1 /* $NetBSD: toollib.c,v 1.1.1.3 2009/12/02 00:25:56 haad Exp $ */ 2 3 /* 4 * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved. 5 * Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved. 6 * 7 * This file is part of LVM2. 8 * 9 * This copyrighted material is made available to anyone wishing to use, 10 * modify, copy, or redistribute it subject to the terms and conditions 11 * of the GNU Lesser General Public License v.2.1. 12 * 13 * You should have received a copy of the GNU Lesser General Public License 14 * along with this program; if not, write to the Free Software Foundation, 15 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 16 */ 17 18 #include "tools.h" 19 #include "lv_alloc.h" 20 #include "xlate.h" 21 22 #include <sys/stat.h> 23 #include <sys/wait.h> 24 25 const char *command_name(struct cmd_context *cmd) 26 { 27 return cmd->command->name; 28 } 29 30 /* 31 * Strip dev_dir if present 32 */ 33 char *skip_dev_dir(struct cmd_context *cmd, const char *vg_name, 34 unsigned *dev_dir_found) 35 { 36 const char *dmdir = dm_dir(); 37 size_t dmdir_len = strlen(dmdir), vglv_sz; 38 char *vgname, *lvname, *layer, *vglv; 39 40 /* FIXME Do this properly */ 41 if (*vg_name == '/') { 42 while (*vg_name == '/') 43 vg_name++; 44 vg_name--; 45 } 46 47 /* Reformat string if /dev/mapper found */ 48 if (!strncmp(vg_name, dmdir, dmdir_len) && vg_name[dmdir_len] == '/') { 49 if (dev_dir_found) 50 *dev_dir_found = 1; 51 vg_name += dmdir_len; 52 while (*vg_name == '/') 53 vg_name++; 54 55 if (!dm_split_lvm_name(cmd->mem, vg_name, &vgname, &lvname, &layer) || 56 *layer) { 57 log_error("skip_dev_dir: Couldn't split up device name %s", 58 vg_name); 59 return (char *) vg_name; 60 } 61 vglv_sz = strlen(vgname) + strlen(lvname) + 2; 62 if (!(vglv = dm_pool_alloc(cmd->mem, vglv_sz)) || 63 dm_snprintf(vglv, vglv_sz, "%s%s%s", vgname, 64 *lvname ? "/" : "", 65 lvname) < 0) { 66 log_error("vg/lv string alloc failed"); 67 return (char *) vg_name; 68 } 69 return vglv; 70 } 71 72 if (!strncmp(vg_name, cmd->dev_dir, strlen(cmd->dev_dir))) { 73 if (dev_dir_found) 74 *dev_dir_found = 1; 75 vg_name += strlen(cmd->dev_dir); 76 while (*vg_name == '/') 77 vg_name++; 78 } else if (dev_dir_found) 79 *dev_dir_found = 0; 80 81 return (char *) vg_name; 82 } 83 84 /* 85 * Metadata iteration functions 86 */ 87 int process_each_lv_in_vg(struct cmd_context *cmd, 88 const struct volume_group *vg, 89 const struct dm_list *arg_lvnames, 90 const struct dm_list *tags, 91 void *handle, 92 process_single_lv_fn_t process_single) 93 { 94 int ret_max = ECMD_PROCESSED; 95 int ret = 0; 96 unsigned process_all = 0; 97 unsigned process_lv = 0; 98 unsigned tags_supplied = 0; 99 unsigned lvargs_supplied = 0; 100 unsigned lvargs_matched = 0; 101 102 struct lv_list *lvl; 103 104 if (!vg_check_status(vg, EXPORTED_VG)) 105 return ECMD_FAILED; 106 107 if (tags && !dm_list_empty(tags)) 108 tags_supplied = 1; 109 110 if (arg_lvnames && !dm_list_empty(arg_lvnames)) 111 lvargs_supplied = 1; 112 113 /* Process all LVs in this VG if no restrictions given */ 114 if (!tags_supplied && !lvargs_supplied) 115 process_all = 1; 116 117 /* Or if VG tags match */ 118 if (!process_lv && tags_supplied && 119 str_list_match_list(tags, &vg->tags)) { 120 process_all = 1; 121 } 122 123 dm_list_iterate_items(lvl, &vg->lvs) { 124 if (lvl->lv->status & SNAPSHOT) 125 continue; 126 127 if (lv_is_virtual_origin(lvl->lv) && !arg_count(cmd, all_ARG)) 128 continue; 129 130 /* Should we process this LV? */ 131 if (process_all) 132 process_lv = 1; 133 else 134 process_lv = 0; 135 136 /* LV tag match? */ 137 if (!process_lv && tags_supplied && 138 str_list_match_list(tags, &lvl->lv->tags)) { 139 process_lv = 1; 140 } 141 142 /* LV name match? */ 143 if (lvargs_supplied && 144 str_list_match_item(arg_lvnames, lvl->lv->name)) { 145 process_lv = 1; 146 lvargs_matched++; 147 } 148 149 if (!process_lv) 150 continue; 151 152 ret = process_single(cmd, lvl->lv, handle); 153 if (ret > ret_max) 154 ret_max = ret; 155 if (sigint_caught()) 156 return ret_max; 157 } 158 159 if (lvargs_supplied && lvargs_matched != dm_list_size(arg_lvnames)) { 160 log_error("One or more specified logical volume(s) not found."); 161 if (ret_max < ECMD_FAILED) 162 ret_max = ECMD_FAILED; 163 } 164 165 return ret_max; 166 } 167 168 int process_each_lv(struct cmd_context *cmd, int argc, char **argv, 169 uint32_t flags, void *handle, 170 int (*process_single) (struct cmd_context * cmd, 171 struct logical_volume * lv, 172 void *handle)) 173 { 174 int opt = 0; 175 int ret_max = ECMD_PROCESSED; 176 int ret = 0; 177 178 struct dm_list *tags_arg; 179 struct dm_list *vgnames; /* VGs to process */ 180 struct str_list *sll, *strl; 181 struct volume_group *vg; 182 struct dm_list tags, lvnames; 183 struct dm_list arg_lvnames; /* Cmdline vgname or vgname/lvname */ 184 char *vglv; 185 size_t vglv_sz; 186 187 const char *vgname; 188 189 dm_list_init(&tags); 190 dm_list_init(&arg_lvnames); 191 192 if (argc) { 193 struct dm_list arg_vgnames; 194 195 log_verbose("Using logical volume(s) on command line"); 196 dm_list_init(&arg_vgnames); 197 198 for (; opt < argc; opt++) { 199 const char *lv_name = argv[opt]; 200 char *vgname_def; 201 unsigned dev_dir_found = 0; 202 203 /* Do we have a tag or vgname or lvname? */ 204 vgname = lv_name; 205 206 if (*vgname == '@') { 207 if (!validate_name(vgname + 1)) { 208 log_error("Skipping invalid tag %s", 209 vgname); 210 continue; 211 } 212 if (!str_list_add(cmd->mem, &tags, 213 dm_pool_strdup(cmd->mem, 214 vgname + 1))) { 215 log_error("strlist allocation failed"); 216 return ECMD_FAILED; 217 } 218 continue; 219 } 220 221 /* FIXME Jumbled parsing */ 222 vgname = skip_dev_dir(cmd, vgname, &dev_dir_found); 223 224 if (*vgname == '/') { 225 log_error("\"%s\": Invalid path for Logical " 226 "Volume", argv[opt]); 227 if (ret_max < ECMD_FAILED) 228 ret_max = ECMD_FAILED; 229 continue; 230 } 231 lv_name = vgname; 232 if (strchr(vgname, '/')) { 233 /* Must be an LV */ 234 lv_name = strchr(vgname, '/'); 235 while (*lv_name == '/') 236 lv_name++; 237 if (!(vgname = extract_vgname(cmd, vgname))) { 238 if (ret_max < ECMD_FAILED) 239 ret_max = ECMD_FAILED; 240 continue; 241 } 242 } else if (!dev_dir_found && 243 (vgname_def = default_vgname(cmd))) { 244 vgname = vgname_def; 245 } else 246 lv_name = NULL; 247 248 if (!str_list_add(cmd->mem, &arg_vgnames, 249 dm_pool_strdup(cmd->mem, vgname))) { 250 log_error("strlist allocation failed"); 251 return ECMD_FAILED; 252 } 253 254 if (!lv_name) { 255 if (!str_list_add(cmd->mem, &arg_lvnames, 256 dm_pool_strdup(cmd->mem, 257 vgname))) { 258 log_error("strlist allocation failed"); 259 return ECMD_FAILED; 260 } 261 } else { 262 vglv_sz = strlen(vgname) + strlen(lv_name) + 2; 263 if (!(vglv = dm_pool_alloc(cmd->mem, vglv_sz)) || 264 dm_snprintf(vglv, vglv_sz, "%s/%s", vgname, 265 lv_name) < 0) { 266 log_error("vg/lv string alloc failed"); 267 return ECMD_FAILED; 268 } 269 if (!str_list_add(cmd->mem, &arg_lvnames, vglv)) { 270 log_error("strlist allocation failed"); 271 return ECMD_FAILED; 272 } 273 } 274 } 275 vgnames = &arg_vgnames; 276 } 277 278 if (!argc || !dm_list_empty(&tags)) { 279 log_verbose("Finding all logical volumes"); 280 if (!(vgnames = get_vgnames(cmd, 0)) || dm_list_empty(vgnames)) { 281 log_error("No volume groups found"); 282 return ret_max; 283 } 284 } 285 286 vg = NULL; 287 dm_list_iterate_items(strl, vgnames) { 288 vgname = strl->str; 289 if (is_orphan_vg(vgname)) 290 continue; /* FIXME Unnecessary? */ 291 vg = vg_read(cmd, vgname, NULL, flags); 292 293 if (vg_read_error(vg)) { 294 vg_release(vg); 295 if (ret_max < ECMD_FAILED) { 296 log_error("Skipping volume group %s", vgname); 297 ret_max = ECMD_FAILED; 298 } else 299 stack; 300 continue; 301 } 302 303 tags_arg = &tags; 304 dm_list_init(&lvnames); /* LVs to be processed in this VG */ 305 dm_list_iterate_items(sll, &arg_lvnames) { 306 const char *vg_name = sll->str; 307 const char *lv_name = strchr(vg_name, '/'); 308 309 if ((!lv_name && !strcmp(vg_name, vgname))) { 310 /* Process all LVs in this VG */ 311 tags_arg = NULL; 312 dm_list_init(&lvnames); 313 break; 314 } else if (!strncmp(vg_name, vgname, strlen(vgname)) && 315 strlen(vgname) == (size_t) (lv_name - vg_name)) { 316 if (!str_list_add(cmd->mem, &lvnames, 317 dm_pool_strdup(cmd->mem, 318 lv_name + 1))) { 319 log_error("strlist allocation failed"); 320 vg_release(vg); 321 return ECMD_FAILED; 322 } 323 } 324 } 325 326 ret = process_each_lv_in_vg(cmd, vg, &lvnames, tags_arg, 327 handle, process_single); 328 unlock_and_release_vg(cmd, vg, vgname); 329 if (ret > ret_max) 330 ret_max = ret; 331 if (sigint_caught()) 332 break; 333 } 334 335 return ret_max; 336 } 337 338 int process_each_segment_in_pv(struct cmd_context *cmd, 339 struct volume_group *vg, 340 struct physical_volume *pv, 341 void *handle, 342 int (*process_single) (struct cmd_context * cmd, 343 struct volume_group * vg, 344 struct pv_segment * pvseg, 345 void *handle)) 346 { 347 struct pv_segment *pvseg; 348 struct pv_list *pvl; 349 const char *vg_name = NULL; 350 int ret_max = ECMD_PROCESSED; 351 int ret; 352 struct volume_group *old_vg = vg; 353 struct pv_segment _free_pv_segment = { .pv = pv }; 354 355 if (is_pv(pv) && !vg && !is_orphan(pv)) { 356 vg_name = pv_vg_name(pv); 357 358 vg = vg_read(cmd, vg_name, NULL, 0); 359 if (vg_read_error(vg)) { 360 vg_release(vg); 361 log_error("Skipping volume group %s", vg_name); 362 return ECMD_FAILED; 363 } 364 365 /* 366 * Replace possibly incomplete PV structure with new one 367 * allocated in vg_read_internal() path. 368 */ 369 if (!(pvl = find_pv_in_vg(vg, pv_dev_name(pv)))) { 370 log_error("Unable to find %s in volume group %s", 371 pv_dev_name(pv), vg_name); 372 vg_release(vg); 373 return ECMD_FAILED; 374 } 375 376 pv = pvl->pv; 377 } 378 379 if (dm_list_empty(&pv->segments)) { 380 ret = process_single(cmd, NULL, &_free_pv_segment, handle); 381 if (ret > ret_max) 382 ret_max = ret; 383 } else 384 dm_list_iterate_items(pvseg, &pv->segments) { 385 ret = process_single(cmd, vg, pvseg, handle); 386 if (ret > ret_max) 387 ret_max = ret; 388 if (sigint_caught()) 389 break; 390 } 391 392 if (vg_name) 393 unlock_vg(cmd, vg_name); 394 if (!old_vg) 395 vg_release(vg); 396 397 return ret_max; 398 } 399 400 int process_each_segment_in_lv(struct cmd_context *cmd, 401 struct logical_volume *lv, 402 void *handle, 403 int (*process_single) (struct cmd_context * cmd, 404 struct lv_segment * seg, 405 void *handle)) 406 { 407 struct lv_segment *seg; 408 int ret_max = ECMD_PROCESSED; 409 int ret; 410 411 dm_list_iterate_items(seg, &lv->segments) { 412 ret = process_single(cmd, seg, handle); 413 if (ret > ret_max) 414 ret_max = ret; 415 if (sigint_caught()) 416 break; 417 } 418 419 return ret_max; 420 } 421 422 static int _process_one_vg(struct cmd_context *cmd, const char *vg_name, 423 const char *vgid, 424 struct dm_list *tags, struct dm_list *arg_vgnames, 425 uint32_t flags, void *handle, int ret_max, 426 int (*process_single) (struct cmd_context * cmd, 427 const char *vg_name, 428 struct volume_group * vg, 429 void *handle)) 430 { 431 struct volume_group *vg; 432 int ret = 0; 433 434 log_verbose("Finding volume group \"%s\"", vg_name); 435 436 vg = vg_read(cmd, vg_name, vgid, flags); 437 /* Allow FAILED_INCONSISTENT through only for vgcfgrestore */ 438 if (vg_read_error(vg) && 439 !((vg_read_error(vg) == FAILED_INCONSISTENT) && 440 (flags & READ_ALLOW_INCONSISTENT))) { 441 ret_max = ECMD_FAILED; 442 goto_out; 443 } 444 445 if (!dm_list_empty(tags)) { 446 /* Only process if a tag matches or it's on arg_vgnames */ 447 if (!str_list_match_item(arg_vgnames, vg_name) && 448 !str_list_match_list(tags, &vg->tags)) 449 goto out; 450 } 451 452 if ((ret = process_single(cmd, vg_name, vg, 453 handle)) > ret_max) 454 ret_max = ret; 455 456 out: 457 if (vg_read_error(vg)) 458 vg_release(vg); 459 else 460 unlock_and_release_vg(cmd, vg, vg_name); 461 return ret_max; 462 } 463 464 int process_each_vg(struct cmd_context *cmd, int argc, char **argv, 465 uint32_t flags, void *handle, 466 int (*process_single) (struct cmd_context * cmd, 467 const char *vg_name, 468 struct volume_group * vg, 469 void *handle)) 470 { 471 int opt = 0; 472 int ret_max = ECMD_PROCESSED; 473 474 struct str_list *sl; 475 struct dm_list *vgnames, *vgids; 476 struct dm_list arg_vgnames, tags; 477 478 const char *vg_name, *vgid; 479 480 dm_list_init(&tags); 481 dm_list_init(&arg_vgnames); 482 483 if (argc) { 484 log_verbose("Using volume group(s) on command line"); 485 486 for (; opt < argc; opt++) { 487 vg_name = argv[opt]; 488 if (*vg_name == '@') { 489 if (!validate_name(vg_name + 1)) { 490 log_error("Skipping invalid tag %s", 491 vg_name); 492 if (ret_max < EINVALID_CMD_LINE) 493 ret_max = EINVALID_CMD_LINE; 494 continue; 495 } 496 if (!str_list_add(cmd->mem, &tags, 497 dm_pool_strdup(cmd->mem, 498 vg_name + 1))) { 499 log_error("strlist allocation failed"); 500 return ECMD_FAILED; 501 } 502 continue; 503 } 504 505 vg_name = skip_dev_dir(cmd, vg_name, NULL); 506 if (strchr(vg_name, '/')) { 507 log_error("Invalid volume group name: %s", 508 vg_name); 509 if (ret_max < EINVALID_CMD_LINE) 510 ret_max = EINVALID_CMD_LINE; 511 continue; 512 } 513 if (!str_list_add(cmd->mem, &arg_vgnames, 514 dm_pool_strdup(cmd->mem, vg_name))) { 515 log_error("strlist allocation failed"); 516 return ECMD_FAILED; 517 } 518 } 519 520 vgnames = &arg_vgnames; 521 } 522 523 if (!argc || !dm_list_empty(&tags)) { 524 log_verbose("Finding all volume groups"); 525 if (!(vgids = get_vgids(cmd, 0)) || dm_list_empty(vgids)) { 526 log_error("No volume groups found"); 527 return ret_max; 528 } 529 dm_list_iterate_items(sl, vgids) { 530 vgid = sl->str; 531 if (!vgid || !(vg_name = vgname_from_vgid(cmd->mem, vgid)) || 532 is_orphan_vg(vg_name)) 533 continue; 534 ret_max = _process_one_vg(cmd, vg_name, vgid, &tags, 535 &arg_vgnames, 536 flags, handle, 537 ret_max, process_single); 538 if (sigint_caught()) 539 return ret_max; 540 } 541 } else { 542 dm_list_iterate_items(sl, vgnames) { 543 vg_name = sl->str; 544 if (is_orphan_vg(vg_name)) 545 continue; /* FIXME Unnecessary? */ 546 ret_max = _process_one_vg(cmd, vg_name, NULL, &tags, 547 &arg_vgnames, 548 flags, handle, 549 ret_max, process_single); 550 if (sigint_caught()) 551 return ret_max; 552 } 553 } 554 555 return ret_max; 556 } 557 558 int process_each_pv_in_vg(struct cmd_context *cmd, struct volume_group *vg, 559 const struct dm_list *tags, void *handle, 560 process_single_pv_fn_t process_single) 561 { 562 int ret_max = ECMD_PROCESSED; 563 int ret = 0; 564 struct pv_list *pvl; 565 566 dm_list_iterate_items(pvl, &vg->pvs) { 567 if (tags && !dm_list_empty(tags) && 568 !str_list_match_list(tags, &pvl->pv->tags)) { 569 continue; 570 } 571 if ((ret = process_single(cmd, vg, pvl->pv, handle)) > ret_max) 572 ret_max = ret; 573 if (sigint_caught()) 574 return ret_max; 575 } 576 577 return ret_max; 578 } 579 580 static int _process_all_devs(struct cmd_context *cmd, void *handle, 581 int (*process_single) (struct cmd_context * cmd, 582 struct volume_group * vg, 583 struct physical_volume * pv, 584 void *handle)) 585 { 586 struct physical_volume *pv; 587 struct physical_volume pv_dummy; 588 struct dev_iter *iter; 589 struct device *dev; 590 591 int ret_max = ECMD_PROCESSED; 592 int ret = 0; 593 594 if (!scan_vgs_for_pvs(cmd)) { 595 stack; 596 return ECMD_FAILED; 597 } 598 599 if (!(iter = dev_iter_create(cmd->filter, 1))) { 600 log_error("dev_iter creation failed"); 601 return ECMD_FAILED; 602 } 603 604 while ((dev = dev_iter_get(iter))) { 605 if (!(pv = pv_read(cmd, dev_name(dev), NULL, NULL, 0, 0))) { 606 memset(&pv_dummy, 0, sizeof(pv_dummy)); 607 dm_list_init(&pv_dummy.tags); 608 dm_list_init(&pv_dummy.segments); 609 pv_dummy.dev = dev; 610 pv_dummy.fmt = NULL; 611 pv = &pv_dummy; 612 } 613 ret = process_single(cmd, NULL, pv, handle); 614 if (ret > ret_max) 615 ret_max = ret; 616 if (sigint_caught()) 617 break; 618 } 619 620 dev_iter_destroy(iter); 621 622 return ret_max; 623 } 624 625 /* 626 * If the lock_type is LCK_VG_READ (used only in reporting commands), 627 * we lock VG_GLOBAL to enable use of metadata cache. 628 * This can pause alongide pvscan or vgscan process for a while. 629 */ 630 int process_each_pv(struct cmd_context *cmd, int argc, char **argv, 631 struct volume_group *vg, uint32_t flags, 632 int scan_label_only, void *handle, 633 int (*process_single) (struct cmd_context * cmd, 634 struct volume_group * vg, 635 struct physical_volume * pv, 636 void *handle)) 637 { 638 int opt = 0; 639 int ret_max = ECMD_PROCESSED; 640 int ret = 0; 641 int lock_global = !(flags & READ_WITHOUT_LOCK) && !(flags & READ_FOR_UPDATE); 642 643 struct pv_list *pvl; 644 struct physical_volume *pv; 645 struct dm_list *pvslist, *vgnames; 646 struct dm_list tags; 647 struct str_list *sll; 648 char *tagname; 649 int scanned = 0; 650 651 dm_list_init(&tags); 652 653 if (lock_global && !lock_vol(cmd, VG_GLOBAL, LCK_VG_READ)) { 654 log_error("Unable to obtain global lock."); 655 return ECMD_FAILED; 656 } 657 658 if (argc) { 659 log_verbose("Using physical volume(s) on command line"); 660 for (; opt < argc; opt++) { 661 if (*argv[opt] == '@') { 662 tagname = argv[opt] + 1; 663 664 if (!validate_name(tagname)) { 665 log_error("Skipping invalid tag %s", 666 tagname); 667 if (ret_max < EINVALID_CMD_LINE) 668 ret_max = EINVALID_CMD_LINE; 669 continue; 670 } 671 if (!str_list_add(cmd->mem, &tags, 672 dm_pool_strdup(cmd->mem, 673 tagname))) { 674 log_error("strlist allocation failed"); 675 goto bad; 676 } 677 continue; 678 } 679 if (vg) { 680 if (!(pvl = find_pv_in_vg(vg, argv[opt]))) { 681 log_error("Physical Volume \"%s\" not " 682 "found in Volume Group " 683 "\"%s\"", argv[opt], 684 vg->name); 685 ret_max = ECMD_FAILED; 686 continue; 687 } 688 pv = pvl->pv; 689 } else { 690 if (!(pv = pv_read(cmd, argv[opt], NULL, 691 NULL, 1, scan_label_only))) { 692 log_error("Failed to read physical " 693 "volume \"%s\"", argv[opt]); 694 ret_max = ECMD_FAILED; 695 continue; 696 } 697 698 /* 699 * If a PV has no MDAs it may appear to be an 700 * orphan until the metadata is read off 701 * another PV in the same VG. Detecting this 702 * means checking every VG by scanning every 703 * PV on the system. 704 */ 705 if (!scanned && is_orphan(pv)) { 706 if (!scan_label_only && 707 !scan_vgs_for_pvs(cmd)) { 708 stack; 709 ret_max = ECMD_FAILED; 710 continue; 711 } 712 scanned = 1; 713 if (!(pv = pv_read(cmd, argv[opt], 714 NULL, NULL, 1, 715 scan_label_only))) { 716 log_error("Failed to read " 717 "physical volume " 718 "\"%s\"", argv[opt]); 719 ret_max = ECMD_FAILED; 720 continue; 721 } 722 } 723 } 724 725 ret = process_single(cmd, vg, pv, handle); 726 if (ret > ret_max) 727 ret_max = ret; 728 if (sigint_caught()) 729 goto out; 730 } 731 if (!dm_list_empty(&tags) && (vgnames = get_vgnames(cmd, 0)) && 732 !dm_list_empty(vgnames)) { 733 dm_list_iterate_items(sll, vgnames) { 734 vg = vg_read(cmd, sll->str, NULL, flags); 735 if (vg_read_error(vg)) { 736 ret_max = ECMD_FAILED; 737 vg_release(vg); 738 stack; 739 continue; 740 } 741 742 ret = process_each_pv_in_vg(cmd, vg, &tags, 743 handle, 744 process_single); 745 746 unlock_and_release_vg(cmd, vg, sll->str); 747 748 if (ret > ret_max) 749 ret_max = ret; 750 if (sigint_caught()) 751 goto out; 752 } 753 } 754 } else { 755 if (vg) { 756 log_verbose("Using all physical volume(s) in " 757 "volume group"); 758 ret = process_each_pv_in_vg(cmd, vg, NULL, handle, 759 process_single); 760 if (ret > ret_max) 761 ret_max = ret; 762 if (sigint_caught()) 763 goto out; 764 } else if (arg_count(cmd, all_ARG)) { 765 ret = _process_all_devs(cmd, handle, process_single); 766 if (ret > ret_max) 767 ret_max = ret; 768 if (sigint_caught()) 769 goto out; 770 } else { 771 log_verbose("Scanning for physical volume names"); 772 773 if (!(pvslist = get_pvs(cmd))) 774 goto bad; 775 776 dm_list_iterate_items(pvl, pvslist) { 777 ret = process_single(cmd, NULL, pvl->pv, 778 handle); 779 if (ret > ret_max) 780 ret_max = ret; 781 if (sigint_caught()) 782 goto out; 783 } 784 } 785 } 786 out: 787 if (lock_global) 788 unlock_vg(cmd, VG_GLOBAL); 789 return ret_max; 790 bad: 791 if (lock_global) 792 unlock_vg(cmd, VG_GLOBAL); 793 794 return ECMD_FAILED; 795 } 796 797 /* 798 * Determine volume group name from a logical volume name 799 */ 800 const char *extract_vgname(struct cmd_context *cmd, const char *lv_name) 801 { 802 const char *vg_name = lv_name; 803 char *st; 804 char *dev_dir = cmd->dev_dir; 805 int dev_dir_provided = 0; 806 807 /* Path supplied? */ 808 if (vg_name && strchr(vg_name, '/')) { 809 /* Strip dev_dir (optional) */ 810 if (*vg_name == '/') { 811 while (*vg_name == '/') 812 vg_name++; 813 vg_name--; 814 } 815 if (!strncmp(vg_name, dev_dir, strlen(dev_dir))) { 816 vg_name += strlen(dev_dir); 817 dev_dir_provided = 1; 818 while (*vg_name == '/') 819 vg_name++; 820 } 821 if (*vg_name == '/') { 822 log_error("\"%s\": Invalid path for Logical " 823 "Volume", lv_name); 824 return 0; 825 } 826 827 /* Require exactly one set of consecutive slashes */ 828 if ((st = strchr(vg_name, '/'))) 829 while (*st == '/') 830 st++; 831 832 if (!strchr(vg_name, '/') || strchr(st, '/')) { 833 log_error("\"%s\": Invalid path for Logical Volume", 834 lv_name); 835 return 0; 836 } 837 838 vg_name = dm_pool_strdup(cmd->mem, vg_name); 839 if (!vg_name) { 840 log_error("Allocation of vg_name failed"); 841 return 0; 842 } 843 844 *strchr(vg_name, '/') = '\0'; 845 return vg_name; 846 } 847 848 if (!(vg_name = default_vgname(cmd))) { 849 if (lv_name) 850 log_error("Path required for Logical Volume \"%s\"", 851 lv_name); 852 return 0; 853 } 854 855 return vg_name; 856 } 857 858 /* 859 * Extract default volume group name from environment 860 */ 861 char *default_vgname(struct cmd_context *cmd) 862 { 863 char *vg_path; 864 865 /* Take default VG from environment? */ 866 vg_path = getenv("LVM_VG_NAME"); 867 if (!vg_path) 868 return 0; 869 870 vg_path = skip_dev_dir(cmd, vg_path, NULL); 871 872 if (strchr(vg_path, '/')) { 873 log_error("Environment Volume Group in LVM_VG_NAME invalid: " 874 "\"%s\"", vg_path); 875 return 0; 876 } 877 878 return dm_pool_strdup(cmd->mem, vg_path); 879 } 880 881 /* 882 * Process physical extent range specifiers 883 */ 884 static int _add_pe_range(struct dm_pool *mem, const char *pvname, 885 struct dm_list *pe_ranges, uint32_t start, uint32_t count) 886 { 887 struct pe_range *per; 888 889 log_debug("Adding PE range: start PE %" PRIu32 " length %" PRIu32 890 " on %s", start, count, pvname); 891 892 /* Ensure no overlap with existing areas */ 893 dm_list_iterate_items(per, pe_ranges) { 894 if (((start < per->start) && (start + count - 1 >= per->start)) 895 || ((start >= per->start) && 896 (per->start + per->count - 1) >= start)) { 897 log_error("Overlapping PE ranges specified (%" PRIu32 898 "-%" PRIu32 ", %" PRIu32 "-%" PRIu32 ")" 899 " on %s", 900 start, start + count - 1, per->start, 901 per->start + per->count - 1, pvname); 902 return 0; 903 } 904 } 905 906 if (!(per = dm_pool_alloc(mem, sizeof(*per)))) { 907 log_error("Allocation of list failed"); 908 return 0; 909 } 910 911 per->start = start; 912 per->count = count; 913 dm_list_add(pe_ranges, &per->list); 914 915 return 1; 916 } 917 918 static int xstrtouint32(const char *s, char **p, int base, uint32_t *result) 919 { 920 unsigned long ul; 921 922 errno = 0; 923 ul = strtoul(s, p, base); 924 if (errno || *p == s || (uint32_t) ul != ul) 925 return -1; 926 *result = ul; 927 return 0; 928 } 929 930 static int _parse_pes(struct dm_pool *mem, char *c, struct dm_list *pe_ranges, 931 const char *pvname, uint32_t size) 932 { 933 char *endptr; 934 uint32_t start, end; 935 936 /* Default to whole PV */ 937 if (!c) { 938 if (!_add_pe_range(mem, pvname, pe_ranges, UINT32_C(0), size)) 939 return_0; 940 return 1; 941 } 942 943 while (*c) { 944 if (*c != ':') 945 goto error; 946 947 c++; 948 949 /* Disallow :: and :\0 */ 950 if (*c == ':' || !*c) 951 goto error; 952 953 /* Default to whole range */ 954 start = UINT32_C(0); 955 end = size - 1; 956 957 /* Start extent given? */ 958 if (isdigit(*c)) { 959 if (xstrtouint32(c, &endptr, 10, &start)) 960 goto error; 961 c = endptr; 962 /* Just one number given? */ 963 if (!*c || *c == ':') 964 end = start; 965 } 966 /* Range? */ 967 if (*c == '-') { 968 c++; 969 if (isdigit(*c)) { 970 if (xstrtouint32(c, &endptr, 10, &end)) 971 goto error; 972 c = endptr; 973 } 974 } 975 if (*c && *c != ':') 976 goto error; 977 978 if ((start > end) || (end > size - 1)) { 979 log_error("PE range error: start extent %" PRIu32 " to " 980 "end extent %" PRIu32, start, end); 981 return 0; 982 } 983 984 if (!_add_pe_range(mem, pvname, pe_ranges, start, end - start + 1)) 985 return_0; 986 987 } 988 989 return 1; 990 991 error: 992 log_error("Physical extent parsing error at %s", c); 993 return 0; 994 } 995 996 static int _create_pv_entry(struct dm_pool *mem, struct pv_list *pvl, 997 char *colon, int allocatable_only, struct dm_list *r) 998 { 999 const char *pvname; 1000 struct pv_list *new_pvl = NULL, *pvl2; 1001 struct dm_list *pe_ranges; 1002 1003 pvname = pv_dev_name(pvl->pv); 1004 if (allocatable_only && !(pvl->pv->status & ALLOCATABLE_PV)) { 1005 log_error("Physical volume %s not allocatable", pvname); 1006 return 1; 1007 } 1008 1009 if (allocatable_only && (pvl->pv->status & MISSING_PV)) { 1010 log_error("Physical volume %s is missing", pvname); 1011 return 1; 1012 } 1013 1014 if (allocatable_only && 1015 (pvl->pv->pe_count == pvl->pv->pe_alloc_count)) { 1016 log_error("No free extents on physical volume \"%s\"", pvname); 1017 return 1; 1018 } 1019 1020 dm_list_iterate_items(pvl2, r) 1021 if (pvl->pv->dev == pvl2->pv->dev) { 1022 new_pvl = pvl2; 1023 break; 1024 } 1025 1026 if (!new_pvl) { 1027 if (!(new_pvl = dm_pool_alloc(mem, sizeof(*new_pvl)))) { 1028 log_error("Unable to allocate physical volume list."); 1029 return 0; 1030 } 1031 1032 memcpy(new_pvl, pvl, sizeof(*new_pvl)); 1033 1034 if (!(pe_ranges = dm_pool_alloc(mem, sizeof(*pe_ranges)))) { 1035 log_error("Allocation of pe_ranges list failed"); 1036 return 0; 1037 } 1038 dm_list_init(pe_ranges); 1039 new_pvl->pe_ranges = pe_ranges; 1040 dm_list_add(r, &new_pvl->list); 1041 } 1042 1043 /* Determine selected physical extents */ 1044 if (!_parse_pes(mem, colon, new_pvl->pe_ranges, pv_dev_name(pvl->pv), 1045 pvl->pv->pe_count)) 1046 return_0; 1047 1048 return 1; 1049 } 1050 1051 struct dm_list *create_pv_list(struct dm_pool *mem, struct volume_group *vg, int argc, 1052 char **argv, int allocatable_only) 1053 { 1054 struct dm_list *r; 1055 struct pv_list *pvl; 1056 struct dm_list tags, arg_pvnames; 1057 const char *pvname = NULL; 1058 char *colon, *tagname; 1059 int i; 1060 1061 /* Build up list of PVs */ 1062 if (!(r = dm_pool_alloc(mem, sizeof(*r)))) { 1063 log_error("Allocation of list failed"); 1064 return NULL; 1065 } 1066 dm_list_init(r); 1067 1068 dm_list_init(&tags); 1069 dm_list_init(&arg_pvnames); 1070 1071 for (i = 0; i < argc; i++) { 1072 if (*argv[i] == '@') { 1073 tagname = argv[i] + 1; 1074 if (!validate_name(tagname)) { 1075 log_error("Skipping invalid tag %s", tagname); 1076 continue; 1077 } 1078 dm_list_iterate_items(pvl, &vg->pvs) { 1079 if (str_list_match_item(&pvl->pv->tags, 1080 tagname)) { 1081 if (!_create_pv_entry(mem, pvl, NULL, 1082 allocatable_only, 1083 r)) 1084 return_NULL; 1085 } 1086 } 1087 continue; 1088 } 1089 1090 pvname = argv[i]; 1091 1092 if ((colon = strchr(pvname, ':'))) { 1093 if (!(pvname = dm_pool_strndup(mem, pvname, 1094 (unsigned) (colon - 1095 pvname)))) { 1096 log_error("Failed to clone PV name"); 1097 return NULL; 1098 } 1099 } 1100 1101 if (!(pvl = find_pv_in_vg(vg, pvname))) { 1102 log_error("Physical Volume \"%s\" not found in " 1103 "Volume Group \"%s\"", pvname, vg->name); 1104 return NULL; 1105 } 1106 if (!_create_pv_entry(mem, pvl, colon, allocatable_only, r)) 1107 return_NULL; 1108 } 1109 1110 if (dm_list_empty(r)) 1111 log_error("No specified PVs have space available"); 1112 1113 return dm_list_empty(r) ? NULL : r; 1114 } 1115 1116 struct dm_list *clone_pv_list(struct dm_pool *mem, struct dm_list *pvsl) 1117 { 1118 struct dm_list *r; 1119 struct pv_list *pvl, *new_pvl; 1120 1121 /* Build up list of PVs */ 1122 if (!(r = dm_pool_alloc(mem, sizeof(*r)))) { 1123 log_error("Allocation of list failed"); 1124 return NULL; 1125 } 1126 dm_list_init(r); 1127 1128 dm_list_iterate_items(pvl, pvsl) { 1129 if (!(new_pvl = dm_pool_zalloc(mem, sizeof(*new_pvl)))) { 1130 log_error("Unable to allocate physical volume list."); 1131 return NULL; 1132 } 1133 1134 memcpy(new_pvl, pvl, sizeof(*new_pvl)); 1135 dm_list_add(r, &new_pvl->list); 1136 } 1137 1138 return r; 1139 } 1140 1141 int apply_lvname_restrictions(const char *name) 1142 { 1143 if (!strncmp(name, "snapshot", 8)) { 1144 log_error("Names starting \"snapshot\" are reserved. " 1145 "Please choose a different LV name."); 1146 return 0; 1147 } 1148 1149 if (!strncmp(name, "pvmove", 6)) { 1150 log_error("Names starting \"pvmove\" are reserved. " 1151 "Please choose a different LV name."); 1152 return 0; 1153 } 1154 1155 if (strstr(name, "_mlog")) { 1156 log_error("Names including \"_mlog\" are reserved. " 1157 "Please choose a different LV name."); 1158 return 0; 1159 } 1160 1161 if (strstr(name, "_mimage")) { 1162 log_error("Names including \"_mimage\" are reserved. " 1163 "Please choose a different LV name."); 1164 return 0; 1165 } 1166 1167 if (strstr(name, "_vorigin")) { 1168 log_error("Names including \"_vorigin\" are reserved. " 1169 "Please choose a different LV name."); 1170 return 0; 1171 } 1172 1173 return 1; 1174 } 1175 1176 int is_reserved_lvname(const char *name) 1177 { 1178 int rc, old_suppress; 1179 1180 old_suppress = log_suppress(2); 1181 rc = !apply_lvname_restrictions(name); 1182 log_suppress(old_suppress); 1183 1184 return rc; 1185 } 1186 1187 void vgcreate_params_set_defaults(struct vgcreate_params *vp_def, 1188 struct volume_group *vg) 1189 { 1190 if (vg) { 1191 vp_def->vg_name = NULL; 1192 vp_def->extent_size = vg->extent_size; 1193 vp_def->max_pv = vg->max_pv; 1194 vp_def->max_lv = vg->max_lv; 1195 vp_def->alloc = vg->alloc; 1196 vp_def->clustered = vg_is_clustered(vg); 1197 } else { 1198 vp_def->vg_name = NULL; 1199 vp_def->extent_size = DEFAULT_EXTENT_SIZE * 2; 1200 vp_def->max_pv = DEFAULT_MAX_PV; 1201 vp_def->max_lv = DEFAULT_MAX_LV; 1202 vp_def->alloc = DEFAULT_ALLOC_POLICY; 1203 vp_def->clustered = DEFAULT_CLUSTERED; 1204 } 1205 } 1206 1207 /* 1208 * Set members of struct vgcreate_params from cmdline arguments. 1209 * Do preliminary validation with arg_*() interface. 1210 * Further, more generic validation is done in validate_vgcreate_params(). 1211 * This function is to remain in tools directory. 1212 */ 1213 int vgcreate_params_set_from_args(struct cmd_context *cmd, 1214 struct vgcreate_params *vp_new, 1215 struct vgcreate_params *vp_def) 1216 { 1217 vp_new->vg_name = skip_dev_dir(cmd, vp_def->vg_name, NULL); 1218 vp_new->max_lv = arg_uint_value(cmd, maxlogicalvolumes_ARG, 1219 vp_def->max_lv); 1220 vp_new->max_pv = arg_uint_value(cmd, maxphysicalvolumes_ARG, 1221 vp_def->max_pv); 1222 vp_new->alloc = arg_uint_value(cmd, alloc_ARG, vp_def->alloc); 1223 1224 /* Units of 512-byte sectors */ 1225 vp_new->extent_size = 1226 arg_uint_value(cmd, physicalextentsize_ARG, vp_def->extent_size); 1227 1228 if (arg_count(cmd, clustered_ARG)) 1229 vp_new->clustered = 1230 !strcmp(arg_str_value(cmd, clustered_ARG, 1231 vp_def->clustered ? "y":"n"), "y"); 1232 else 1233 /* Default depends on current locking type */ 1234 vp_new->clustered = locking_is_clustered(); 1235 1236 if (arg_sign_value(cmd, physicalextentsize_ARG, 0) == SIGN_MINUS) { 1237 log_error("Physical extent size may not be negative"); 1238 return 1; 1239 } 1240 1241 if (arg_sign_value(cmd, maxlogicalvolumes_ARG, 0) == SIGN_MINUS) { 1242 log_error("Max Logical Volumes may not be negative"); 1243 return 1; 1244 } 1245 1246 if (arg_sign_value(cmd, maxphysicalvolumes_ARG, 0) == SIGN_MINUS) { 1247 log_error("Max Physical Volumes may not be negative"); 1248 return 1; 1249 } 1250 1251 return 0; 1252 } 1253 1254 int lv_refresh(struct cmd_context *cmd, struct logical_volume *lv) 1255 { 1256 return suspend_lv(cmd, lv) && resume_lv(cmd, lv); 1257 } 1258 1259 int vg_refresh_visible(struct cmd_context *cmd, struct volume_group *vg) 1260 { 1261 struct lv_list *lvl; 1262 int r = 1; 1263 1264 dm_list_iterate_items(lvl, &vg->lvs) 1265 if (lv_is_visible(lvl->lv)) 1266 if (!lv_refresh(cmd, lvl->lv)) 1267 r = 0; 1268 1269 return r; 1270 } 1271 1272 void lv_spawn_background_polling(struct cmd_context *cmd, 1273 struct logical_volume *lv) 1274 { 1275 const char *pvname; 1276 1277 if ((lv->status & PVMOVE) && 1278 (pvname = get_pvmove_pvname_from_lv_mirr(lv))) { 1279 log_verbose("Spawning background pvmove process for %s", 1280 pvname); 1281 pvmove_poll(cmd, pvname, 1); 1282 } else if ((lv->status & LOCKED) && 1283 (pvname = get_pvmove_pvname_from_lv(lv))) { 1284 log_verbose("Spawning background pvmove process for %s", 1285 pvname); 1286 pvmove_poll(cmd, pvname, 1); 1287 } 1288 1289 if (lv->status & CONVERTING) { 1290 log_verbose("Spawning background lvconvert process for %s", 1291 lv->name); 1292 lvconvert_poll(cmd, lv, 1); 1293 } 1294 } 1295 1296 /* 1297 * Intial sanity checking of non-recovery related command-line arguments. 1298 * 1299 * Output arguments: 1300 * pp: structure allocated by caller, fields written / validated here 1301 */ 1302 int pvcreate_params_validate(struct cmd_context *cmd, 1303 int argc, char **argv, 1304 struct pvcreate_params *pp) 1305 { 1306 if (!argc) { 1307 log_error("Please enter a physical volume path"); 1308 return 0; 1309 } 1310 1311 if (arg_count(cmd, yes_ARG) && !arg_count(cmd, force_ARG)) { 1312 log_error("Option y can only be given with option f"); 1313 return 0; 1314 } 1315 1316 pp->yes = arg_count(cmd, yes_ARG); 1317 pp->force = arg_count(cmd, force_ARG); 1318 1319 if (arg_int_value(cmd, labelsector_ARG, 0) >= LABEL_SCAN_SECTORS) { 1320 log_error("labelsector must be less than %lu", 1321 LABEL_SCAN_SECTORS); 1322 return 0; 1323 } else { 1324 pp->labelsector = arg_int64_value(cmd, labelsector_ARG, 1325 DEFAULT_LABELSECTOR); 1326 } 1327 1328 if (!(cmd->fmt->features & FMT_MDAS) && 1329 (arg_count(cmd, pvmetadatacopies_ARG) || 1330 arg_count(cmd, metadatasize_ARG) || 1331 arg_count(cmd, dataalignment_ARG) || 1332 arg_count(cmd, dataalignmentoffset_ARG))) { 1333 log_error("Metadata and data alignment parameters only " 1334 "apply to text format."); 1335 return 0; 1336 } 1337 1338 if (arg_count(cmd, pvmetadatacopies_ARG) && 1339 arg_int_value(cmd, pvmetadatacopies_ARG, -1) > 2) { 1340 log_error("Metadatacopies may only be 0, 1 or 2"); 1341 return 0; 1342 } 1343 1344 if (arg_count(cmd, zero_ARG)) 1345 pp->zero = strcmp(arg_str_value(cmd, zero_ARG, "y"), "n"); 1346 1347 if (arg_sign_value(cmd, dataalignment_ARG, 0) == SIGN_MINUS) { 1348 log_error("Physical volume data alignment may not be negative"); 1349 return 0; 1350 } 1351 pp->data_alignment = arg_uint64_value(cmd, dataalignment_ARG, UINT64_C(0)); 1352 1353 if (pp->data_alignment > ULONG_MAX) { 1354 log_error("Physical volume data alignment is too big."); 1355 return 0; 1356 } 1357 1358 if (pp->data_alignment && pp->pe_start) { 1359 if (pp->pe_start % pp->data_alignment) 1360 log_warn("WARNING: Ignoring data alignment %" PRIu64 1361 " incompatible with --restorefile value (%" 1362 PRIu64").", pp->data_alignment, pp->pe_start); 1363 pp->data_alignment = 0; 1364 } 1365 1366 if (arg_sign_value(cmd, dataalignmentoffset_ARG, 0) == SIGN_MINUS) { 1367 log_error("Physical volume data alignment offset may not be negative"); 1368 return 0; 1369 } 1370 pp->data_alignment_offset = arg_uint64_value(cmd, dataalignmentoffset_ARG, UINT64_C(0)); 1371 1372 if (pp->data_alignment_offset > ULONG_MAX) { 1373 log_error("Physical volume data alignment offset is too big."); 1374 return 0; 1375 } 1376 1377 if (pp->data_alignment_offset && pp->pe_start) { 1378 log_warn("WARNING: Ignoring data alignment offset %" PRIu64 1379 " incompatible with --restorefile value (%" 1380 PRIu64").", pp->data_alignment_offset, pp->pe_start); 1381 pp->data_alignment_offset = 0; 1382 } 1383 1384 if (arg_sign_value(cmd, metadatasize_ARG, 0) == SIGN_MINUS) { 1385 log_error("Metadata size may not be negative"); 1386 return 0; 1387 } 1388 1389 pp->pvmetadatasize = arg_uint64_value(cmd, metadatasize_ARG, UINT64_C(0)); 1390 if (!pp->pvmetadatasize) 1391 pp->pvmetadatasize = find_config_tree_int(cmd, 1392 "metadata/pvmetadatasize", 1393 DEFAULT_PVMETADATASIZE); 1394 1395 pp->pvmetadatacopies = arg_int_value(cmd, pvmetadatacopies_ARG, -1); 1396 if (pp->pvmetadatacopies < 0) 1397 pp->pvmetadatacopies = find_config_tree_int(cmd, 1398 "metadata/pvmetadatacopies", 1399 DEFAULT_PVMETADATACOPIES); 1400 1401 return 1; 1402 } 1403 1404