1 /* $NetBSD: libdm-deptree.c,v 1.4 2009/12/02 00:58:03 haad Exp $ */ 2 3 /* 4 * Copyright (C) 2005-2007 Red Hat, Inc. All rights reserved. 5 * 6 * This file is part of the device-mapper userspace tools. 7 * 8 * This copyrighted material is made available to anyone wishing to use, 9 * modify, copy, or redistribute it subject to the terms and conditions 10 * of the GNU Lesser General Public License v.2.1. 11 * 12 * You should have received a copy of the GNU Lesser General Public License 13 * along with this program; if not, write to the Free Software Foundation, 14 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 15 */ 16 17 #include "dmlib.h" 18 #include "libdm-targets.h" 19 #include "libdm-common.h" 20 #include "kdev_t.h" 21 #include "dm-ioctl.h" 22 23 #include <stdarg.h> 24 #include <sys/param.h> 25 #include <sys/utsname.h> 26 27 #define MAX_TARGET_PARAMSIZE 500000 28 29 /* FIXME Fix interface so this is used only by LVM */ 30 #define UUID_PREFIX "LVM-" 31 32 /* Supported segment types */ 33 enum { 34 SEG_CRYPT, 35 SEG_ERROR, 36 SEG_LINEAR, 37 SEG_MIRRORED, 38 SEG_SNAPSHOT, 39 SEG_SNAPSHOT_ORIGIN, 40 SEG_STRIPED, 41 SEG_ZERO, 42 }; 43 44 /* FIXME Add crypt and multipath support */ 45 46 struct { 47 unsigned type; 48 const char *target; 49 } dm_segtypes[] = { 50 { SEG_CRYPT, "crypt" }, 51 { SEG_ERROR, "error" }, 52 { SEG_LINEAR, "linear" }, 53 { SEG_MIRRORED, "mirror" }, 54 { SEG_SNAPSHOT, "snapshot" }, 55 { SEG_SNAPSHOT_ORIGIN, "snapshot-origin" }, 56 { SEG_STRIPED, "striped" }, 57 { SEG_ZERO, "zero"}, 58 }; 59 60 /* Some segment types have a list of areas of other devices attached */ 61 struct seg_area { 62 struct dm_list list; 63 64 struct dm_tree_node *dev_node; 65 66 uint64_t offset; 67 }; 68 69 /* Per-segment properties */ 70 struct load_segment { 71 struct dm_list list; 72 73 unsigned type; 74 75 uint64_t size; 76 77 unsigned area_count; /* Linear + Striped + Mirrored + Crypt */ 78 struct dm_list areas; /* Linear + Striped + Mirrored + Crypt */ 79 80 uint32_t stripe_size; /* Striped */ 81 82 int persistent; /* Snapshot */ 83 uint32_t chunk_size; /* Snapshot */ 84 struct dm_tree_node *cow; /* Snapshot */ 85 struct dm_tree_node *origin; /* Snapshot + Snapshot origin */ 86 87 struct dm_tree_node *log; /* Mirror */ 88 uint32_t region_size; /* Mirror */ 89 unsigned clustered; /* Mirror */ 90 unsigned mirror_area_count; /* Mirror */ 91 uint32_t flags; /* Mirror log */ 92 char *uuid; /* Clustered mirror log */ 93 94 const char *cipher; /* Crypt */ 95 const char *chainmode; /* Crypt */ 96 const char *iv; /* Crypt */ 97 uint64_t iv_offset; /* Crypt */ 98 const char *key; /* Crypt */ 99 }; 100 101 /* Per-device properties */ 102 struct load_properties { 103 int read_only; 104 uint32_t major; 105 uint32_t minor; 106 107 uint32_t read_ahead; 108 uint32_t read_ahead_flags; 109 110 unsigned segment_count; 111 unsigned size_changed; 112 struct dm_list segs; 113 114 const char *new_name; 115 }; 116 117 /* Two of these used to join two nodes with uses and used_by. */ 118 struct dm_tree_link { 119 struct dm_list list; 120 struct dm_tree_node *node; 121 }; 122 123 struct dm_tree_node { 124 struct dm_tree *dtree; 125 126 const char *name; 127 const char *uuid; 128 struct dm_info info; 129 130 struct dm_list uses; /* Nodes this node uses */ 131 struct dm_list used_by; /* Nodes that use this node */ 132 133 int activation_priority; /* 0 gets activated first */ 134 135 uint16_t udev_flags; /* Udev control flags */ 136 137 void *context; /* External supplied context */ 138 139 struct load_properties props; /* For creation/table (re)load */ 140 }; 141 142 struct dm_tree { 143 struct dm_pool *mem; 144 struct dm_hash_table *devs; 145 struct dm_hash_table *uuids; 146 struct dm_tree_node root; 147 int skip_lockfs; /* 1 skips lockfs (for non-snapshots) */ 148 int no_flush; /* 1 sets noflush (mirrors/multipath) */ 149 uint32_t cookie; 150 }; 151 152 struct dm_tree *dm_tree_create(void) 153 { 154 struct dm_tree *dtree; 155 156 if (!(dtree = dm_malloc(sizeof(*dtree)))) { 157 log_error("dm_tree_create malloc failed"); 158 return NULL; 159 } 160 161 memset(dtree, 0, sizeof(*dtree)); 162 dtree->root.dtree = dtree; 163 dm_list_init(&dtree->root.uses); 164 dm_list_init(&dtree->root.used_by); 165 dtree->skip_lockfs = 0; 166 dtree->no_flush = 0; 167 168 if (!(dtree->mem = dm_pool_create("dtree", 1024))) { 169 log_error("dtree pool creation failed"); 170 dm_free(dtree); 171 return NULL; 172 } 173 174 if (!(dtree->devs = dm_hash_create(8))) { 175 log_error("dtree hash creation failed"); 176 dm_pool_destroy(dtree->mem); 177 dm_free(dtree); 178 return NULL; 179 } 180 181 if (!(dtree->uuids = dm_hash_create(32))) { 182 log_error("dtree uuid hash creation failed"); 183 dm_hash_destroy(dtree->devs); 184 dm_pool_destroy(dtree->mem); 185 dm_free(dtree); 186 return NULL; 187 } 188 189 return dtree; 190 } 191 192 void dm_tree_free(struct dm_tree *dtree) 193 { 194 if (!dtree) 195 return; 196 197 dm_hash_destroy(dtree->uuids); 198 dm_hash_destroy(dtree->devs); 199 dm_pool_destroy(dtree->mem); 200 dm_free(dtree); 201 } 202 203 static int _nodes_are_linked(struct dm_tree_node *parent, 204 struct dm_tree_node *child) 205 { 206 struct dm_tree_link *dlink; 207 208 dm_list_iterate_items(dlink, &parent->uses) 209 if (dlink->node == child) 210 return 1; 211 212 return 0; 213 } 214 215 static int _link(struct dm_list *list, struct dm_tree_node *node) 216 { 217 struct dm_tree_link *dlink; 218 219 if (!(dlink = dm_pool_alloc(node->dtree->mem, sizeof(*dlink)))) { 220 log_error("dtree link allocation failed"); 221 return 0; 222 } 223 224 dlink->node = node; 225 dm_list_add(list, &dlink->list); 226 227 return 1; 228 } 229 230 static int _link_nodes(struct dm_tree_node *parent, 231 struct dm_tree_node *child) 232 { 233 if (_nodes_are_linked(parent, child)) 234 return 1; 235 236 if (!_link(&parent->uses, child)) 237 return 0; 238 239 if (!_link(&child->used_by, parent)) 240 return 0; 241 242 return 1; 243 } 244 245 static void _unlink(struct dm_list *list, struct dm_tree_node *node) 246 { 247 struct dm_tree_link *dlink; 248 249 dm_list_iterate_items(dlink, list) 250 if (dlink->node == node) { 251 dm_list_del(&dlink->list); 252 break; 253 } 254 } 255 256 static void _unlink_nodes(struct dm_tree_node *parent, 257 struct dm_tree_node *child) 258 { 259 if (!_nodes_are_linked(parent, child)) 260 return; 261 262 _unlink(&parent->uses, child); 263 _unlink(&child->used_by, parent); 264 } 265 266 static int _add_to_toplevel(struct dm_tree_node *node) 267 { 268 return _link_nodes(&node->dtree->root, node); 269 } 270 271 static void _remove_from_toplevel(struct dm_tree_node *node) 272 { 273 return _unlink_nodes(&node->dtree->root, node); 274 } 275 276 static int _add_to_bottomlevel(struct dm_tree_node *node) 277 { 278 return _link_nodes(node, &node->dtree->root); 279 } 280 281 static void _remove_from_bottomlevel(struct dm_tree_node *node) 282 { 283 return _unlink_nodes(node, &node->dtree->root); 284 } 285 286 static int _link_tree_nodes(struct dm_tree_node *parent, struct dm_tree_node *child) 287 { 288 /* Don't link to root node if child already has a parent */ 289 if ((parent == &parent->dtree->root)) { 290 if (dm_tree_node_num_children(child, 1)) 291 return 1; 292 } else 293 _remove_from_toplevel(child); 294 295 if ((child == &child->dtree->root)) { 296 if (dm_tree_node_num_children(parent, 0)) 297 return 1; 298 } else 299 _remove_from_bottomlevel(parent); 300 301 return _link_nodes(parent, child); 302 } 303 304 static struct dm_tree_node *_create_dm_tree_node(struct dm_tree *dtree, 305 const char *name, 306 const char *uuid, 307 struct dm_info *info, 308 void *context, 309 uint16_t udev_flags) 310 { 311 struct dm_tree_node *node; 312 uint64_t dev; 313 314 if (!(node = dm_pool_zalloc(dtree->mem, sizeof(*node)))) { 315 log_error("_create_dm_tree_node alloc failed"); 316 return NULL; 317 } 318 319 node->dtree = dtree; 320 321 node->name = name; 322 node->uuid = uuid; 323 node->info = *info; 324 node->context = context; 325 node->udev_flags = udev_flags; 326 node->activation_priority = 0; 327 328 dm_list_init(&node->uses); 329 dm_list_init(&node->used_by); 330 dm_list_init(&node->props.segs); 331 332 dev = MKDEV(info->major, info->minor); 333 334 if (!dm_hash_insert_binary(dtree->devs, (const char *) &dev, 335 sizeof(dev), node)) { 336 log_error("dtree node hash insertion failed"); 337 dm_pool_free(dtree->mem, node); 338 return NULL; 339 } 340 341 if (uuid && *uuid && 342 !dm_hash_insert(dtree->uuids, uuid, node)) { 343 log_error("dtree uuid hash insertion failed"); 344 dm_hash_remove_binary(dtree->devs, (const char *) &dev, 345 sizeof(dev)); 346 dm_pool_free(dtree->mem, node); 347 return NULL; 348 } 349 350 return node; 351 } 352 353 static struct dm_tree_node *_find_dm_tree_node(struct dm_tree *dtree, 354 uint32_t major, uint32_t minor) 355 { 356 uint64_t dev = MKDEV(major, minor); 357 358 return dm_hash_lookup_binary(dtree->devs, (const char *) &dev, 359 sizeof(dev)); 360 } 361 362 static struct dm_tree_node *_find_dm_tree_node_by_uuid(struct dm_tree *dtree, 363 const char *uuid) 364 { 365 struct dm_tree_node *node; 366 367 if ((node = dm_hash_lookup(dtree->uuids, uuid))) 368 return node; 369 370 if (strncmp(uuid, UUID_PREFIX, sizeof(UUID_PREFIX) - 1)) 371 return NULL; 372 373 return dm_hash_lookup(dtree->uuids, uuid + sizeof(UUID_PREFIX) - 1); 374 } 375 376 static int _deps(struct dm_task **dmt, struct dm_pool *mem, uint32_t major, uint32_t minor, 377 const char **name, const char **uuid, 378 struct dm_info *info, struct dm_deps **deps) 379 { 380 memset(info, 0, sizeof(*info)); 381 382 if (!dm_is_dm_major(major)) { 383 *name = ""; 384 *uuid = ""; 385 *deps = NULL; 386 info->major = major; 387 info->minor = minor; 388 info->exists = 0; 389 info->live_table = 0; 390 info->inactive_table = 0; 391 info->read_only = 0; 392 return 1; 393 } 394 395 if (!(*dmt = dm_task_create(DM_DEVICE_DEPS))) { 396 log_error("deps dm_task creation failed"); 397 return 0; 398 } 399 400 if (!dm_task_set_major(*dmt, major)) { 401 log_error("_deps: failed to set major for (%" PRIu32 ":%" PRIu32 ")", 402 major, minor); 403 goto failed; 404 } 405 406 if (!dm_task_set_minor(*dmt, minor)) { 407 log_error("_deps: failed to set minor for (%" PRIu32 ":%" PRIu32 ")", 408 major, minor); 409 goto failed; 410 } 411 412 if (!dm_task_run(*dmt)) { 413 log_error("_deps: task run failed for (%" PRIu32 ":%" PRIu32 ")", 414 major, minor); 415 goto failed; 416 } 417 418 if (!dm_task_get_info(*dmt, info)) { 419 log_error("_deps: failed to get info for (%" PRIu32 ":%" PRIu32 ")", 420 major, minor); 421 goto failed; 422 } 423 424 if (!info->exists) { 425 *name = ""; 426 *uuid = ""; 427 *deps = NULL; 428 } else { 429 if (info->major != major) { 430 log_error("Inconsistent dtree major number: %u != %u", 431 major, info->major); 432 goto failed; 433 } 434 if (info->minor != minor) { 435 log_error("Inconsistent dtree minor number: %u != %u", 436 minor, info->minor); 437 goto failed; 438 } 439 if (!(*name = dm_pool_strdup(mem, dm_task_get_name(*dmt)))) { 440 log_error("name pool_strdup failed"); 441 goto failed; 442 } 443 if (!(*uuid = dm_pool_strdup(mem, dm_task_get_uuid(*dmt)))) { 444 log_error("uuid pool_strdup failed"); 445 goto failed; 446 } 447 *deps = dm_task_get_deps(*dmt); 448 } 449 450 return 1; 451 452 failed: 453 dm_task_destroy(*dmt); 454 return 0; 455 } 456 457 static struct dm_tree_node *_add_dev(struct dm_tree *dtree, 458 struct dm_tree_node *parent, 459 uint32_t major, uint32_t minor) 460 { 461 struct dm_task *dmt = NULL; 462 struct dm_info info; 463 struct dm_deps *deps = NULL; 464 const char *name = NULL; 465 const char *uuid = NULL; 466 struct dm_tree_node *node = NULL; 467 uint32_t i; 468 int new = 0; 469 470 /* Already in tree? */ 471 if (!(node = _find_dm_tree_node(dtree, major, minor))) { 472 if (!_deps(&dmt, dtree->mem, major, minor, &name, &uuid, &info, &deps)) 473 return_NULL; 474 475 if (!(node = _create_dm_tree_node(dtree, name, uuid, &info, 476 NULL, 0))) 477 goto_out; 478 new = 1; 479 } 480 481 if (!_link_tree_nodes(parent, node)) { 482 node = NULL; 483 goto_out; 484 } 485 486 /* If node was already in tree, no need to recurse. */ 487 if (!new) 488 goto out; 489 490 /* Can't recurse if not a mapped device or there are no dependencies */ 491 if (!node->info.exists || !deps->count) { 492 if (!_add_to_bottomlevel(node)) { 493 stack; 494 node = NULL; 495 } 496 goto out; 497 } 498 499 /* Add dependencies to tree */ 500 for (i = 0; i < deps->count; i++) 501 if (!_add_dev(dtree, node, MAJOR(deps->device[i]), 502 MINOR(deps->device[i]))) { 503 node = NULL; 504 goto_out; 505 } 506 507 out: 508 if (dmt) 509 dm_task_destroy(dmt); 510 511 return node; 512 } 513 514 static int _node_clear_table(struct dm_tree_node *dnode) 515 { 516 struct dm_task *dmt; 517 struct dm_info *info; 518 const char *name; 519 int r; 520 521 if (!(info = &dnode->info)) { 522 log_error("_node_clear_table failed: missing info"); 523 return 0; 524 } 525 526 if (!(name = dm_tree_node_get_name(dnode))) { 527 log_error("_node_clear_table failed: missing name"); 528 return 0; 529 } 530 531 /* Is there a table? */ 532 if (!info->exists || !info->inactive_table) 533 return 1; 534 535 log_verbose("Clearing inactive table %s (%" PRIu32 ":%" PRIu32 ")", 536 name, info->major, info->minor); 537 538 if (!(dmt = dm_task_create(DM_DEVICE_CLEAR))) { 539 dm_task_destroy(dmt); 540 log_error("Table clear dm_task creation failed for %s", name); 541 return 0; 542 } 543 544 if (!dm_task_set_major(dmt, info->major) || 545 !dm_task_set_minor(dmt, info->minor)) { 546 log_error("Failed to set device number for %s table clear", name); 547 dm_task_destroy(dmt); 548 return 0; 549 } 550 551 r = dm_task_run(dmt); 552 553 if (!dm_task_get_info(dmt, info)) { 554 log_error("_node_clear_table failed: info missing after running task for %s", name); 555 r = 0; 556 } 557 558 dm_task_destroy(dmt); 559 560 return r; 561 } 562 563 struct dm_tree_node *dm_tree_add_new_dev(struct dm_tree *dtree, 564 const char *name, 565 const char *uuid, 566 uint32_t major, uint32_t minor, 567 int read_only, 568 int clear_inactive, 569 void *context) 570 { 571 struct dm_tree_node *dnode; 572 struct dm_info info; 573 const char *name2; 574 const char *uuid2; 575 576 /* Do we need to add node to tree? */ 577 if (!(dnode = dm_tree_find_node_by_uuid(dtree, uuid))) { 578 if (!(name2 = dm_pool_strdup(dtree->mem, name))) { 579 log_error("name pool_strdup failed"); 580 return NULL; 581 } 582 if (!(uuid2 = dm_pool_strdup(dtree->mem, uuid))) { 583 log_error("uuid pool_strdup failed"); 584 return NULL; 585 } 586 587 info.major = 0; 588 info.minor = 0; 589 info.exists = 0; 590 info.live_table = 0; 591 info.inactive_table = 0; 592 info.read_only = 0; 593 594 if (!(dnode = _create_dm_tree_node(dtree, name2, uuid2, &info, 595 context, 0))) 596 return_NULL; 597 598 /* Attach to root node until a table is supplied */ 599 if (!_add_to_toplevel(dnode) || !_add_to_bottomlevel(dnode)) 600 return_NULL; 601 602 dnode->props.major = major; 603 dnode->props.minor = minor; 604 dnode->props.new_name = NULL; 605 dnode->props.size_changed = 0; 606 } else if (strcmp(name, dnode->name)) { 607 /* Do we need to rename node? */ 608 if (!(dnode->props.new_name = dm_pool_strdup(dtree->mem, name))) { 609 log_error("name pool_strdup failed"); 610 return 0; 611 } 612 } 613 614 dnode->props.read_only = read_only ? 1 : 0; 615 dnode->props.read_ahead = DM_READ_AHEAD_AUTO; 616 dnode->props.read_ahead_flags = 0; 617 618 if (clear_inactive && !_node_clear_table(dnode)) 619 return_NULL; 620 621 dnode->context = context; 622 dnode->udev_flags = 0; 623 624 return dnode; 625 } 626 627 struct dm_tree_node *dm_tree_add_new_dev_with_udev_flags(struct dm_tree *dtree, 628 const char *name, 629 const char *uuid, 630 uint32_t major, 631 uint32_t minor, 632 int read_only, 633 int clear_inactive, 634 void *context, 635 uint16_t udev_flags) 636 { 637 struct dm_tree_node *node; 638 639 if ((node = dm_tree_add_new_dev(dtree, name, uuid, major, minor, read_only, 640 clear_inactive, context))) 641 node->udev_flags = udev_flags; 642 643 return node; 644 } 645 646 647 void dm_tree_node_set_read_ahead(struct dm_tree_node *dnode, 648 uint32_t read_ahead, 649 uint32_t read_ahead_flags) 650 { 651 dnode->props.read_ahead = read_ahead; 652 dnode->props.read_ahead_flags = read_ahead_flags; 653 } 654 655 int dm_tree_add_dev(struct dm_tree *dtree, uint32_t major, uint32_t minor) 656 { 657 return _add_dev(dtree, &dtree->root, major, minor) ? 1 : 0; 658 } 659 660 const char *dm_tree_node_get_name(struct dm_tree_node *node) 661 { 662 return node->info.exists ? node->name : ""; 663 } 664 665 const char *dm_tree_node_get_uuid(struct dm_tree_node *node) 666 { 667 return node->info.exists ? node->uuid : ""; 668 } 669 670 const struct dm_info *dm_tree_node_get_info(struct dm_tree_node *node) 671 { 672 return &node->info; 673 } 674 675 void *dm_tree_node_get_context(struct dm_tree_node *node) 676 { 677 return node->context; 678 } 679 680 int dm_tree_node_size_changed(struct dm_tree_node *dnode) 681 { 682 return dnode->props.size_changed; 683 } 684 685 int dm_tree_node_num_children(struct dm_tree_node *node, uint32_t inverted) 686 { 687 if (inverted) { 688 if (_nodes_are_linked(&node->dtree->root, node)) 689 return 0; 690 return dm_list_size(&node->used_by); 691 } 692 693 if (_nodes_are_linked(node, &node->dtree->root)) 694 return 0; 695 696 return dm_list_size(&node->uses); 697 } 698 699 /* 700 * Returns 1 if no prefix supplied 701 */ 702 static int _uuid_prefix_matches(const char *uuid, const char *uuid_prefix, size_t uuid_prefix_len) 703 { 704 if (!uuid_prefix) 705 return 1; 706 707 if (!strncmp(uuid, uuid_prefix, uuid_prefix_len)) 708 return 1; 709 710 /* Handle transition: active device uuids might be missing the prefix */ 711 if (uuid_prefix_len <= 4) 712 return 0; 713 714 if (!strncmp(uuid, UUID_PREFIX, sizeof(UUID_PREFIX) - 1)) 715 return 0; 716 717 if (strncmp(uuid_prefix, UUID_PREFIX, sizeof(UUID_PREFIX) - 1)) 718 return 0; 719 720 if (!strncmp(uuid, uuid_prefix + sizeof(UUID_PREFIX) - 1, uuid_prefix_len - (sizeof(UUID_PREFIX) - 1))) 721 return 1; 722 723 return 0; 724 } 725 726 /* 727 * Returns 1 if no children. 728 */ 729 static int _children_suspended(struct dm_tree_node *node, 730 uint32_t inverted, 731 const char *uuid_prefix, 732 size_t uuid_prefix_len) 733 { 734 struct dm_list *list; 735 struct dm_tree_link *dlink; 736 const struct dm_info *dinfo; 737 const char *uuid; 738 739 if (inverted) { 740 if (_nodes_are_linked(&node->dtree->root, node)) 741 return 1; 742 list = &node->used_by; 743 } else { 744 if (_nodes_are_linked(node, &node->dtree->root)) 745 return 1; 746 list = &node->uses; 747 } 748 749 dm_list_iterate_items(dlink, list) { 750 if (!(uuid = dm_tree_node_get_uuid(dlink->node))) { 751 stack; 752 continue; 753 } 754 755 /* Ignore if it doesn't belong to this VG */ 756 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len)) 757 continue; 758 759 if (!(dinfo = dm_tree_node_get_info(dlink->node))) { 760 stack; /* FIXME Is this normal? */ 761 return 0; 762 } 763 764 if (!dinfo->suspended) 765 return 0; 766 } 767 768 return 1; 769 } 770 771 /* 772 * Set major and minor to zero for root of tree. 773 */ 774 struct dm_tree_node *dm_tree_find_node(struct dm_tree *dtree, 775 uint32_t major, 776 uint32_t minor) 777 { 778 if (!major && !minor) 779 return &dtree->root; 780 781 return _find_dm_tree_node(dtree, major, minor); 782 } 783 784 /* 785 * Set uuid to NULL for root of tree. 786 */ 787 struct dm_tree_node *dm_tree_find_node_by_uuid(struct dm_tree *dtree, 788 const char *uuid) 789 { 790 if (!uuid || !*uuid) 791 return &dtree->root; 792 793 return _find_dm_tree_node_by_uuid(dtree, uuid); 794 } 795 796 /* 797 * First time set *handle to NULL. 798 * Set inverted to invert the tree. 799 */ 800 struct dm_tree_node *dm_tree_next_child(void **handle, 801 struct dm_tree_node *parent, 802 uint32_t inverted) 803 { 804 struct dm_list **dlink = (struct dm_list **) handle; 805 struct dm_list *use_list; 806 807 if (inverted) 808 use_list = &parent->used_by; 809 else 810 use_list = &parent->uses; 811 812 if (!*dlink) 813 *dlink = dm_list_first(use_list); 814 else 815 *dlink = dm_list_next(use_list, *dlink); 816 817 return (*dlink) ? dm_list_item(*dlink, struct dm_tree_link)->node : NULL; 818 } 819 820 /* 821 * Deactivate a device with its dependencies if the uuid prefix matches. 822 */ 823 static int _info_by_dev(uint32_t major, uint32_t minor, int with_open_count, 824 struct dm_info *info) 825 { 826 struct dm_task *dmt; 827 int r; 828 829 if (!(dmt = dm_task_create(DM_DEVICE_INFO))) { 830 log_error("_info_by_dev: dm_task creation failed"); 831 return 0; 832 } 833 834 if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) { 835 log_error("_info_by_dev: Failed to set device number"); 836 dm_task_destroy(dmt); 837 return 0; 838 } 839 840 if (!with_open_count && !dm_task_no_open_count(dmt)) 841 log_error("Failed to disable open_count"); 842 843 if ((r = dm_task_run(dmt))) 844 r = dm_task_get_info(dmt, info); 845 846 dm_task_destroy(dmt); 847 848 return r; 849 } 850 851 static int _deactivate_node(const char *name, uint32_t major, uint32_t minor, 852 uint32_t *cookie, uint16_t udev_flags) 853 { 854 struct dm_task *dmt; 855 int r = 0; 856 857 log_verbose("Removing %s (%" PRIu32 ":%" PRIu32 ")", name, major, minor); 858 859 if (!(dmt = dm_task_create(DM_DEVICE_REMOVE))) { 860 log_error("Deactivation dm_task creation failed for %s", name); 861 return 0; 862 } 863 864 if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) { 865 log_error("Failed to set device number for %s deactivation", name); 866 goto out; 867 } 868 869 if (!dm_task_no_open_count(dmt)) 870 log_error("Failed to disable open_count"); 871 872 if (!dm_task_set_cookie(dmt, cookie, udev_flags)) 873 goto out; 874 875 r = dm_task_run(dmt); 876 877 /* FIXME Until kernel returns actual name so dm-ioctl.c can handle it */ 878 rm_dev_node(name, dmt->cookie_set); 879 880 /* FIXME Remove node from tree or mark invalid? */ 881 882 out: 883 dm_task_destroy(dmt); 884 885 return r; 886 } 887 888 static int _rename_node(const char *old_name, const char *new_name, uint32_t major, 889 uint32_t minor, uint32_t *cookie, uint16_t udev_flags) 890 { 891 struct dm_task *dmt; 892 int r = 0; 893 894 log_verbose("Renaming %s (%" PRIu32 ":%" PRIu32 ") to %s", old_name, major, minor, new_name); 895 896 if (!(dmt = dm_task_create(DM_DEVICE_RENAME))) { 897 log_error("Rename dm_task creation failed for %s", old_name); 898 return 0; 899 } 900 901 if (!dm_task_set_name(dmt, old_name)) { 902 log_error("Failed to set name for %s rename.", old_name); 903 goto out; 904 } 905 906 if (!dm_task_set_newname(dmt, new_name)) 907 goto_out; 908 909 if (!dm_task_no_open_count(dmt)) 910 log_error("Failed to disable open_count"); 911 912 if (!dm_task_set_cookie(dmt, cookie, udev_flags)) 913 goto out; 914 915 r = dm_task_run(dmt); 916 917 out: 918 dm_task_destroy(dmt); 919 920 return r; 921 } 922 923 /* FIXME Merge with _suspend_node? */ 924 static int _resume_node(const char *name, uint32_t major, uint32_t minor, 925 uint32_t read_ahead, uint32_t read_ahead_flags, 926 struct dm_info *newinfo, uint32_t *cookie, 927 uint16_t udev_flags) 928 { 929 struct dm_task *dmt; 930 int r = 0; 931 932 log_verbose("Resuming %s (%" PRIu32 ":%" PRIu32 ")", name, major, minor); 933 934 if (!(dmt = dm_task_create(DM_DEVICE_RESUME))) { 935 log_error("Suspend dm_task creation failed for %s", name); 936 return 0; 937 } 938 939 /* FIXME Kernel should fill in name on return instead */ 940 if (!dm_task_set_name(dmt, name)) { 941 log_error("Failed to set readahead device name for %s", name); 942 goto out; 943 } 944 945 if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) { 946 log_error("Failed to set device number for %s resumption.", name); 947 goto out; 948 } 949 950 if (!dm_task_no_open_count(dmt)) 951 log_error("Failed to disable open_count"); 952 953 if (!dm_task_set_read_ahead(dmt, read_ahead, read_ahead_flags)) 954 log_error("Failed to set read ahead"); 955 956 if (!dm_task_set_cookie(dmt, cookie, udev_flags)) 957 goto out; 958 959 if ((r = dm_task_run(dmt))) 960 r = dm_task_get_info(dmt, newinfo); 961 962 out: 963 dm_task_destroy(dmt); 964 965 return r; 966 } 967 968 static int _suspend_node(const char *name, uint32_t major, uint32_t minor, 969 int skip_lockfs, int no_flush, struct dm_info *newinfo) 970 { 971 struct dm_task *dmt; 972 int r; 973 974 log_verbose("Suspending %s (%" PRIu32 ":%" PRIu32 ")%s%s", 975 name, major, minor, 976 skip_lockfs ? "" : " with filesystem sync", 977 no_flush ? "" : " with device flush"); 978 979 if (!(dmt = dm_task_create(DM_DEVICE_SUSPEND))) { 980 log_error("Suspend dm_task creation failed for %s", name); 981 return 0; 982 } 983 984 if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) { 985 log_error("Failed to set device number for %s suspension.", name); 986 dm_task_destroy(dmt); 987 return 0; 988 } 989 990 if (!dm_task_no_open_count(dmt)) 991 log_error("Failed to disable open_count"); 992 993 if (skip_lockfs && !dm_task_skip_lockfs(dmt)) 994 log_error("Failed to set skip_lockfs flag."); 995 996 if (no_flush && !dm_task_no_flush(dmt)) 997 log_error("Failed to set no_flush flag."); 998 999 if ((r = dm_task_run(dmt))) 1000 r = dm_task_get_info(dmt, newinfo); 1001 1002 dm_task_destroy(dmt); 1003 1004 return r; 1005 } 1006 1007 int dm_tree_deactivate_children(struct dm_tree_node *dnode, 1008 const char *uuid_prefix, 1009 size_t uuid_prefix_len) 1010 { 1011 void *handle = NULL; 1012 struct dm_tree_node *child = dnode; 1013 struct dm_info info; 1014 const struct dm_info *dinfo; 1015 const char *name; 1016 const char *uuid; 1017 1018 while ((child = dm_tree_next_child(&handle, dnode, 0))) { 1019 if (!(dinfo = dm_tree_node_get_info(child))) { 1020 stack; 1021 continue; 1022 } 1023 1024 if (!(name = dm_tree_node_get_name(child))) { 1025 stack; 1026 continue; 1027 } 1028 1029 if (!(uuid = dm_tree_node_get_uuid(child))) { 1030 stack; 1031 continue; 1032 } 1033 1034 /* Ignore if it doesn't belong to this VG */ 1035 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len)) 1036 continue; 1037 1038 /* Refresh open_count */ 1039 if (!_info_by_dev(dinfo->major, dinfo->minor, 1, &info) || 1040 !info.exists || info.open_count) 1041 continue; 1042 1043 if (!_deactivate_node(name, info.major, info.minor, 1044 &child->dtree->cookie, child->udev_flags)) { 1045 log_error("Unable to deactivate %s (%" PRIu32 1046 ":%" PRIu32 ")", name, info.major, 1047 info.minor); 1048 continue; 1049 } 1050 1051 if (dm_tree_node_num_children(child, 0)) 1052 dm_tree_deactivate_children(child, uuid_prefix, uuid_prefix_len); 1053 } 1054 1055 return 1; 1056 } 1057 1058 void dm_tree_skip_lockfs(struct dm_tree_node *dnode) 1059 { 1060 dnode->dtree->skip_lockfs = 1; 1061 } 1062 1063 void dm_tree_use_no_flush_suspend(struct dm_tree_node *dnode) 1064 { 1065 dnode->dtree->no_flush = 1; 1066 } 1067 1068 int dm_tree_suspend_children(struct dm_tree_node *dnode, 1069 const char *uuid_prefix, 1070 size_t uuid_prefix_len) 1071 { 1072 void *handle = NULL; 1073 struct dm_tree_node *child = dnode; 1074 struct dm_info info, newinfo; 1075 const struct dm_info *dinfo; 1076 const char *name; 1077 const char *uuid; 1078 1079 /* Suspend nodes at this level of the tree */ 1080 while ((child = dm_tree_next_child(&handle, dnode, 0))) { 1081 if (!(dinfo = dm_tree_node_get_info(child))) { 1082 stack; 1083 continue; 1084 } 1085 1086 if (!(name = dm_tree_node_get_name(child))) { 1087 stack; 1088 continue; 1089 } 1090 1091 if (!(uuid = dm_tree_node_get_uuid(child))) { 1092 stack; 1093 continue; 1094 } 1095 1096 /* Ignore if it doesn't belong to this VG */ 1097 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len)) 1098 continue; 1099 1100 /* Ensure immediate parents are already suspended */ 1101 if (!_children_suspended(child, 1, uuid_prefix, uuid_prefix_len)) 1102 continue; 1103 1104 if (!_info_by_dev(dinfo->major, dinfo->minor, 0, &info) || 1105 !info.exists || info.suspended) 1106 continue; 1107 1108 if (!_suspend_node(name, info.major, info.minor, 1109 child->dtree->skip_lockfs, 1110 child->dtree->no_flush, &newinfo)) { 1111 log_error("Unable to suspend %s (%" PRIu32 1112 ":%" PRIu32 ")", name, info.major, 1113 info.minor); 1114 continue; 1115 } 1116 1117 /* Update cached info */ 1118 child->info = newinfo; 1119 } 1120 1121 /* Then suspend any child nodes */ 1122 handle = NULL; 1123 1124 while ((child = dm_tree_next_child(&handle, dnode, 0))) { 1125 if (!(uuid = dm_tree_node_get_uuid(child))) { 1126 stack; 1127 continue; 1128 } 1129 1130 /* Ignore if it doesn't belong to this VG */ 1131 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len)) 1132 continue; 1133 1134 if (dm_tree_node_num_children(child, 0)) 1135 dm_tree_suspend_children(child, uuid_prefix, uuid_prefix_len); 1136 } 1137 1138 return 1; 1139 } 1140 1141 int dm_tree_activate_children(struct dm_tree_node *dnode, 1142 const char *uuid_prefix, 1143 size_t uuid_prefix_len) 1144 { 1145 void *handle = NULL; 1146 struct dm_tree_node *child = dnode; 1147 struct dm_info newinfo; 1148 const char *name; 1149 const char *uuid; 1150 int priority; 1151 1152 /* Activate children first */ 1153 while ((child = dm_tree_next_child(&handle, dnode, 0))) { 1154 if (!(uuid = dm_tree_node_get_uuid(child))) { 1155 stack; 1156 continue; 1157 } 1158 1159 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len)) 1160 continue; 1161 1162 if (dm_tree_node_num_children(child, 0)) 1163 dm_tree_activate_children(child, uuid_prefix, uuid_prefix_len); 1164 } 1165 1166 handle = NULL; 1167 1168 for (priority = 0; priority < 2; priority++) { 1169 while ((child = dm_tree_next_child(&handle, dnode, 0))) { 1170 if (!(uuid = dm_tree_node_get_uuid(child))) { 1171 stack; 1172 continue; 1173 } 1174 1175 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len)) 1176 continue; 1177 1178 if (priority != child->activation_priority) 1179 continue; 1180 1181 if (!(name = dm_tree_node_get_name(child))) { 1182 stack; 1183 continue; 1184 } 1185 1186 /* Rename? */ 1187 if (child->props.new_name) { 1188 if (!_rename_node(name, child->props.new_name, child->info.major, 1189 child->info.minor, &child->dtree->cookie, 1190 child->udev_flags)) { 1191 log_error("Failed to rename %s (%" PRIu32 1192 ":%" PRIu32 ") to %s", name, child->info.major, 1193 child->info.minor, child->props.new_name); 1194 return 0; 1195 } 1196 child->name = child->props.new_name; 1197 child->props.new_name = NULL; 1198 } 1199 1200 if (!child->info.inactive_table && !child->info.suspended) 1201 continue; 1202 1203 if (!_resume_node(child->name, child->info.major, child->info.minor, 1204 child->props.read_ahead, child->props.read_ahead_flags, 1205 &newinfo, &child->dtree->cookie, child->udev_flags)) { 1206 log_error("Unable to resume %s (%" PRIu32 1207 ":%" PRIu32 ")", child->name, child->info.major, 1208 child->info.minor); 1209 continue; 1210 } 1211 1212 /* Update cached info */ 1213 child->info = newinfo; 1214 } 1215 } 1216 1217 handle = NULL; 1218 1219 return 1; 1220 } 1221 1222 static int _create_node(struct dm_tree_node *dnode) 1223 { 1224 int r = 0; 1225 struct dm_task *dmt; 1226 1227 log_verbose("Creating %s", dnode->name); 1228 1229 if (!(dmt = dm_task_create(DM_DEVICE_CREATE))) { 1230 log_error("Create dm_task creation failed for %s", dnode->name); 1231 return 0; 1232 } 1233 1234 if (!dm_task_set_name(dmt, dnode->name)) { 1235 log_error("Failed to set device name for %s", dnode->name); 1236 goto out; 1237 } 1238 1239 if (!dm_task_set_uuid(dmt, dnode->uuid)) { 1240 log_error("Failed to set uuid for %s", dnode->name); 1241 goto out; 1242 } 1243 1244 if (dnode->props.major && 1245 (!dm_task_set_major(dmt, dnode->props.major) || 1246 !dm_task_set_minor(dmt, dnode->props.minor))) { 1247 log_error("Failed to set device number for %s creation.", dnode->name); 1248 goto out; 1249 } 1250 1251 if (dnode->props.read_only && !dm_task_set_ro(dmt)) { 1252 log_error("Failed to set read only flag for %s", dnode->name); 1253 goto out; 1254 } 1255 1256 if (!dm_task_no_open_count(dmt)) 1257 log_error("Failed to disable open_count"); 1258 1259 if ((r = dm_task_run(dmt))) 1260 r = dm_task_get_info(dmt, &dnode->info); 1261 1262 out: 1263 dm_task_destroy(dmt); 1264 1265 return r; 1266 } 1267 1268 1269 static int _build_dev_string(char *devbuf, size_t bufsize, struct dm_tree_node *node) 1270 { 1271 if (!dm_format_dev(devbuf, bufsize, node->info.major, node->info.minor)) { 1272 log_error("Failed to format %s device number for %s as dm " 1273 "target (%u,%u)", 1274 node->name, node->uuid, node->info.major, node->info.minor); 1275 return 0; 1276 } 1277 1278 return 1; 1279 } 1280 1281 /* simplify string emiting code */ 1282 #define EMIT_PARAMS(p, str...)\ 1283 do {\ 1284 int w;\ 1285 if ((w = dm_snprintf(params + p, paramsize - (size_t) p, str)) < 0) {\ 1286 stack; /* Out of space */\ 1287 return -1;\ 1288 }\ 1289 p += w;\ 1290 } while (0) 1291 1292 /* 1293 * _emit_areas_line 1294 * 1295 * Returns: 1 on success, 0 on failure 1296 */ 1297 static int _emit_areas_line(struct dm_task *dmt __attribute((unused)), 1298 struct load_segment *seg, char *params, 1299 size_t paramsize, int *pos) 1300 { 1301 struct seg_area *area; 1302 char devbuf[DM_FORMAT_DEV_BUFSIZE]; 1303 unsigned first_time = 1; 1304 1305 dm_list_iterate_items(area, &seg->areas) { 1306 if (!_build_dev_string(devbuf, sizeof(devbuf), area->dev_node)) 1307 return_0; 1308 1309 EMIT_PARAMS(*pos, "%s%s %" PRIu64, first_time ? "" : " ", 1310 devbuf, area->offset); 1311 1312 first_time = 0; 1313 } 1314 1315 return 1; 1316 } 1317 1318 /* 1319 * Returns: 1 on success, 0 on failure 1320 */ 1321 static int _mirror_emit_segment_line(struct dm_task *dmt, uint32_t major, 1322 uint32_t minor, struct load_segment *seg, 1323 uint64_t *seg_start, char *params, 1324 size_t paramsize) 1325 { 1326 int r; 1327 int block_on_error = 0; 1328 int handle_errors = 0; 1329 int dm_log_userspace = 0; 1330 struct utsname uts; 1331 unsigned log_parm_count; 1332 int pos = 0; 1333 char logbuf[DM_FORMAT_DEV_BUFSIZE]; 1334 const char *logtype; 1335 1336 r = uname(&uts); 1337 if (r) 1338 return_0; 1339 1340 if ((seg->flags & DM_BLOCK_ON_ERROR)) { 1341 /* 1342 * Originally, block_on_error was an argument to the log 1343 * portion of the mirror CTR table. It was renamed to 1344 * "handle_errors" and now resides in the 'features' 1345 * section of the mirror CTR table (i.e. at the end). 1346 * 1347 * We can identify whether to use "block_on_error" or 1348 * "handle_errors" by the dm-mirror module's version 1349 * number (>= 1.12) or by the kernel version (>= 2.6.22). 1350 */ 1351 if (strncmp(uts.release, "2.6.22", 6) >= 0) 1352 handle_errors = 1; 1353 else 1354 block_on_error = 1; 1355 } 1356 1357 if (seg->clustered) { 1358 /* Cluster mirrors require a UUID */ 1359 if (!seg->uuid) 1360 return_0; 1361 1362 /* 1363 * Cluster mirrors used to have their own log 1364 * types. Now they are accessed through the 1365 * userspace log type. 1366 * 1367 * The dm-log-userspace module was added to the 1368 * 2.6.31 kernel. 1369 */ 1370 if (strncmp(uts.release, "2.6.31", 6) >= 0) 1371 dm_log_userspace = 1; 1372 } 1373 1374 /* Region size */ 1375 log_parm_count = 1; 1376 1377 /* [no]sync, block_on_error etc. */ 1378 log_parm_count += hweight32(seg->flags); 1379 1380 /* "handle_errors" is a feature arg now */ 1381 if (handle_errors) 1382 log_parm_count--; 1383 1384 /* DM_CORELOG does not count in the param list */ 1385 if (seg->flags & DM_CORELOG) 1386 log_parm_count--; 1387 1388 if (seg->clustered) { 1389 log_parm_count++; /* For UUID */ 1390 1391 if (!dm_log_userspace) 1392 EMIT_PARAMS(pos, "clustered-"); 1393 } 1394 1395 if (!seg->log) 1396 logtype = "core"; 1397 else { 1398 logtype = "disk"; 1399 log_parm_count++; 1400 if (!_build_dev_string(logbuf, sizeof(logbuf), seg->log)) 1401 return_0; 1402 } 1403 1404 if (dm_log_userspace) 1405 EMIT_PARAMS(pos, "userspace %u %s clustered-%s", 1406 log_parm_count, seg->uuid, logtype); 1407 else 1408 EMIT_PARAMS(pos, "%s %u", logtype, log_parm_count); 1409 1410 if (seg->log) 1411 EMIT_PARAMS(pos, " %s", logbuf); 1412 1413 EMIT_PARAMS(pos, " %u", seg->region_size); 1414 1415 if (seg->clustered && !dm_log_userspace) 1416 EMIT_PARAMS(pos, " %s", seg->uuid); 1417 1418 if ((seg->flags & DM_NOSYNC)) 1419 EMIT_PARAMS(pos, " nosync"); 1420 else if ((seg->flags & DM_FORCESYNC)) 1421 EMIT_PARAMS(pos, " sync"); 1422 1423 if (block_on_error) 1424 EMIT_PARAMS(pos, " block_on_error"); 1425 1426 EMIT_PARAMS(pos, " %u ", seg->mirror_area_count); 1427 1428 if ((r = _emit_areas_line(dmt, seg, params, paramsize, &pos)) <= 0) 1429 return_0; 1430 1431 if (handle_errors) 1432 EMIT_PARAMS(pos, " 1 handle_errors"); 1433 1434 return 1; 1435 } 1436 1437 static int _emit_segment_line(struct dm_task *dmt, uint32_t major, 1438 uint32_t minor, struct load_segment *seg, 1439 uint64_t *seg_start, char *params, 1440 size_t paramsize) 1441 { 1442 int pos = 0; 1443 int r; 1444 char originbuf[DM_FORMAT_DEV_BUFSIZE], cowbuf[DM_FORMAT_DEV_BUFSIZE]; 1445 1446 switch(seg->type) { 1447 case SEG_ERROR: 1448 case SEG_ZERO: 1449 case SEG_LINEAR: 1450 break; 1451 case SEG_MIRRORED: 1452 /* Mirrors are pretty complicated - now in separate function */ 1453 r = _mirror_emit_segment_line(dmt, major, minor, seg, seg_start, 1454 params, paramsize); 1455 if (!r) 1456 return_0; 1457 break; 1458 case SEG_SNAPSHOT: 1459 if (!_build_dev_string(originbuf, sizeof(originbuf), seg->origin)) 1460 return_0; 1461 if (!_build_dev_string(cowbuf, sizeof(cowbuf), seg->cow)) 1462 return_0; 1463 EMIT_PARAMS(pos, "%s %s %c %d", originbuf, cowbuf, 1464 seg->persistent ? 'P' : 'N', seg->chunk_size); 1465 break; 1466 case SEG_SNAPSHOT_ORIGIN: 1467 if (!_build_dev_string(originbuf, sizeof(originbuf), seg->origin)) 1468 return_0; 1469 EMIT_PARAMS(pos, "%s", originbuf); 1470 break; 1471 case SEG_STRIPED: 1472 EMIT_PARAMS(pos, "%u %u ", seg->area_count, seg->stripe_size); 1473 break; 1474 case SEG_CRYPT: 1475 EMIT_PARAMS(pos, "%s%s%s%s%s %s %" PRIu64 " ", seg->cipher, 1476 seg->chainmode ? "-" : "", seg->chainmode ?: "", 1477 seg->iv ? "-" : "", seg->iv ?: "", seg->key, 1478 seg->iv_offset != DM_CRYPT_IV_DEFAULT ? 1479 seg->iv_offset : *seg_start); 1480 break; 1481 } 1482 1483 switch(seg->type) { 1484 case SEG_ERROR: 1485 case SEG_SNAPSHOT: 1486 case SEG_SNAPSHOT_ORIGIN: 1487 case SEG_ZERO: 1488 break; 1489 case SEG_CRYPT: 1490 case SEG_LINEAR: 1491 case SEG_STRIPED: 1492 if ((r = _emit_areas_line(dmt, seg, params, paramsize, &pos)) <= 0) { 1493 stack; 1494 return r; 1495 } 1496 break; 1497 } 1498 1499 log_debug("Adding target to (%" PRIu32 ":%" PRIu32 "): %" PRIu64 1500 " %" PRIu64 " %s %s", major, minor, 1501 *seg_start, seg->size, dm_segtypes[seg->type].target, params); 1502 1503 if (!dm_task_add_target(dmt, *seg_start, seg->size, dm_segtypes[seg->type].target, params)) 1504 return_0; 1505 1506 *seg_start += seg->size; 1507 1508 return 1; 1509 } 1510 1511 #undef EMIT_PARAMS 1512 1513 static int _emit_segment(struct dm_task *dmt, uint32_t major, uint32_t minor, 1514 struct load_segment *seg, uint64_t *seg_start) 1515 { 1516 char *params; 1517 size_t paramsize = 4096; 1518 int ret; 1519 1520 do { 1521 if (!(params = dm_malloc(paramsize))) { 1522 log_error("Insufficient space for target parameters."); 1523 return 0; 1524 } 1525 1526 params[0] = '\0'; 1527 ret = _emit_segment_line(dmt, major, minor, seg, seg_start, 1528 params, paramsize); 1529 dm_free(params); 1530 1531 if (!ret) 1532 stack; 1533 1534 if (ret >= 0) 1535 return ret; 1536 1537 log_debug("Insufficient space in params[%" PRIsize_t 1538 "] for target parameters.", paramsize); 1539 1540 paramsize *= 2; 1541 } while (paramsize < MAX_TARGET_PARAMSIZE); 1542 1543 log_error("Target parameter size too big. Aborting."); 1544 return 0; 1545 } 1546 1547 static int _load_node(struct dm_tree_node *dnode) 1548 { 1549 int r = 0; 1550 struct dm_task *dmt; 1551 struct load_segment *seg; 1552 uint64_t seg_start = 0; 1553 1554 log_verbose("Loading %s table (%" PRIu32 ":%" PRIu32 ")", dnode->name, 1555 dnode->info.major, dnode->info.minor); 1556 1557 if (!(dmt = dm_task_create(DM_DEVICE_RELOAD))) { 1558 log_error("Reload dm_task creation failed for %s", dnode->name); 1559 return 0; 1560 } 1561 1562 if (!dm_task_set_major(dmt, dnode->info.major) || 1563 !dm_task_set_minor(dmt, dnode->info.minor)) { 1564 log_error("Failed to set device number for %s reload.", dnode->name); 1565 goto out; 1566 } 1567 1568 if (dnode->props.read_only && !dm_task_set_ro(dmt)) { 1569 log_error("Failed to set read only flag for %s", dnode->name); 1570 goto out; 1571 } 1572 1573 if (!dm_task_no_open_count(dmt)) 1574 log_error("Failed to disable open_count"); 1575 1576 dm_list_iterate_items(seg, &dnode->props.segs) 1577 if (!_emit_segment(dmt, dnode->info.major, dnode->info.minor, 1578 seg, &seg_start)) 1579 goto_out; 1580 1581 if (!dm_task_suppress_identical_reload(dmt)) 1582 log_error("Failed to suppress reload of identical tables."); 1583 1584 if ((r = dm_task_run(dmt))) { 1585 r = dm_task_get_info(dmt, &dnode->info); 1586 if (r && !dnode->info.inactive_table) 1587 log_verbose("Suppressed %s identical table reload.", 1588 dnode->name); 1589 1590 if ((dnode->props.size_changed = 1591 (dm_task_get_existing_table_size(dmt) == seg_start) ? 0 : 1)) 1592 log_debug("Table size changed from %" PRIu64 " to %" 1593 PRIu64 " for %s", 1594 dm_task_get_existing_table_size(dmt), 1595 seg_start, dnode->name); 1596 } 1597 1598 dnode->props.segment_count = 0; 1599 1600 out: 1601 dm_task_destroy(dmt); 1602 1603 return r; 1604 } 1605 1606 int dm_tree_preload_children(struct dm_tree_node *dnode, 1607 const char *uuid_prefix, 1608 size_t uuid_prefix_len) 1609 { 1610 void *handle = NULL; 1611 struct dm_tree_node *child; 1612 struct dm_info newinfo; 1613 1614 /* Preload children first */ 1615 while ((child = dm_tree_next_child(&handle, dnode, 0))) { 1616 /* Skip existing non-device-mapper devices */ 1617 if (!child->info.exists && child->info.major) 1618 continue; 1619 1620 /* Ignore if it doesn't belong to this VG */ 1621 if (child->info.exists && 1622 !_uuid_prefix_matches(child->uuid, uuid_prefix, uuid_prefix_len)) 1623 continue; 1624 1625 if (dm_tree_node_num_children(child, 0)) 1626 dm_tree_preload_children(child, uuid_prefix, uuid_prefix_len); 1627 1628 /* FIXME Cope if name exists with no uuid? */ 1629 if (!child->info.exists) { 1630 if (!_create_node(child)) { 1631 stack; 1632 return 0; 1633 } 1634 } 1635 1636 if (!child->info.inactive_table && child->props.segment_count) { 1637 if (!_load_node(child)) { 1638 stack; 1639 return 0; 1640 } 1641 } 1642 1643 /* Propagate device size change change */ 1644 if (child->props.size_changed) 1645 dnode->props.size_changed = 1; 1646 1647 /* Resume device immediately if it has parents and its size changed */ 1648 if (!dm_tree_node_num_children(child, 1) || !child->props.size_changed) 1649 continue; 1650 1651 if (!child->info.inactive_table && !child->info.suspended) 1652 continue; 1653 1654 if (!_resume_node(child->name, child->info.major, child->info.minor, 1655 child->props.read_ahead, child->props.read_ahead_flags, 1656 &newinfo, &child->dtree->cookie, child->udev_flags)) { 1657 log_error("Unable to resume %s (%" PRIu32 1658 ":%" PRIu32 ")", child->name, child->info.major, 1659 child->info.minor); 1660 continue; 1661 } 1662 1663 /* Update cached info */ 1664 child->info = newinfo; 1665 } 1666 1667 handle = NULL; 1668 1669 return 1; 1670 } 1671 1672 /* 1673 * Returns 1 if unsure. 1674 */ 1675 int dm_tree_children_use_uuid(struct dm_tree_node *dnode, 1676 const char *uuid_prefix, 1677 size_t uuid_prefix_len) 1678 { 1679 void *handle = NULL; 1680 struct dm_tree_node *child = dnode; 1681 const char *uuid; 1682 1683 while ((child = dm_tree_next_child(&handle, dnode, 0))) { 1684 if (!(uuid = dm_tree_node_get_uuid(child))) { 1685 log_error("Failed to get uuid for dtree node."); 1686 return 1; 1687 } 1688 1689 if (_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len)) 1690 return 1; 1691 1692 if (dm_tree_node_num_children(child, 0)) 1693 dm_tree_children_use_uuid(child, uuid_prefix, uuid_prefix_len); 1694 } 1695 1696 return 0; 1697 } 1698 1699 /* 1700 * Target functions 1701 */ 1702 static struct load_segment *_add_segment(struct dm_tree_node *dnode, unsigned type, uint64_t size) 1703 { 1704 struct load_segment *seg; 1705 1706 if (!(seg = dm_pool_zalloc(dnode->dtree->mem, sizeof(*seg)))) { 1707 log_error("dtree node segment allocation failed"); 1708 return NULL; 1709 } 1710 1711 seg->type = type; 1712 seg->size = size; 1713 seg->area_count = 0; 1714 dm_list_init(&seg->areas); 1715 seg->stripe_size = 0; 1716 seg->persistent = 0; 1717 seg->chunk_size = 0; 1718 seg->cow = NULL; 1719 seg->origin = NULL; 1720 1721 dm_list_add(&dnode->props.segs, &seg->list); 1722 dnode->props.segment_count++; 1723 1724 return seg; 1725 } 1726 1727 int dm_tree_node_add_snapshot_origin_target(struct dm_tree_node *dnode, 1728 uint64_t size, 1729 const char *origin_uuid) 1730 { 1731 struct load_segment *seg; 1732 struct dm_tree_node *origin_node; 1733 1734 if (!(seg = _add_segment(dnode, SEG_SNAPSHOT_ORIGIN, size))) 1735 return_0; 1736 1737 if (!(origin_node = dm_tree_find_node_by_uuid(dnode->dtree, origin_uuid))) { 1738 log_error("Couldn't find snapshot origin uuid %s.", origin_uuid); 1739 return 0; 1740 } 1741 1742 seg->origin = origin_node; 1743 if (!_link_tree_nodes(dnode, origin_node)) 1744 return_0; 1745 1746 /* Resume snapshot origins after new snapshots */ 1747 dnode->activation_priority = 1; 1748 1749 return 1; 1750 } 1751 1752 int dm_tree_node_add_snapshot_target(struct dm_tree_node *node, 1753 uint64_t size, 1754 const char *origin_uuid, 1755 const char *cow_uuid, 1756 int persistent, 1757 uint32_t chunk_size) 1758 { 1759 struct load_segment *seg; 1760 struct dm_tree_node *origin_node, *cow_node; 1761 1762 if (!(seg = _add_segment(node, SEG_SNAPSHOT, size))) 1763 return_0; 1764 1765 if (!(origin_node = dm_tree_find_node_by_uuid(node->dtree, origin_uuid))) { 1766 log_error("Couldn't find snapshot origin uuid %s.", origin_uuid); 1767 return 0; 1768 } 1769 1770 seg->origin = origin_node; 1771 if (!_link_tree_nodes(node, origin_node)) 1772 return_0; 1773 1774 if (!(cow_node = dm_tree_find_node_by_uuid(node->dtree, cow_uuid))) { 1775 log_error("Couldn't find snapshot origin uuid %s.", cow_uuid); 1776 return 0; 1777 } 1778 1779 seg->cow = cow_node; 1780 if (!_link_tree_nodes(node, cow_node)) 1781 return_0; 1782 1783 seg->persistent = persistent ? 1 : 0; 1784 seg->chunk_size = chunk_size; 1785 1786 return 1; 1787 } 1788 1789 int dm_tree_node_add_error_target(struct dm_tree_node *node, 1790 uint64_t size) 1791 { 1792 if (!_add_segment(node, SEG_ERROR, size)) 1793 return_0; 1794 1795 return 1; 1796 } 1797 1798 int dm_tree_node_add_zero_target(struct dm_tree_node *node, 1799 uint64_t size) 1800 { 1801 if (!_add_segment(node, SEG_ZERO, size)) 1802 return_0; 1803 1804 return 1; 1805 } 1806 1807 int dm_tree_node_add_linear_target(struct dm_tree_node *node, 1808 uint64_t size) 1809 { 1810 if (!_add_segment(node, SEG_LINEAR, size)) 1811 return_0; 1812 1813 return 1; 1814 } 1815 1816 int dm_tree_node_add_striped_target(struct dm_tree_node *node, 1817 uint64_t size, 1818 uint32_t stripe_size) 1819 { 1820 struct load_segment *seg; 1821 1822 if (!(seg = _add_segment(node, SEG_STRIPED, size))) 1823 return_0; 1824 1825 seg->stripe_size = stripe_size; 1826 1827 return 1; 1828 } 1829 1830 int dm_tree_node_add_crypt_target(struct dm_tree_node *node, 1831 uint64_t size, 1832 const char *cipher, 1833 const char *chainmode, 1834 const char *iv, 1835 uint64_t iv_offset, 1836 const char *key) 1837 { 1838 struct load_segment *seg; 1839 1840 if (!(seg = _add_segment(node, SEG_CRYPT, size))) 1841 return_0; 1842 1843 seg->cipher = cipher; 1844 seg->chainmode = chainmode; 1845 seg->iv = iv; 1846 seg->iv_offset = iv_offset; 1847 seg->key = key; 1848 1849 return 1; 1850 } 1851 1852 int dm_tree_node_add_mirror_target_log(struct dm_tree_node *node, 1853 uint32_t region_size, 1854 unsigned clustered, 1855 const char *log_uuid, 1856 unsigned area_count, 1857 uint32_t flags) 1858 { 1859 struct dm_tree_node *log_node = NULL; 1860 struct load_segment *seg; 1861 1862 if (!node->props.segment_count) { 1863 log_error("Internal error: Attempt to add target area to missing segment."); 1864 return 0; 1865 } 1866 1867 seg = dm_list_item(dm_list_last(&node->props.segs), struct load_segment); 1868 1869 if (log_uuid) { 1870 if (!(seg->uuid = dm_pool_strdup(node->dtree->mem, log_uuid))) { 1871 log_error("log uuid pool_strdup failed"); 1872 return 0; 1873 } 1874 if (!(flags & DM_CORELOG)) { 1875 if (!(log_node = dm_tree_find_node_by_uuid(node->dtree, log_uuid))) { 1876 log_error("Couldn't find mirror log uuid %s.", log_uuid); 1877 return 0; 1878 } 1879 1880 if (!_link_tree_nodes(node, log_node)) 1881 return_0; 1882 } 1883 } 1884 1885 seg->log = log_node; 1886 seg->region_size = region_size; 1887 seg->clustered = clustered; 1888 seg->mirror_area_count = area_count; 1889 seg->flags = flags; 1890 1891 return 1; 1892 } 1893 1894 int dm_tree_node_add_mirror_target(struct dm_tree_node *node, 1895 uint64_t size) 1896 { 1897 struct load_segment *seg; 1898 1899 if (!(seg = _add_segment(node, SEG_MIRRORED, size))) 1900 return_0; 1901 1902 return 1; 1903 } 1904 1905 static int _add_area(struct dm_tree_node *node, struct load_segment *seg, struct dm_tree_node *dev_node, uint64_t offset) 1906 { 1907 struct seg_area *area; 1908 1909 if (!(area = dm_pool_zalloc(node->dtree->mem, sizeof (*area)))) { 1910 log_error("Failed to allocate target segment area."); 1911 return 0; 1912 } 1913 1914 area->dev_node = dev_node; 1915 area->offset = offset; 1916 1917 dm_list_add(&seg->areas, &area->list); 1918 seg->area_count++; 1919 1920 return 1; 1921 } 1922 1923 int dm_tree_node_add_target_area(struct dm_tree_node *node, 1924 const char *dev_name, 1925 const char *uuid, 1926 uint64_t offset) 1927 { 1928 struct load_segment *seg; 1929 struct stat info; 1930 struct dm_tree_node *dev_node; 1931 1932 if ((!dev_name || !*dev_name) && (!uuid || !*uuid)) { 1933 log_error("dm_tree_node_add_target_area called without device"); 1934 return 0; 1935 } 1936 1937 if (uuid) { 1938 if (!(dev_node = dm_tree_find_node_by_uuid(node->dtree, uuid))) { 1939 log_error("Couldn't find area uuid %s.", uuid); 1940 return 0; 1941 } 1942 if (!_link_tree_nodes(node, dev_node)) 1943 return_0; 1944 } else { 1945 if (stat(dev_name, &info) < 0) { 1946 log_error("Device %s not found.", dev_name); 1947 return 0; 1948 } 1949 #ifndef __NetBSD__ 1950 if (!S_ISBLK(info.st_mode)) { 1951 log_error("Device %s is not a block device.", dev_name); 1952 return 0; 1953 } 1954 #else 1955 if (S_ISBLK(info.st_mode)) { 1956 log_error("Device %s is a block device. Use raw devices on NetBSD.", dev_name); 1957 return 0; 1958 } 1959 #endif 1960 /* FIXME Check correct macro use */ 1961 if (!(dev_node = _add_dev(node->dtree, node, MAJOR(info.st_rdev), MINOR(info.st_rdev)))) 1962 return_0; 1963 } 1964 1965 if (!node->props.segment_count) { 1966 log_error("Internal error: Attempt to add target area to missing segment."); 1967 return 0; 1968 } 1969 1970 seg = dm_list_item(dm_list_last(&node->props.segs), struct load_segment); 1971 1972 if (!_add_area(node, seg, dev_node, offset)) 1973 return_0; 1974 1975 return 1; 1976 } 1977 1978 void dm_tree_set_cookie(struct dm_tree_node *node, uint32_t cookie) 1979 { 1980 node->dtree->cookie = cookie; 1981 } 1982 1983 uint32_t dm_tree_get_cookie(struct dm_tree_node *node) 1984 { 1985 return node->dtree->cookie; 1986 } 1987
Indexes created Tue Feb 24 08:35:24 UTC 2026