1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2013 by Delphix. All rights reserved. 25 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>. 26 */ 27 28 /* 29 * Functions to convert between a list of vdevs and an nvlist representing the 30 * configuration. Each entry in the list can be one of: 31 * 32 * Device vdevs 33 * disk=(path=..., devid=...) 34 * file=(path=...) 35 * 36 * Group vdevs 37 * raidz[1|2]=(...) 38 * mirror=(...) 39 * 40 * Hot spares 41 * 42 * While the underlying implementation supports it, group vdevs cannot contain 43 * other group vdevs. All userland verification of devices is contained within 44 * this file. If successful, the nvlist returned can be passed directly to the 45 * kernel; we've done as much verification as possible in userland. 46 * 47 * Hot spares are a special case, and passed down as an array of disk vdevs, at 48 * the same level as the root of the vdev tree. 49 * 50 * The only function exported by this file is 'make_root_vdev'. The 51 * function performs several passes: 52 * 53 * 1. Construct the vdev specification. Performs syntax validation and 54 * makes sure each device is valid. 55 * 2. Check for devices in use. Using libdiskmgt, makes sure that no 56 * devices are also in use. Some can be overridden using the 'force' 57 * flag, others cannot. 58 * 3. Check for replication errors if the 'force' flag is not specified. 59 * validates that the replication level is consistent across the 60 * entire pool. 61 * 4. Call libzfs to label any whole disks with an EFI label. 62 */ 63 64 #include <assert.h> 65 #include <devid.h> 66 #include <errno.h> 67 #include <fcntl.h> 68 #include <libdiskmgt.h> 69 #include <libintl.h> 70 #include <libnvpair.h> 71 #include <limits.h> 72 #include <stdio.h> 73 #include <string.h> 74 #include <unistd.h> 75 #include <sys/efi_partition.h> 76 #include <sys/stat.h> 77 #include <sys/vtoc.h> 78 #include <sys/mntent.h> 79 80 #include "zpool_util.h" 81 82 #define BACKUP_SLICE "s2" 83 84 /* 85 * For any given vdev specification, we can have multiple errors. The 86 * vdev_error() function keeps track of whether we have seen an error yet, and 87 * prints out a header if its the first error we've seen. 88 */ 89 boolean_t error_seen; 90 boolean_t is_force; 91 92 /*PRINTFLIKE1*/ 93 static void 94 vdev_error(const char *fmt, ...) 95 { 96 va_list ap; 97 98 if (!error_seen) { 99 (void) fprintf(stderr, gettext("invalid vdev specification\n")); 100 if (!is_force) 101 (void) fprintf(stderr, gettext("use '-f' to override " 102 "the following errors:\n")); 103 else 104 (void) fprintf(stderr, gettext("the following errors " 105 "must be manually repaired:\n")); 106 error_seen = B_TRUE; 107 } 108 109 va_start(ap, fmt); 110 (void) vfprintf(stderr, fmt, ap); 111 va_end(ap); 112 } 113 114 static void 115 libdiskmgt_error(int error) 116 { 117 /* 118 * ENXIO/ENODEV is a valid error message if the device doesn't live in 119 * /dev/dsk. Don't bother printing an error message in this case. 120 */ 121 if (error == ENXIO || error == ENODEV) 122 return; 123 124 (void) fprintf(stderr, gettext("warning: device in use checking " 125 "failed: %s\n"), strerror(error)); 126 } 127 128 /* 129 * Validate a device, passing the bulk of the work off to libdiskmgt. 130 */ 131 static int 132 check_slice(const char *path, int force, boolean_t wholedisk, boolean_t isspare) 133 { 134 char *msg; 135 int error = 0; 136 dm_who_type_t who; 137 138 if (force) 139 who = DM_WHO_ZPOOL_FORCE; 140 else if (isspare) 141 who = DM_WHO_ZPOOL_SPARE; 142 else 143 who = DM_WHO_ZPOOL; 144 145 if (dm_inuse((char *)path, &msg, who, &error) || error) { 146 if (error != 0) { 147 libdiskmgt_error(error); 148 return (0); 149 } else { 150 vdev_error("%s", msg); 151 free(msg); 152 return (-1); 153 } 154 } 155 156 /* 157 * If we're given a whole disk, ignore overlapping slices since we're 158 * about to label it anyway. 159 */ 160 error = 0; 161 if (!wholedisk && !force && 162 (dm_isoverlapping((char *)path, &msg, &error) || error)) { 163 if (error == 0) { 164 /* dm_isoverlapping returned -1 */ 165 vdev_error(gettext("%s overlaps with %s\n"), path, msg); 166 free(msg); 167 return (-1); 168 } else if (error != ENODEV) { 169 /* libdiskmgt's devcache only handles physical drives */ 170 libdiskmgt_error(error); 171 return (0); 172 } 173 } 174 175 return (0); 176 } 177 178 179 /* 180 * Validate a whole disk. Iterate over all slices on the disk and make sure 181 * that none is in use by calling check_slice(). 182 */ 183 static int 184 check_disk(const char *name, dm_descriptor_t disk, int force, int isspare) 185 { 186 dm_descriptor_t *drive, *media, *slice; 187 int err = 0; 188 int i; 189 int ret; 190 191 /* 192 * Get the drive associated with this disk. This should never fail, 193 * because we already have an alias handle open for the device. 194 */ 195 if ((drive = dm_get_associated_descriptors(disk, DM_DRIVE, 196 &err)) == NULL || *drive == NULL) { 197 if (err) 198 libdiskmgt_error(err); 199 return (0); 200 } 201 202 if ((media = dm_get_associated_descriptors(*drive, DM_MEDIA, 203 &err)) == NULL) { 204 dm_free_descriptors(drive); 205 if (err) 206 libdiskmgt_error(err); 207 return (0); 208 } 209 210 dm_free_descriptors(drive); 211 212 /* 213 * It is possible that the user has specified a removable media drive, 214 * and the media is not present. 215 */ 216 if (*media == NULL) { 217 dm_free_descriptors(media); 218 vdev_error(gettext("'%s' has no media in drive\n"), name); 219 return (-1); 220 } 221 222 if ((slice = dm_get_associated_descriptors(*media, DM_SLICE, 223 &err)) == NULL) { 224 dm_free_descriptors(media); 225 if (err) 226 libdiskmgt_error(err); 227 return (0); 228 } 229 230 dm_free_descriptors(media); 231 232 ret = 0; 233 234 /* 235 * Iterate over all slices and report any errors. We don't care about 236 * overlapping slices because we are using the whole disk. 237 */ 238 for (i = 0; slice[i] != NULL; i++) { 239 char *name = dm_get_name(slice[i], &err); 240 241 if (check_slice(name, force, B_TRUE, isspare) != 0) 242 ret = -1; 243 244 dm_free_name(name); 245 } 246 247 dm_free_descriptors(slice); 248 return (ret); 249 } 250 251 /* 252 * Validate a device. 253 */ 254 static int 255 check_device(const char *path, boolean_t force, boolean_t isspare) 256 { 257 dm_descriptor_t desc; 258 int err; 259 char *dev; 260 261 /* 262 * For whole disks, libdiskmgt does not include the leading dev path. 263 */ 264 dev = strrchr(path, '/'); 265 assert(dev != NULL); 266 dev++; 267 if ((desc = dm_get_descriptor_by_name(DM_ALIAS, dev, &err)) != NULL) { 268 err = check_disk(path, desc, force, isspare); 269 dm_free_descriptor(desc); 270 return (err); 271 } 272 273 return (check_slice(path, force, B_FALSE, isspare)); 274 } 275 276 /* 277 * Check that a file is valid. All we can do in this case is check that it's 278 * not in use by another pool, and not in use by swap. 279 */ 280 static int 281 check_file(const char *file, boolean_t force, boolean_t isspare) 282 { 283 char *name; 284 int fd; 285 int ret = 0; 286 int err; 287 pool_state_t state; 288 boolean_t inuse; 289 290 if (dm_inuse_swap(file, &err)) { 291 if (err) 292 libdiskmgt_error(err); 293 else 294 vdev_error(gettext("%s is currently used by swap. " 295 "Please see swap(1M).\n"), file); 296 return (-1); 297 } 298 299 if ((fd = open(file, O_RDONLY)) < 0) 300 return (0); 301 302 if (zpool_in_use(g_zfs, fd, &state, &name, &inuse) == 0 && inuse) { 303 const char *desc; 304 305 switch (state) { 306 case POOL_STATE_ACTIVE: 307 desc = gettext("active"); 308 break; 309 310 case POOL_STATE_EXPORTED: 311 desc = gettext("exported"); 312 break; 313 314 case POOL_STATE_POTENTIALLY_ACTIVE: 315 desc = gettext("potentially active"); 316 break; 317 318 default: 319 desc = gettext("unknown"); 320 break; 321 } 322 323 /* 324 * Allow hot spares to be shared between pools. 325 */ 326 if (state == POOL_STATE_SPARE && isspare) 327 return (0); 328 329 if (state == POOL_STATE_ACTIVE || 330 state == POOL_STATE_SPARE || !force) { 331 switch (state) { 332 case POOL_STATE_SPARE: 333 vdev_error(gettext("%s is reserved as a hot " 334 "spare for pool %s\n"), file, name); 335 break; 336 default: 337 vdev_error(gettext("%s is part of %s pool " 338 "'%s'\n"), file, desc, name); 339 break; 340 } 341 ret = -1; 342 } 343 344 free(name); 345 } 346 347 (void) close(fd); 348 return (ret); 349 } 350 351 352 /* 353 * By "whole disk" we mean an entire physical disk (something we can 354 * label, toggle the write cache on, etc.) as opposed to the full 355 * capacity of a pseudo-device such as lofi or did. We act as if we 356 * are labeling the disk, which should be a pretty good test of whether 357 * it's a viable device or not. Returns B_TRUE if it is and B_FALSE if 358 * it isn't. 359 */ 360 static boolean_t 361 is_whole_disk(const char *arg) 362 { 363 struct dk_gpt *label; 364 int fd; 365 char path[MAXPATHLEN]; 366 367 (void) snprintf(path, sizeof (path), "%s%s%s", 368 ZFS_RDISK_ROOT, strrchr(arg, '/'), BACKUP_SLICE); 369 if ((fd = open(path, O_RDWR | O_NDELAY)) < 0) 370 return (B_FALSE); 371 if (efi_alloc_and_init(fd, EFI_NUMPAR, &label) != 0) { 372 (void) close(fd); 373 return (B_FALSE); 374 } 375 efi_free(label); 376 (void) close(fd); 377 return (B_TRUE); 378 } 379 380 /* 381 * Create a leaf vdev. Determine if this is a file or a device. If it's a 382 * device, fill in the device id to make a complete nvlist. Valid forms for a 383 * leaf vdev are: 384 * 385 * /dev/dsk/xxx Complete disk path 386 * /xxx Full path to file 387 * xxx Shorthand for /dev/dsk/xxx 388 */ 389 static nvlist_t * 390 make_leaf_vdev(const char *arg, uint64_t is_log) 391 { 392 char path[MAXPATHLEN]; 393 struct stat64 statbuf; 394 nvlist_t *vdev = NULL; 395 char *type = NULL; 396 boolean_t wholedisk = B_FALSE; 397 398 /* 399 * Determine what type of vdev this is, and put the full path into 400 * 'path'. We detect whether this is a device of file afterwards by 401 * checking the st_mode of the file. 402 */ 403 if (arg[0] == '/') { 404 /* 405 * Complete device or file path. Exact type is determined by 406 * examining the file descriptor afterwards. 407 */ 408 wholedisk = is_whole_disk(arg); 409 if (!wholedisk && (stat64(arg, &statbuf) != 0)) { 410 (void) fprintf(stderr, 411 gettext("cannot open '%s': %s\n"), 412 arg, strerror(errno)); 413 return (NULL); 414 } 415 416 (void) strlcpy(path, arg, sizeof (path)); 417 } else { 418 /* 419 * This may be a short path for a device, or it could be total 420 * gibberish. Check to see if it's a known device in 421 * /dev/dsk/. As part of this check, see if we've been given a 422 * an entire disk (minus the slice number). 423 */ 424 (void) snprintf(path, sizeof (path), "%s/%s", ZFS_DISK_ROOT, 425 arg); 426 wholedisk = is_whole_disk(path); 427 if (!wholedisk && (stat64(path, &statbuf) != 0)) { 428 /* 429 * If we got ENOENT, then the user gave us 430 * gibberish, so try to direct them with a 431 * reasonable error message. Otherwise, 432 * regurgitate strerror() since it's the best we 433 * can do. 434 */ 435 if (errno == ENOENT) { 436 (void) fprintf(stderr, 437 gettext("cannot open '%s': no such " 438 "device in %s\n"), arg, ZFS_DISK_ROOT); 439 (void) fprintf(stderr, 440 gettext("must be a full path or " 441 "shorthand device name\n")); 442 return (NULL); 443 } else { 444 (void) fprintf(stderr, 445 gettext("cannot open '%s': %s\n"), 446 path, strerror(errno)); 447 return (NULL); 448 } 449 } 450 } 451 452 /* 453 * Determine whether this is a device or a file. 454 */ 455 if (wholedisk || S_ISBLK(statbuf.st_mode)) { 456 type = VDEV_TYPE_DISK; 457 } else if (S_ISREG(statbuf.st_mode)) { 458 type = VDEV_TYPE_FILE; 459 } else { 460 (void) fprintf(stderr, gettext("cannot use '%s': must be a " 461 "block device or regular file\n"), path); 462 return (NULL); 463 } 464 465 /* 466 * Finally, we have the complete device or file, and we know that it is 467 * acceptable to use. Construct the nvlist to describe this vdev. All 468 * vdevs have a 'path' element, and devices also have a 'devid' element. 469 */ 470 verify(nvlist_alloc(&vdev, NV_UNIQUE_NAME, 0) == 0); 471 verify(nvlist_add_string(vdev, ZPOOL_CONFIG_PATH, path) == 0); 472 verify(nvlist_add_string(vdev, ZPOOL_CONFIG_TYPE, type) == 0); 473 verify(nvlist_add_uint64(vdev, ZPOOL_CONFIG_IS_LOG, is_log) == 0); 474 if (strcmp(type, VDEV_TYPE_DISK) == 0) 475 verify(nvlist_add_uint64(vdev, ZPOOL_CONFIG_WHOLE_DISK, 476 (uint64_t)wholedisk) == 0); 477 478 /* 479 * For a whole disk, defer getting its devid until after labeling it. 480 */ 481 if (S_ISBLK(statbuf.st_mode) && !wholedisk) { 482 /* 483 * Get the devid for the device. 484 */ 485 int fd; 486 ddi_devid_t devid; 487 char *minor = NULL, *devid_str = NULL; 488 489 if ((fd = open(path, O_RDONLY)) < 0) { 490 (void) fprintf(stderr, gettext("cannot open '%s': " 491 "%s\n"), path, strerror(errno)); 492 nvlist_free(vdev); 493 return (NULL); 494 } 495 496 if (devid_get(fd, &devid) == 0) { 497 if (devid_get_minor_name(fd, &minor) == 0 && 498 (devid_str = devid_str_encode(devid, minor)) != 499 NULL) { 500 verify(nvlist_add_string(vdev, 501 ZPOOL_CONFIG_DEVID, devid_str) == 0); 502 } 503 if (devid_str != NULL) 504 devid_str_free(devid_str); 505 if (minor != NULL) 506 devid_str_free(minor); 507 devid_free(devid); 508 } 509 510 (void) close(fd); 511 } 512 513 return (vdev); 514 } 515 516 /* 517 * Go through and verify the replication level of the pool is consistent. 518 * Performs the following checks: 519 * 520 * For the new spec, verifies that devices in mirrors and raidz are the 521 * same size. 522 * 523 * If the current configuration already has inconsistent replication 524 * levels, ignore any other potential problems in the new spec. 525 * 526 * Otherwise, make sure that the current spec (if there is one) and the new 527 * spec have consistent replication levels. 528 */ 529 typedef struct replication_level { 530 char *zprl_type; 531 uint64_t zprl_children; 532 uint64_t zprl_parity; 533 } replication_level_t; 534 535 #define ZPOOL_FUZZ (16 * 1024 * 1024) 536 537 /* 538 * Given a list of toplevel vdevs, return the current replication level. If 539 * the config is inconsistent, then NULL is returned. If 'fatal' is set, then 540 * an error message will be displayed for each self-inconsistent vdev. 541 */ 542 static replication_level_t * 543 get_replication(nvlist_t *nvroot, boolean_t fatal) 544 { 545 nvlist_t **top; 546 uint_t t, toplevels; 547 nvlist_t **child; 548 uint_t c, children; 549 nvlist_t *nv; 550 char *type; 551 replication_level_t lastrep = {0}; 552 replication_level_t rep; 553 replication_level_t *ret; 554 boolean_t dontreport; 555 556 ret = safe_malloc(sizeof (replication_level_t)); 557 558 verify(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 559 &top, &toplevels) == 0); 560 561 lastrep.zprl_type = NULL; 562 for (t = 0; t < toplevels; t++) { 563 uint64_t is_log = B_FALSE; 564 565 nv = top[t]; 566 567 /* 568 * For separate logs we ignore the top level vdev replication 569 * constraints. 570 */ 571 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG, &is_log); 572 if (is_log) 573 continue; 574 575 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, 576 &type) == 0); 577 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 578 &child, &children) != 0) { 579 /* 580 * This is a 'file' or 'disk' vdev. 581 */ 582 rep.zprl_type = type; 583 rep.zprl_children = 1; 584 rep.zprl_parity = 0; 585 } else { 586 uint64_t vdev_size; 587 588 /* 589 * This is a mirror or RAID-Z vdev. Go through and make 590 * sure the contents are all the same (files vs. disks), 591 * keeping track of the number of elements in the 592 * process. 593 * 594 * We also check that the size of each vdev (if it can 595 * be determined) is the same. 596 */ 597 rep.zprl_type = type; 598 rep.zprl_children = 0; 599 600 if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) { 601 verify(nvlist_lookup_uint64(nv, 602 ZPOOL_CONFIG_NPARITY, 603 &rep.zprl_parity) == 0); 604 assert(rep.zprl_parity != 0); 605 } else { 606 rep.zprl_parity = 0; 607 } 608 609 /* 610 * The 'dontreport' variable indicates that we've 611 * already reported an error for this spec, so don't 612 * bother doing it again. 613 */ 614 type = NULL; 615 dontreport = 0; 616 vdev_size = -1ULL; 617 for (c = 0; c < children; c++) { 618 nvlist_t *cnv = child[c]; 619 char *path; 620 struct stat64 statbuf; 621 uint64_t size = -1ULL; 622 char *childtype; 623 int fd, err; 624 625 rep.zprl_children++; 626 627 verify(nvlist_lookup_string(cnv, 628 ZPOOL_CONFIG_TYPE, &childtype) == 0); 629 630 /* 631 * If this is a replacing or spare vdev, then 632 * get the real first child of the vdev. 633 */ 634 if (strcmp(childtype, 635 VDEV_TYPE_REPLACING) == 0 || 636 strcmp(childtype, VDEV_TYPE_SPARE) == 0) { 637 nvlist_t **rchild; 638 uint_t rchildren; 639 640 verify(nvlist_lookup_nvlist_array(cnv, 641 ZPOOL_CONFIG_CHILDREN, &rchild, 642 &rchildren) == 0); 643 assert(rchildren == 2); 644 cnv = rchild[0]; 645 646 verify(nvlist_lookup_string(cnv, 647 ZPOOL_CONFIG_TYPE, 648 &childtype) == 0); 649 } 650 651 verify(nvlist_lookup_string(cnv, 652 ZPOOL_CONFIG_PATH, &path) == 0); 653 654 /* 655 * If we have a raidz/mirror that combines disks 656 * with files, report it as an error. 657 */ 658 if (!dontreport && type != NULL && 659 strcmp(type, childtype) != 0) { 660 if (ret != NULL) 661 free(ret); 662 ret = NULL; 663 if (fatal) 664 vdev_error(gettext( 665 "mismatched replication " 666 "level: %s contains both " 667 "files and devices\n"), 668 rep.zprl_type); 669 else 670 return (NULL); 671 dontreport = B_TRUE; 672 } 673 674 /* 675 * According to stat(2), the value of 'st_size' 676 * is undefined for block devices and character 677 * devices. But there is no effective way to 678 * determine the real size in userland. 679 * 680 * Instead, we'll take advantage of an 681 * implementation detail of spec_size(). If the 682 * device is currently open, then we (should) 683 * return a valid size. 684 * 685 * If we still don't get a valid size (indicated 686 * by a size of 0 or MAXOFFSET_T), then ignore 687 * this device altogether. 688 */ 689 if ((fd = open(path, O_RDONLY)) >= 0) { 690 err = fstat64(fd, &statbuf); 691 (void) close(fd); 692 } else { 693 err = stat64(path, &statbuf); 694 } 695 696 if (err != 0 || 697 statbuf.st_size == 0 || 698 statbuf.st_size == MAXOFFSET_T) 699 continue; 700 701 size = statbuf.st_size; 702 703 /* 704 * Also make sure that devices and 705 * slices have a consistent size. If 706 * they differ by a significant amount 707 * (~16MB) then report an error. 708 */ 709 if (!dontreport && 710 (vdev_size != -1ULL && 711 (labs(size - vdev_size) > 712 ZPOOL_FUZZ))) { 713 if (ret != NULL) 714 free(ret); 715 ret = NULL; 716 if (fatal) 717 vdev_error(gettext( 718 "%s contains devices of " 719 "different sizes\n"), 720 rep.zprl_type); 721 else 722 return (NULL); 723 dontreport = B_TRUE; 724 } 725 726 type = childtype; 727 vdev_size = size; 728 } 729 } 730 731 /* 732 * At this point, we have the replication of the last toplevel 733 * vdev in 'rep'. Compare it to 'lastrep' to see if its 734 * different. 735 */ 736 if (lastrep.zprl_type != NULL) { 737 if (strcmp(lastrep.zprl_type, rep.zprl_type) != 0) { 738 if (ret != NULL) 739 free(ret); 740 ret = NULL; 741 if (fatal) 742 vdev_error(gettext( 743 "mismatched replication level: " 744 "both %s and %s vdevs are " 745 "present\n"), 746 lastrep.zprl_type, rep.zprl_type); 747 else 748 return (NULL); 749 } else if (lastrep.zprl_parity != rep.zprl_parity) { 750 if (ret) 751 free(ret); 752 ret = NULL; 753 if (fatal) 754 vdev_error(gettext( 755 "mismatched replication level: " 756 "both %llu and %llu device parity " 757 "%s vdevs are present\n"), 758 lastrep.zprl_parity, 759 rep.zprl_parity, 760 rep.zprl_type); 761 else 762 return (NULL); 763 } else if (lastrep.zprl_children != rep.zprl_children) { 764 if (ret) 765 free(ret); 766 ret = NULL; 767 if (fatal) 768 vdev_error(gettext( 769 "mismatched replication level: " 770 "both %llu-way and %llu-way %s " 771 "vdevs are present\n"), 772 lastrep.zprl_children, 773 rep.zprl_children, 774 rep.zprl_type); 775 else 776 return (NULL); 777 } 778 } 779 lastrep = rep; 780 } 781 782 if (ret != NULL) 783 *ret = rep; 784 785 return (ret); 786 } 787 788 /* 789 * Check the replication level of the vdev spec against the current pool. Calls 790 * get_replication() to make sure the new spec is self-consistent. If the pool 791 * has a consistent replication level, then we ignore any errors. Otherwise, 792 * report any difference between the two. 793 */ 794 static int 795 check_replication(nvlist_t *config, nvlist_t *newroot) 796 { 797 nvlist_t **child; 798 uint_t children; 799 replication_level_t *current = NULL, *new; 800 int ret; 801 802 /* 803 * If we have a current pool configuration, check to see if it's 804 * self-consistent. If not, simply return success. 805 */ 806 if (config != NULL) { 807 nvlist_t *nvroot; 808 809 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 810 &nvroot) == 0); 811 if ((current = get_replication(nvroot, B_FALSE)) == NULL) 812 return (0); 813 } 814 /* 815 * for spares there may be no children, and therefore no 816 * replication level to check 817 */ 818 if ((nvlist_lookup_nvlist_array(newroot, ZPOOL_CONFIG_CHILDREN, 819 &child, &children) != 0) || (children == 0)) { 820 free(current); 821 return (0); 822 } 823 824 /* 825 * If all we have is logs then there's no replication level to check. 826 */ 827 if (num_logs(newroot) == children) { 828 free(current); 829 return (0); 830 } 831 832 /* 833 * Get the replication level of the new vdev spec, reporting any 834 * inconsistencies found. 835 */ 836 if ((new = get_replication(newroot, B_TRUE)) == NULL) { 837 free(current); 838 return (-1); 839 } 840 841 /* 842 * Check to see if the new vdev spec matches the replication level of 843 * the current pool. 844 */ 845 ret = 0; 846 if (current != NULL) { 847 if (strcmp(current->zprl_type, new->zprl_type) != 0) { 848 vdev_error(gettext( 849 "mismatched replication level: pool uses %s " 850 "and new vdev is %s\n"), 851 current->zprl_type, new->zprl_type); 852 ret = -1; 853 } else if (current->zprl_parity != new->zprl_parity) { 854 vdev_error(gettext( 855 "mismatched replication level: pool uses %llu " 856 "device parity and new vdev uses %llu\n"), 857 current->zprl_parity, new->zprl_parity); 858 ret = -1; 859 } else if (current->zprl_children != new->zprl_children) { 860 vdev_error(gettext( 861 "mismatched replication level: pool uses %llu-way " 862 "%s and new vdev uses %llu-way %s\n"), 863 current->zprl_children, current->zprl_type, 864 new->zprl_children, new->zprl_type); 865 ret = -1; 866 } 867 } 868 869 free(new); 870 if (current != NULL) 871 free(current); 872 873 return (ret); 874 } 875 876 /* 877 * Go through and find any whole disks in the vdev specification, labelling them 878 * as appropriate. When constructing the vdev spec, we were unable to open this 879 * device in order to provide a devid. Now that we have labelled the disk and 880 * know that slice 0 is valid, we can construct the devid now. 881 * 882 * If the disk was already labeled with an EFI label, we will have gotten the 883 * devid already (because we were able to open the whole disk). Otherwise, we 884 * need to get the devid after we label the disk. 885 */ 886 static int 887 make_disks(zpool_handle_t *zhp, nvlist_t *nv) 888 { 889 nvlist_t **child; 890 uint_t c, children; 891 char *type, *path, *diskname; 892 char buf[MAXPATHLEN]; 893 uint64_t wholedisk; 894 int fd; 895 int ret; 896 ddi_devid_t devid; 897 char *minor = NULL, *devid_str = NULL; 898 899 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); 900 901 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 902 &child, &children) != 0) { 903 904 if (strcmp(type, VDEV_TYPE_DISK) != 0) 905 return (0); 906 907 /* 908 * We have a disk device. Get the path to the device 909 * and see if it's a whole disk by appending the backup 910 * slice and stat()ing the device. 911 */ 912 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 913 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK, 914 &wholedisk) != 0 || !wholedisk) 915 return (0); 916 917 diskname = strrchr(path, '/'); 918 assert(diskname != NULL); 919 diskname++; 920 if (zpool_label_disk(g_zfs, zhp, diskname) == -1) 921 return (-1); 922 923 /* 924 * Fill in the devid, now that we've labeled the disk. 925 */ 926 (void) snprintf(buf, sizeof (buf), "%ss0", path); 927 if ((fd = open(buf, O_RDONLY)) < 0) { 928 (void) fprintf(stderr, 929 gettext("cannot open '%s': %s\n"), 930 buf, strerror(errno)); 931 return (-1); 932 } 933 934 if (devid_get(fd, &devid) == 0) { 935 if (devid_get_minor_name(fd, &minor) == 0 && 936 (devid_str = devid_str_encode(devid, minor)) != 937 NULL) { 938 verify(nvlist_add_string(nv, 939 ZPOOL_CONFIG_DEVID, devid_str) == 0); 940 } 941 if (devid_str != NULL) 942 devid_str_free(devid_str); 943 if (minor != NULL) 944 devid_str_free(minor); 945 devid_free(devid); 946 } 947 948 /* 949 * Update the path to refer to the 's0' slice. The presence of 950 * the 'whole_disk' field indicates to the CLI that we should 951 * chop off the slice number when displaying the device in 952 * future output. 953 */ 954 verify(nvlist_add_string(nv, ZPOOL_CONFIG_PATH, buf) == 0); 955 956 (void) close(fd); 957 958 return (0); 959 } 960 961 for (c = 0; c < children; c++) 962 if ((ret = make_disks(zhp, child[c])) != 0) 963 return (ret); 964 965 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 966 &child, &children) == 0) 967 for (c = 0; c < children; c++) 968 if ((ret = make_disks(zhp, child[c])) != 0) 969 return (ret); 970 971 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 972 &child, &children) == 0) 973 for (c = 0; c < children; c++) 974 if ((ret = make_disks(zhp, child[c])) != 0) 975 return (ret); 976 977 return (0); 978 } 979 980 /* 981 * Determine if the given path is a hot spare within the given configuration. 982 */ 983 static boolean_t 984 is_spare(nvlist_t *config, const char *path) 985 { 986 int fd; 987 pool_state_t state; 988 char *name = NULL; 989 nvlist_t *label; 990 uint64_t guid, spareguid; 991 nvlist_t *nvroot; 992 nvlist_t **spares; 993 uint_t i, nspares; 994 boolean_t inuse; 995 996 if ((fd = open(path, O_RDONLY)) < 0) 997 return (B_FALSE); 998 999 if (zpool_in_use(g_zfs, fd, &state, &name, &inuse) != 0 || 1000 !inuse || 1001 state != POOL_STATE_SPARE || 1002 zpool_read_label(fd, &label) != 0) { 1003 free(name); 1004 (void) close(fd); 1005 return (B_FALSE); 1006 } 1007 free(name); 1008 (void) close(fd); 1009 1010 verify(nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID, &guid) == 0); 1011 nvlist_free(label); 1012 1013 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 1014 &nvroot) == 0); 1015 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 1016 &spares, &nspares) == 0) { 1017 for (i = 0; i < nspares; i++) { 1018 verify(nvlist_lookup_uint64(spares[i], 1019 ZPOOL_CONFIG_GUID, &spareguid) == 0); 1020 if (spareguid == guid) 1021 return (B_TRUE); 1022 } 1023 } 1024 1025 return (B_FALSE); 1026 } 1027 1028 /* 1029 * Go through and find any devices that are in use. We rely on libdiskmgt for 1030 * the majority of this task. 1031 */ 1032 static boolean_t 1033 is_device_in_use(nvlist_t *config, nvlist_t *nv, boolean_t force, 1034 boolean_t replacing, boolean_t isspare) 1035 { 1036 nvlist_t **child; 1037 uint_t c, children; 1038 char *type, *path; 1039 int ret = 0; 1040 char buf[MAXPATHLEN]; 1041 uint64_t wholedisk; 1042 boolean_t anyinuse = B_FALSE; 1043 1044 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); 1045 1046 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1047 &child, &children) != 0) { 1048 1049 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 1050 1051 /* 1052 * As a generic check, we look to see if this is a replace of a 1053 * hot spare within the same pool. If so, we allow it 1054 * regardless of what libdiskmgt or zpool_in_use() says. 1055 */ 1056 if (replacing) { 1057 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK, 1058 &wholedisk) == 0 && wholedisk) 1059 (void) snprintf(buf, sizeof (buf), "%ss0", 1060 path); 1061 else 1062 (void) strlcpy(buf, path, sizeof (buf)); 1063 1064 if (is_spare(config, buf)) 1065 return (B_FALSE); 1066 } 1067 1068 if (strcmp(type, VDEV_TYPE_DISK) == 0) 1069 ret = check_device(path, force, isspare); 1070 else if (strcmp(type, VDEV_TYPE_FILE) == 0) 1071 ret = check_file(path, force, isspare); 1072 1073 return (ret != 0); 1074 } 1075 1076 for (c = 0; c < children; c++) 1077 if (is_device_in_use(config, child[c], force, replacing, 1078 B_FALSE)) 1079 anyinuse = B_TRUE; 1080 1081 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 1082 &child, &children) == 0) 1083 for (c = 0; c < children; c++) 1084 if (is_device_in_use(config, child[c], force, replacing, 1085 B_TRUE)) 1086 anyinuse = B_TRUE; 1087 1088 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 1089 &child, &children) == 0) 1090 for (c = 0; c < children; c++) 1091 if (is_device_in_use(config, child[c], force, replacing, 1092 B_FALSE)) 1093 anyinuse = B_TRUE; 1094 1095 return (anyinuse); 1096 } 1097 1098 static const char * 1099 is_grouping(const char *type, int *mindev, int *maxdev) 1100 { 1101 if (strncmp(type, "raidz", 5) == 0) { 1102 const char *p = type + 5; 1103 char *end; 1104 long nparity; 1105 1106 if (*p == '\0') { 1107 nparity = 1; 1108 } else if (*p == '0') { 1109 return (NULL); /* no zero prefixes allowed */ 1110 } else { 1111 errno = 0; 1112 nparity = strtol(p, &end, 10); 1113 if (errno != 0 || nparity < 1 || nparity >= 255 || 1114 *end != '\0') 1115 return (NULL); 1116 } 1117 1118 if (mindev != NULL) 1119 *mindev = nparity + 1; 1120 if (maxdev != NULL) 1121 *maxdev = 255; 1122 return (VDEV_TYPE_RAIDZ); 1123 } 1124 1125 if (maxdev != NULL) 1126 *maxdev = INT_MAX; 1127 1128 if (strcmp(type, "mirror") == 0) { 1129 if (mindev != NULL) 1130 *mindev = 2; 1131 return (VDEV_TYPE_MIRROR); 1132 } 1133 1134 if (strcmp(type, "spare") == 0) { 1135 if (mindev != NULL) 1136 *mindev = 1; 1137 return (VDEV_TYPE_SPARE); 1138 } 1139 1140 if (strcmp(type, "log") == 0) { 1141 if (mindev != NULL) 1142 *mindev = 1; 1143 return (VDEV_TYPE_LOG); 1144 } 1145 1146 if (strcmp(type, "cache") == 0) { 1147 if (mindev != NULL) 1148 *mindev = 1; 1149 return (VDEV_TYPE_L2CACHE); 1150 } 1151 1152 return (NULL); 1153 } 1154 1155 /* 1156 * Construct a syntactically valid vdev specification, 1157 * and ensure that all devices and files exist and can be opened. 1158 * Note: we don't bother freeing anything in the error paths 1159 * because the program is just going to exit anyway. 1160 */ 1161 nvlist_t * 1162 construct_spec(int argc, char **argv) 1163 { 1164 nvlist_t *nvroot, *nv, **top, **spares, **l2cache; 1165 int t, toplevels, mindev, maxdev, nspares, nlogs, nl2cache; 1166 const char *type; 1167 uint64_t is_log; 1168 boolean_t seen_logs; 1169 1170 top = NULL; 1171 toplevels = 0; 1172 spares = NULL; 1173 l2cache = NULL; 1174 nspares = 0; 1175 nlogs = 0; 1176 nl2cache = 0; 1177 is_log = B_FALSE; 1178 seen_logs = B_FALSE; 1179 1180 while (argc > 0) { 1181 nv = NULL; 1182 1183 /* 1184 * If it's a mirror or raidz, the subsequent arguments are 1185 * its leaves -- until we encounter the next mirror or raidz. 1186 */ 1187 if ((type = is_grouping(argv[0], &mindev, &maxdev)) != NULL) { 1188 nvlist_t **child = NULL; 1189 int c, children = 0; 1190 1191 if (strcmp(type, VDEV_TYPE_SPARE) == 0) { 1192 if (spares != NULL) { 1193 (void) fprintf(stderr, 1194 gettext("invalid vdev " 1195 "specification: 'spare' can be " 1196 "specified only once\n")); 1197 return (NULL); 1198 } 1199 is_log = B_FALSE; 1200 } 1201 1202 if (strcmp(type, VDEV_TYPE_LOG) == 0) { 1203 if (seen_logs) { 1204 (void) fprintf(stderr, 1205 gettext("invalid vdev " 1206 "specification: 'log' can be " 1207 "specified only once\n")); 1208 return (NULL); 1209 } 1210 seen_logs = B_TRUE; 1211 is_log = B_TRUE; 1212 argc--; 1213 argv++; 1214 /* 1215 * A log is not a real grouping device. 1216 * We just set is_log and continue. 1217 */ 1218 continue; 1219 } 1220 1221 if (strcmp(type, VDEV_TYPE_L2CACHE) == 0) { 1222 if (l2cache != NULL) { 1223 (void) fprintf(stderr, 1224 gettext("invalid vdev " 1225 "specification: 'cache' can be " 1226 "specified only once\n")); 1227 return (NULL); 1228 } 1229 is_log = B_FALSE; 1230 } 1231 1232 if (is_log) { 1233 if (strcmp(type, VDEV_TYPE_MIRROR) != 0) { 1234 (void) fprintf(stderr, 1235 gettext("invalid vdev " 1236 "specification: unsupported 'log' " 1237 "device: %s\n"), type); 1238 return (NULL); 1239 } 1240 nlogs++; 1241 } 1242 1243 for (c = 1; c < argc; c++) { 1244 if (is_grouping(argv[c], NULL, NULL) != NULL) 1245 break; 1246 children++; 1247 child = realloc(child, 1248 children * sizeof (nvlist_t *)); 1249 if (child == NULL) 1250 zpool_no_memory(); 1251 if ((nv = make_leaf_vdev(argv[c], B_FALSE)) 1252 == NULL) 1253 return (NULL); 1254 child[children - 1] = nv; 1255 } 1256 1257 if (children < mindev) { 1258 (void) fprintf(stderr, gettext("invalid vdev " 1259 "specification: %s requires at least %d " 1260 "devices\n"), argv[0], mindev); 1261 return (NULL); 1262 } 1263 1264 if (children > maxdev) { 1265 (void) fprintf(stderr, gettext("invalid vdev " 1266 "specification: %s supports no more than " 1267 "%d devices\n"), argv[0], maxdev); 1268 return (NULL); 1269 } 1270 1271 argc -= c; 1272 argv += c; 1273 1274 if (strcmp(type, VDEV_TYPE_SPARE) == 0) { 1275 spares = child; 1276 nspares = children; 1277 continue; 1278 } else if (strcmp(type, VDEV_TYPE_L2CACHE) == 0) { 1279 l2cache = child; 1280 nl2cache = children; 1281 continue; 1282 } else { 1283 verify(nvlist_alloc(&nv, NV_UNIQUE_NAME, 1284 0) == 0); 1285 verify(nvlist_add_string(nv, ZPOOL_CONFIG_TYPE, 1286 type) == 0); 1287 verify(nvlist_add_uint64(nv, 1288 ZPOOL_CONFIG_IS_LOG, is_log) == 0); 1289 if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) { 1290 verify(nvlist_add_uint64(nv, 1291 ZPOOL_CONFIG_NPARITY, 1292 mindev - 1) == 0); 1293 } 1294 verify(nvlist_add_nvlist_array(nv, 1295 ZPOOL_CONFIG_CHILDREN, child, 1296 children) == 0); 1297 1298 for (c = 0; c < children; c++) 1299 nvlist_free(child[c]); 1300 free(child); 1301 } 1302 } else { 1303 /* 1304 * We have a device. Pass off to make_leaf_vdev() to 1305 * construct the appropriate nvlist describing the vdev. 1306 */ 1307 if ((nv = make_leaf_vdev(argv[0], is_log)) == NULL) 1308 return (NULL); 1309 if (is_log) 1310 nlogs++; 1311 argc--; 1312 argv++; 1313 } 1314 1315 toplevels++; 1316 top = realloc(top, toplevels * sizeof (nvlist_t *)); 1317 if (top == NULL) 1318 zpool_no_memory(); 1319 top[toplevels - 1] = nv; 1320 } 1321 1322 if (toplevels == 0 && nspares == 0 && nl2cache == 0) { 1323 (void) fprintf(stderr, gettext("invalid vdev " 1324 "specification: at least one toplevel vdev must be " 1325 "specified\n")); 1326 return (NULL); 1327 } 1328 1329 if (seen_logs && nlogs == 0) { 1330 (void) fprintf(stderr, gettext("invalid vdev specification: " 1331 "log requires at least 1 device\n")); 1332 return (NULL); 1333 } 1334 1335 /* 1336 * Finally, create nvroot and add all top-level vdevs to it. 1337 */ 1338 verify(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, 0) == 0); 1339 verify(nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE, 1340 VDEV_TYPE_ROOT) == 0); 1341 verify(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 1342 top, toplevels) == 0); 1343 if (nspares != 0) 1344 verify(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 1345 spares, nspares) == 0); 1346 if (nl2cache != 0) 1347 verify(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 1348 l2cache, nl2cache) == 0); 1349 1350 for (t = 0; t < toplevels; t++) 1351 nvlist_free(top[t]); 1352 for (t = 0; t < nspares; t++) 1353 nvlist_free(spares[t]); 1354 for (t = 0; t < nl2cache; t++) 1355 nvlist_free(l2cache[t]); 1356 if (spares) 1357 free(spares); 1358 if (l2cache) 1359 free(l2cache); 1360 free(top); 1361 1362 return (nvroot); 1363 } 1364 1365 nvlist_t * 1366 split_mirror_vdev(zpool_handle_t *zhp, char *newname, nvlist_t *props, 1367 splitflags_t flags, int argc, char **argv) 1368 { 1369 nvlist_t *newroot = NULL, **child; 1370 uint_t c, children; 1371 1372 if (argc > 0) { 1373 if ((newroot = construct_spec(argc, argv)) == NULL) { 1374 (void) fprintf(stderr, gettext("Unable to build a " 1375 "pool from the specified devices\n")); 1376 return (NULL); 1377 } 1378 1379 if (!flags.dryrun && make_disks(zhp, newroot) != 0) { 1380 nvlist_free(newroot); 1381 return (NULL); 1382 } 1383 1384 /* avoid any tricks in the spec */ 1385 verify(nvlist_lookup_nvlist_array(newroot, 1386 ZPOOL_CONFIG_CHILDREN, &child, &children) == 0); 1387 for (c = 0; c < children; c++) { 1388 char *path; 1389 const char *type; 1390 int min, max; 1391 1392 verify(nvlist_lookup_string(child[c], 1393 ZPOOL_CONFIG_PATH, &path) == 0); 1394 if ((type = is_grouping(path, &min, &max)) != NULL) { 1395 (void) fprintf(stderr, gettext("Cannot use " 1396 "'%s' as a device for splitting\n"), type); 1397 nvlist_free(newroot); 1398 return (NULL); 1399 } 1400 } 1401 } 1402 1403 if (zpool_vdev_split(zhp, newname, &newroot, props, flags) != 0) { 1404 nvlist_free(newroot); 1405 return (NULL); 1406 } 1407 1408 return (newroot); 1409 } 1410 1411 /* 1412 * Get and validate the contents of the given vdev specification. This ensures 1413 * that the nvlist returned is well-formed, that all the devices exist, and that 1414 * they are not currently in use by any other known consumer. The 'poolconfig' 1415 * parameter is the current configuration of the pool when adding devices 1416 * existing pool, and is used to perform additional checks, such as changing the 1417 * replication level of the pool. It can be 'NULL' to indicate that this is a 1418 * new pool. The 'force' flag controls whether devices should be forcefully 1419 * added, even if they appear in use. 1420 */ 1421 nvlist_t * 1422 make_root_vdev(zpool_handle_t *zhp, int force, int check_rep, 1423 boolean_t replacing, boolean_t dryrun, int argc, char **argv) 1424 { 1425 nvlist_t *newroot; 1426 nvlist_t *poolconfig = NULL; 1427 is_force = force; 1428 1429 /* 1430 * Construct the vdev specification. If this is successful, we know 1431 * that we have a valid specification, and that all devices can be 1432 * opened. 1433 */ 1434 if ((newroot = construct_spec(argc, argv)) == NULL) 1435 return (NULL); 1436 1437 if (zhp && ((poolconfig = zpool_get_config(zhp, NULL)) == NULL)) 1438 return (NULL); 1439 1440 /* 1441 * Validate each device to make sure that its not shared with another 1442 * subsystem. We do this even if 'force' is set, because there are some 1443 * uses (such as a dedicated dump device) that even '-f' cannot 1444 * override. 1445 */ 1446 if (is_device_in_use(poolconfig, newroot, force, replacing, B_FALSE)) { 1447 nvlist_free(newroot); 1448 return (NULL); 1449 } 1450 1451 /* 1452 * Check the replication level of the given vdevs and report any errors 1453 * found. We include the existing pool spec, if any, as we need to 1454 * catch changes against the existing replication level. 1455 */ 1456 if (check_rep && check_replication(poolconfig, newroot) != 0) { 1457 nvlist_free(newroot); 1458 return (NULL); 1459 } 1460 1461 /* 1462 * Run through the vdev specification and label any whole disks found. 1463 */ 1464 if (!dryrun && make_disks(zhp, newroot) != 0) { 1465 nvlist_free(newroot); 1466 return (NULL); 1467 } 1468 1469 return (newroot); 1470 } 1471