1fa9e4066Sahrens /* 2fa9e4066Sahrens * CDDL HEADER START 3fa9e4066Sahrens * 4fa9e4066Sahrens * The contents of this file are subject to the terms of the 5ea8dc4b6Seschrock * Common Development and Distribution License (the "License"). 6ea8dc4b6Seschrock * You may not use this file except in compliance with the License. 7fa9e4066Sahrens * 8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing. 10fa9e4066Sahrens * See the License for the specific language governing permissions 11fa9e4066Sahrens * and limitations under the License. 12fa9e4066Sahrens * 13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each 14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the 16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying 17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18fa9e4066Sahrens * 19fa9e4066Sahrens * CDDL HEADER END 20fa9e4066Sahrens */ 2199653d4eSeschrock 22fa9e4066Sahrens /* 23*3f9d6ad7SLin Ling * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 24fa9e4066Sahrens */ 25fa9e4066Sahrens 26fa9e4066Sahrens /* 27fa9e4066Sahrens * Functions to convert between a list of vdevs and an nvlist representing the 28fa9e4066Sahrens * configuration. Each entry in the list can be one of: 29fa9e4066Sahrens * 30fa9e4066Sahrens * Device vdevs 31fa9e4066Sahrens * disk=(path=..., devid=...) 32fa9e4066Sahrens * file=(path=...) 33fa9e4066Sahrens * 34fa9e4066Sahrens * Group vdevs 3599653d4eSeschrock * raidz[1|2]=(...) 36fa9e4066Sahrens * mirror=(...) 37fa9e4066Sahrens * 3899653d4eSeschrock * Hot spares 3999653d4eSeschrock * 40fa9e4066Sahrens * While the underlying implementation supports it, group vdevs cannot contain 41fa9e4066Sahrens * other group vdevs. All userland verification of devices is contained within 42fa9e4066Sahrens * this file. If successful, the nvlist returned can be passed directly to the 43fa9e4066Sahrens * kernel; we've done as much verification as possible in userland. 44fa9e4066Sahrens * 4599653d4eSeschrock * Hot spares are a special case, and passed down as an array of disk vdevs, at 4699653d4eSeschrock * the same level as the root of the vdev tree. 4799653d4eSeschrock * 488488aeb5Staylor * The only function exported by this file is 'make_root_vdev'. The 498488aeb5Staylor * function performs several passes: 50fa9e4066Sahrens * 51fa9e4066Sahrens * 1. Construct the vdev specification. Performs syntax validation and 52fa9e4066Sahrens * makes sure each device is valid. 53fa9e4066Sahrens * 2. Check for devices in use. Using libdiskmgt, makes sure that no 54fa9e4066Sahrens * devices are also in use. Some can be overridden using the 'force' 55fa9e4066Sahrens * flag, others cannot. 56fa9e4066Sahrens * 3. Check for replication errors if the 'force' flag is not specified. 57fa9e4066Sahrens * validates that the replication level is consistent across the 58fa9e4066Sahrens * entire pool. 598488aeb5Staylor * 4. Call libzfs to label any whole disks with an EFI label. 60fa9e4066Sahrens */ 61fa9e4066Sahrens 62fa9e4066Sahrens #include <assert.h> 63fa9e4066Sahrens #include <devid.h> 64fa9e4066Sahrens #include <errno.h> 65fa9e4066Sahrens #include <fcntl.h> 66fa9e4066Sahrens #include <libdiskmgt.h> 67fa9e4066Sahrens #include <libintl.h> 68fa9e4066Sahrens #include <libnvpair.h> 69f94275ceSAdam Leventhal #include <limits.h> 70fa9e4066Sahrens #include <stdio.h> 71fa9e4066Sahrens #include <string.h> 72fa9e4066Sahrens #include <unistd.h> 73fa9e4066Sahrens #include <sys/efi_partition.h> 74fa9e4066Sahrens #include <sys/stat.h> 75fa9e4066Sahrens #include <sys/vtoc.h> 76fa9e4066Sahrens #include <sys/mntent.h> 77fa9e4066Sahrens 78fa9e4066Sahrens #include "zpool_util.h" 79fa9e4066Sahrens 80fa9e4066Sahrens #define DISK_ROOT "/dev/dsk" 81fa9e4066Sahrens #define RDISK_ROOT "/dev/rdsk" 82fa9e4066Sahrens #define BACKUP_SLICE "s2" 83fa9e4066Sahrens 84fa9e4066Sahrens /* 85fa9e4066Sahrens * For any given vdev specification, we can have multiple errors. The 86fa9e4066Sahrens * vdev_error() function keeps track of whether we have seen an error yet, and 87fa9e4066Sahrens * prints out a header if its the first error we've seen. 88fa9e4066Sahrens */ 8999653d4eSeschrock boolean_t error_seen; 9099653d4eSeschrock boolean_t is_force; 91fa9e4066Sahrens 9299653d4eSeschrock /*PRINTFLIKE1*/ 9399653d4eSeschrock static void 94fa9e4066Sahrens vdev_error(const char *fmt, ...) 95fa9e4066Sahrens { 96fa9e4066Sahrens va_list ap; 97fa9e4066Sahrens 98fa9e4066Sahrens if (!error_seen) { 99fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid vdev specification\n")); 100fa9e4066Sahrens if (!is_force) 101fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-f' to override " 102fa9e4066Sahrens "the following errors:\n")); 103fa9e4066Sahrens else 104fa9e4066Sahrens (void) fprintf(stderr, gettext("the following errors " 105fa9e4066Sahrens "must be manually repaired:\n")); 10699653d4eSeschrock error_seen = B_TRUE; 107fa9e4066Sahrens } 108fa9e4066Sahrens 109fa9e4066Sahrens va_start(ap, fmt); 110fa9e4066Sahrens (void) vfprintf(stderr, fmt, ap); 111fa9e4066Sahrens va_end(ap); 112fa9e4066Sahrens } 113fa9e4066Sahrens 11446a2abf2Seschrock static void 11546a2abf2Seschrock libdiskmgt_error(int error) 116fa9e4066Sahrens { 117ea8dc4b6Seschrock /* 11899653d4eSeschrock * ENXIO/ENODEV is a valid error message if the device doesn't live in 119ea8dc4b6Seschrock * /dev/dsk. Don't bother printing an error message in this case. 120ea8dc4b6Seschrock */ 12199653d4eSeschrock if (error == ENXIO || error == ENODEV) 122ea8dc4b6Seschrock return; 123ea8dc4b6Seschrock 12446a2abf2Seschrock (void) fprintf(stderr, gettext("warning: device in use checking " 12546a2abf2Seschrock "failed: %s\n"), strerror(error)); 126fa9e4066Sahrens } 127fa9e4066Sahrens 128fa9e4066Sahrens /* 12946a2abf2Seschrock * Validate a device, passing the bulk of the work off to libdiskmgt. 130fa9e4066Sahrens */ 1318488aeb5Staylor static int 13299653d4eSeschrock check_slice(const char *path, int force, boolean_t wholedisk, boolean_t isspare) 133fa9e4066Sahrens { 13446a2abf2Seschrock char *msg; 13546a2abf2Seschrock int error = 0; 13603a818bcSmmusante dm_who_type_t who; 137fa9e4066Sahrens 13803a818bcSmmusante if (force) 13903a818bcSmmusante who = DM_WHO_ZPOOL_FORCE; 14003a818bcSmmusante else if (isspare) 14103a818bcSmmusante who = DM_WHO_ZPOOL_SPARE; 14203a818bcSmmusante else 14303a818bcSmmusante who = DM_WHO_ZPOOL; 14403a818bcSmmusante 14503a818bcSmmusante if (dm_inuse((char *)path, &msg, who, &error) || error) { 14646a2abf2Seschrock if (error != 0) { 14746a2abf2Seschrock libdiskmgt_error(error); 14846a2abf2Seschrock return (0); 14946657f8dSmmusante } else { 15046a2abf2Seschrock vdev_error("%s", msg); 15146a2abf2Seschrock free(msg); 152181c2f42Smmusante return (-1); 153fa9e4066Sahrens } 154fa9e4066Sahrens } 155fa9e4066Sahrens 156fa9e4066Sahrens /* 15746a2abf2Seschrock * If we're given a whole disk, ignore overlapping slices since we're 15846a2abf2Seschrock * about to label it anyway. 159fa9e4066Sahrens */ 16046a2abf2Seschrock error = 0; 16146a2abf2Seschrock if (!wholedisk && !force && 16246a2abf2Seschrock (dm_isoverlapping((char *)path, &msg, &error) || error)) { 163181c2f42Smmusante if (error == 0) { 164181c2f42Smmusante /* dm_isoverlapping returned -1 */ 165181c2f42Smmusante vdev_error(gettext("%s overlaps with %s\n"), path, msg); 166181c2f42Smmusante free(msg); 167181c2f42Smmusante return (-1); 168181c2f42Smmusante } else if (error != ENODEV) { 169181c2f42Smmusante /* libdiskmgt's devcache only handles physical drives */ 17046a2abf2Seschrock libdiskmgt_error(error); 17146a2abf2Seschrock return (0); 172fa9e4066Sahrens } 17346a2abf2Seschrock } 174fa9e4066Sahrens 175181c2f42Smmusante return (0); 176fa9e4066Sahrens } 177fa9e4066Sahrens 1788488aeb5Staylor 179fa9e4066Sahrens /* 180fa9e4066Sahrens * Validate a whole disk. Iterate over all slices on the disk and make sure 181fa9e4066Sahrens * that none is in use by calling check_slice(). 182fa9e4066Sahrens */ 1838488aeb5Staylor static int 18499653d4eSeschrock check_disk(const char *name, dm_descriptor_t disk, int force, int isspare) 185fa9e4066Sahrens { 186fa9e4066Sahrens dm_descriptor_t *drive, *media, *slice; 187fa9e4066Sahrens int err = 0; 188fa9e4066Sahrens int i; 189fa9e4066Sahrens int ret; 190fa9e4066Sahrens 191fa9e4066Sahrens /* 192fa9e4066Sahrens * Get the drive associated with this disk. This should never fail, 193fa9e4066Sahrens * because we already have an alias handle open for the device. 194fa9e4066Sahrens */ 195fa9e4066Sahrens if ((drive = dm_get_associated_descriptors(disk, DM_DRIVE, 19646a2abf2Seschrock &err)) == NULL || *drive == NULL) { 19746a2abf2Seschrock if (err) 19846a2abf2Seschrock libdiskmgt_error(err); 19946a2abf2Seschrock return (0); 20046a2abf2Seschrock } 201fa9e4066Sahrens 202fa9e4066Sahrens if ((media = dm_get_associated_descriptors(*drive, DM_MEDIA, 20346a2abf2Seschrock &err)) == NULL) { 20446a2abf2Seschrock dm_free_descriptors(drive); 20546a2abf2Seschrock if (err) 20646a2abf2Seschrock libdiskmgt_error(err); 20746a2abf2Seschrock return (0); 20846a2abf2Seschrock } 209fa9e4066Sahrens 210fa9e4066Sahrens dm_free_descriptors(drive); 211fa9e4066Sahrens 212fa9e4066Sahrens /* 213fa9e4066Sahrens * It is possible that the user has specified a removable media drive, 214fa9e4066Sahrens * and the media is not present. 215fa9e4066Sahrens */ 216fa9e4066Sahrens if (*media == NULL) { 217fa9e4066Sahrens dm_free_descriptors(media); 21846a2abf2Seschrock vdev_error(gettext("'%s' has no media in drive\n"), name); 219fa9e4066Sahrens return (-1); 220fa9e4066Sahrens } 221fa9e4066Sahrens 222fa9e4066Sahrens if ((slice = dm_get_associated_descriptors(*media, DM_SLICE, 22346a2abf2Seschrock &err)) == NULL) { 22446a2abf2Seschrock dm_free_descriptors(media); 22546a2abf2Seschrock if (err) 22646a2abf2Seschrock libdiskmgt_error(err); 22746a2abf2Seschrock return (0); 22846a2abf2Seschrock } 229fa9e4066Sahrens 230fa9e4066Sahrens dm_free_descriptors(media); 231fa9e4066Sahrens 232fa9e4066Sahrens ret = 0; 233fa9e4066Sahrens 234fa9e4066Sahrens /* 235fa9e4066Sahrens * Iterate over all slices and report any errors. We don't care about 236fa9e4066Sahrens * overlapping slices because we are using the whole disk. 237fa9e4066Sahrens */ 238fa9e4066Sahrens for (i = 0; slice[i] != NULL; i++) { 23999653d4eSeschrock char *name = dm_get_name(slice[i], &err); 24099653d4eSeschrock 24199653d4eSeschrock if (check_slice(name, force, B_TRUE, isspare) != 0) 242fa9e4066Sahrens ret = -1; 24399653d4eSeschrock 24499653d4eSeschrock dm_free_name(name); 245fa9e4066Sahrens } 246fa9e4066Sahrens 247fa9e4066Sahrens dm_free_descriptors(slice); 248fa9e4066Sahrens return (ret); 249fa9e4066Sahrens } 250fa9e4066Sahrens 251fa9e4066Sahrens /* 25246a2abf2Seschrock * Validate a device. 253fa9e4066Sahrens */ 2548488aeb5Staylor static int 25599653d4eSeschrock check_device(const char *path, boolean_t force, boolean_t isspare) 256fa9e4066Sahrens { 257fa9e4066Sahrens dm_descriptor_t desc; 258fa9e4066Sahrens int err; 25946a2abf2Seschrock char *dev; 260fa9e4066Sahrens 261fa9e4066Sahrens /* 262fa9e4066Sahrens * For whole disks, libdiskmgt does not include the leading dev path. 263fa9e4066Sahrens */ 264fa9e4066Sahrens dev = strrchr(path, '/'); 265fa9e4066Sahrens assert(dev != NULL); 266fa9e4066Sahrens dev++; 26746a2abf2Seschrock if ((desc = dm_get_descriptor_by_name(DM_ALIAS, dev, &err)) != NULL) { 26899653d4eSeschrock err = check_disk(path, desc, force, isspare); 26946a2abf2Seschrock dm_free_descriptor(desc); 27046a2abf2Seschrock return (err); 271fa9e4066Sahrens } 272fa9e4066Sahrens 27399653d4eSeschrock return (check_slice(path, force, B_FALSE, isspare)); 274fa9e4066Sahrens } 275fa9e4066Sahrens 276fa9e4066Sahrens /* 277fa9e4066Sahrens * Check that a file is valid. All we can do in this case is check that it's 278181c2f42Smmusante * not in use by another pool, and not in use by swap. 279fa9e4066Sahrens */ 2808488aeb5Staylor static int 28199653d4eSeschrock check_file(const char *file, boolean_t force, boolean_t isspare) 282fa9e4066Sahrens { 28346a2abf2Seschrock char *name; 284fa9e4066Sahrens int fd; 285fa9e4066Sahrens int ret = 0; 286181c2f42Smmusante int err; 28746a2abf2Seschrock pool_state_t state; 28899653d4eSeschrock boolean_t inuse; 289fa9e4066Sahrens 290181c2f42Smmusante if (dm_inuse_swap(file, &err)) { 291181c2f42Smmusante if (err) 292181c2f42Smmusante libdiskmgt_error(err); 293181c2f42Smmusante else 294181c2f42Smmusante vdev_error(gettext("%s is currently used by swap. " 295181c2f42Smmusante "Please see swap(1M).\n"), file); 296181c2f42Smmusante return (-1); 297181c2f42Smmusante } 298181c2f42Smmusante 299fa9e4066Sahrens if ((fd = open(file, O_RDONLY)) < 0) 300fa9e4066Sahrens return (0); 301fa9e4066Sahrens 30299653d4eSeschrock if (zpool_in_use(g_zfs, fd, &state, &name, &inuse) == 0 && inuse) { 30346a2abf2Seschrock const char *desc; 30446a2abf2Seschrock 30546a2abf2Seschrock switch (state) { 30646a2abf2Seschrock case POOL_STATE_ACTIVE: 30746a2abf2Seschrock desc = gettext("active"); 30846a2abf2Seschrock break; 30946a2abf2Seschrock 31046a2abf2Seschrock case POOL_STATE_EXPORTED: 31146a2abf2Seschrock desc = gettext("exported"); 31246a2abf2Seschrock break; 31346a2abf2Seschrock 31446a2abf2Seschrock case POOL_STATE_POTENTIALLY_ACTIVE: 31546a2abf2Seschrock desc = gettext("potentially active"); 31646a2abf2Seschrock break; 31746a2abf2Seschrock 31846a2abf2Seschrock default: 31946a2abf2Seschrock desc = gettext("unknown"); 32046a2abf2Seschrock break; 32146a2abf2Seschrock } 32246a2abf2Seschrock 32399653d4eSeschrock /* 32499653d4eSeschrock * Allow hot spares to be shared between pools. 32599653d4eSeschrock */ 32699653d4eSeschrock if (state == POOL_STATE_SPARE && isspare) 32799653d4eSeschrock return (0); 32899653d4eSeschrock 32999653d4eSeschrock if (state == POOL_STATE_ACTIVE || 33099653d4eSeschrock state == POOL_STATE_SPARE || !force) { 33199653d4eSeschrock switch (state) { 33299653d4eSeschrock case POOL_STATE_SPARE: 33399653d4eSeschrock vdev_error(gettext("%s is reserved as a hot " 33499653d4eSeschrock "spare for pool %s\n"), file, name); 33599653d4eSeschrock break; 33699653d4eSeschrock default: 33799653d4eSeschrock vdev_error(gettext("%s is part of %s pool " 33899653d4eSeschrock "'%s'\n"), file, desc, name); 33999653d4eSeschrock break; 34099653d4eSeschrock } 341fa9e4066Sahrens ret = -1; 342fa9e4066Sahrens } 343fa9e4066Sahrens 344fa9e4066Sahrens free(name); 345fa9e4066Sahrens } 346fa9e4066Sahrens 347fa9e4066Sahrens (void) close(fd); 348fa9e4066Sahrens return (ret); 349fa9e4066Sahrens } 350fa9e4066Sahrens 3518488aeb5Staylor 3528488aeb5Staylor /* 3538488aeb5Staylor * By "whole disk" we mean an entire physical disk (something we can 3548488aeb5Staylor * label, toggle the write cache on, etc.) as opposed to the full 3558488aeb5Staylor * capacity of a pseudo-device such as lofi or did. We act as if we 3568488aeb5Staylor * are labeling the disk, which should be a pretty good test of whether 3578488aeb5Staylor * it's a viable device or not. Returns B_TRUE if it is and B_FALSE if 3588488aeb5Staylor * it isn't. 3598488aeb5Staylor */ 36099653d4eSeschrock static boolean_t 3618488aeb5Staylor is_whole_disk(const char *arg) 362fa9e4066Sahrens { 3638488aeb5Staylor struct dk_gpt *label; 3648488aeb5Staylor int fd; 3658488aeb5Staylor char path[MAXPATHLEN]; 366fa9e4066Sahrens 3678488aeb5Staylor (void) snprintf(path, sizeof (path), "%s%s%s", 3688488aeb5Staylor RDISK_ROOT, strrchr(arg, '/'), BACKUP_SLICE); 3698488aeb5Staylor if ((fd = open(path, O_RDWR | O_NDELAY)) < 0) 3708488aeb5Staylor return (B_FALSE); 3718488aeb5Staylor if (efi_alloc_and_init(fd, EFI_NUMPAR, &label) != 0) { 3728488aeb5Staylor (void) close(fd); 3738488aeb5Staylor return (B_FALSE); 3748488aeb5Staylor } 3758488aeb5Staylor efi_free(label); 3768488aeb5Staylor (void) close(fd); 3778488aeb5Staylor return (B_TRUE); 378fa9e4066Sahrens } 379fa9e4066Sahrens 380fa9e4066Sahrens /* 381fa9e4066Sahrens * Create a leaf vdev. Determine if this is a file or a device. If it's a 382fa9e4066Sahrens * device, fill in the device id to make a complete nvlist. Valid forms for a 383fa9e4066Sahrens * leaf vdev are: 384fa9e4066Sahrens * 385fa9e4066Sahrens * /dev/dsk/xxx Complete disk path 386fa9e4066Sahrens * /xxx Full path to file 387fa9e4066Sahrens * xxx Shorthand for /dev/dsk/xxx 388fa9e4066Sahrens */ 3898488aeb5Staylor static nvlist_t * 3908654d025Sperrin make_leaf_vdev(const char *arg, uint64_t is_log) 391fa9e4066Sahrens { 392fa9e4066Sahrens char path[MAXPATHLEN]; 393fa9e4066Sahrens struct stat64 statbuf; 394fa9e4066Sahrens nvlist_t *vdev = NULL; 395fa9e4066Sahrens char *type = NULL; 39699653d4eSeschrock boolean_t wholedisk = B_FALSE; 397fa9e4066Sahrens 398fa9e4066Sahrens /* 399fa9e4066Sahrens * Determine what type of vdev this is, and put the full path into 400fa9e4066Sahrens * 'path'. We detect whether this is a device of file afterwards by 401fa9e4066Sahrens * checking the st_mode of the file. 402fa9e4066Sahrens */ 403fa9e4066Sahrens if (arg[0] == '/') { 404fa9e4066Sahrens /* 405fa9e4066Sahrens * Complete device or file path. Exact type is determined by 406fa9e4066Sahrens * examining the file descriptor afterwards. 407fa9e4066Sahrens */ 4088488aeb5Staylor wholedisk = is_whole_disk(arg); 4098488aeb5Staylor if (!wholedisk && (stat64(arg, &statbuf) != 0)) { 410fa9e4066Sahrens (void) fprintf(stderr, 411fa9e4066Sahrens gettext("cannot open '%s': %s\n"), 412fa9e4066Sahrens arg, strerror(errno)); 413fa9e4066Sahrens return (NULL); 414fa9e4066Sahrens } 415fa9e4066Sahrens 416fa9e4066Sahrens (void) strlcpy(path, arg, sizeof (path)); 417fa9e4066Sahrens } else { 418fa9e4066Sahrens /* 419fa9e4066Sahrens * This may be a short path for a device, or it could be total 420fa9e4066Sahrens * gibberish. Check to see if it's a known device in 421fa9e4066Sahrens * /dev/dsk/. As part of this check, see if we've been given a 422fa9e4066Sahrens * an entire disk (minus the slice number). 423fa9e4066Sahrens */ 424fa9e4066Sahrens (void) snprintf(path, sizeof (path), "%s/%s", DISK_ROOT, 425fa9e4066Sahrens arg); 4268488aeb5Staylor wholedisk = is_whole_disk(path); 4278488aeb5Staylor if (!wholedisk && (stat64(path, &statbuf) != 0)) { 428fa9e4066Sahrens /* 429fa9e4066Sahrens * If we got ENOENT, then the user gave us 430fa9e4066Sahrens * gibberish, so try to direct them with a 431fa9e4066Sahrens * reasonable error message. Otherwise, 432fa9e4066Sahrens * regurgitate strerror() since it's the best we 433fa9e4066Sahrens * can do. 434fa9e4066Sahrens */ 435fa9e4066Sahrens if (errno == ENOENT) { 436fa9e4066Sahrens (void) fprintf(stderr, 437fa9e4066Sahrens gettext("cannot open '%s': no such " 438fa9e4066Sahrens "device in %s\n"), arg, DISK_ROOT); 439fa9e4066Sahrens (void) fprintf(stderr, 440fa9e4066Sahrens gettext("must be a full path or " 441fa9e4066Sahrens "shorthand device name\n")); 442fa9e4066Sahrens return (NULL); 443fa9e4066Sahrens } else { 444fa9e4066Sahrens (void) fprintf(stderr, 445fa9e4066Sahrens gettext("cannot open '%s': %s\n"), 446fa9e4066Sahrens path, strerror(errno)); 447fa9e4066Sahrens return (NULL); 448fa9e4066Sahrens } 449fa9e4066Sahrens } 450fa9e4066Sahrens } 451fa9e4066Sahrens 452fa9e4066Sahrens /* 453fa9e4066Sahrens * Determine whether this is a device or a file. 454fa9e4066Sahrens */ 4558488aeb5Staylor if (wholedisk || S_ISBLK(statbuf.st_mode)) { 456fa9e4066Sahrens type = VDEV_TYPE_DISK; 457fa9e4066Sahrens } else if (S_ISREG(statbuf.st_mode)) { 458fa9e4066Sahrens type = VDEV_TYPE_FILE; 459fa9e4066Sahrens } else { 460fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot use '%s': must be a " 461fa9e4066Sahrens "block device or regular file\n"), path); 462fa9e4066Sahrens return (NULL); 463fa9e4066Sahrens } 464fa9e4066Sahrens 465fa9e4066Sahrens /* 466fa9e4066Sahrens * Finally, we have the complete device or file, and we know that it is 467fa9e4066Sahrens * acceptable to use. Construct the nvlist to describe this vdev. All 468fa9e4066Sahrens * vdevs have a 'path' element, and devices also have a 'devid' element. 469fa9e4066Sahrens */ 470fa9e4066Sahrens verify(nvlist_alloc(&vdev, NV_UNIQUE_NAME, 0) == 0); 471fa9e4066Sahrens verify(nvlist_add_string(vdev, ZPOOL_CONFIG_PATH, path) == 0); 472fa9e4066Sahrens verify(nvlist_add_string(vdev, ZPOOL_CONFIG_TYPE, type) == 0); 4738654d025Sperrin verify(nvlist_add_uint64(vdev, ZPOOL_CONFIG_IS_LOG, is_log) == 0); 474afefbcddSeschrock if (strcmp(type, VDEV_TYPE_DISK) == 0) 475afefbcddSeschrock verify(nvlist_add_uint64(vdev, ZPOOL_CONFIG_WHOLE_DISK, 476afefbcddSeschrock (uint64_t)wholedisk) == 0); 477fa9e4066Sahrens 478fa9e4066Sahrens /* 479fa9e4066Sahrens * For a whole disk, defer getting its devid until after labeling it. 480fa9e4066Sahrens */ 481fa9e4066Sahrens if (S_ISBLK(statbuf.st_mode) && !wholedisk) { 482fa9e4066Sahrens /* 483fa9e4066Sahrens * Get the devid for the device. 484fa9e4066Sahrens */ 485fa9e4066Sahrens int fd; 486fa9e4066Sahrens ddi_devid_t devid; 487fa9e4066Sahrens char *minor = NULL, *devid_str = NULL; 488fa9e4066Sahrens 489fa9e4066Sahrens if ((fd = open(path, O_RDONLY)) < 0) { 490fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot open '%s': " 491fa9e4066Sahrens "%s\n"), path, strerror(errno)); 492fa9e4066Sahrens nvlist_free(vdev); 493fa9e4066Sahrens return (NULL); 494fa9e4066Sahrens } 495fa9e4066Sahrens 496fa9e4066Sahrens if (devid_get(fd, &devid) == 0) { 497fa9e4066Sahrens if (devid_get_minor_name(fd, &minor) == 0 && 498fa9e4066Sahrens (devid_str = devid_str_encode(devid, minor)) != 499fa9e4066Sahrens NULL) { 500fa9e4066Sahrens verify(nvlist_add_string(vdev, 501fa9e4066Sahrens ZPOOL_CONFIG_DEVID, devid_str) == 0); 502fa9e4066Sahrens } 503fa9e4066Sahrens if (devid_str != NULL) 504fa9e4066Sahrens devid_str_free(devid_str); 505fa9e4066Sahrens if (minor != NULL) 506fa9e4066Sahrens devid_str_free(minor); 507fa9e4066Sahrens devid_free(devid); 508fa9e4066Sahrens } 509fa9e4066Sahrens 510fa9e4066Sahrens (void) close(fd); 511fa9e4066Sahrens } 512fa9e4066Sahrens 513fa9e4066Sahrens return (vdev); 514fa9e4066Sahrens } 515fa9e4066Sahrens 516fa9e4066Sahrens /* 517fa9e4066Sahrens * Go through and verify the replication level of the pool is consistent. 518fa9e4066Sahrens * Performs the following checks: 519fa9e4066Sahrens * 520fa9e4066Sahrens * For the new spec, verifies that devices in mirrors and raidz are the 521fa9e4066Sahrens * same size. 522fa9e4066Sahrens * 523fa9e4066Sahrens * If the current configuration already has inconsistent replication 524fa9e4066Sahrens * levels, ignore any other potential problems in the new spec. 525fa9e4066Sahrens * 526fa9e4066Sahrens * Otherwise, make sure that the current spec (if there is one) and the new 527fa9e4066Sahrens * spec have consistent replication levels. 528fa9e4066Sahrens */ 529fa9e4066Sahrens typedef struct replication_level { 53099653d4eSeschrock char *zprl_type; 53199653d4eSeschrock uint64_t zprl_children; 53299653d4eSeschrock uint64_t zprl_parity; 533fa9e4066Sahrens } replication_level_t; 534fa9e4066Sahrens 5358488aeb5Staylor #define ZPOOL_FUZZ (16 * 1024 * 1024) 5368488aeb5Staylor 537fa9e4066Sahrens /* 538fa9e4066Sahrens * Given a list of toplevel vdevs, return the current replication level. If 539fa9e4066Sahrens * the config is inconsistent, then NULL is returned. If 'fatal' is set, then 540fa9e4066Sahrens * an error message will be displayed for each self-inconsistent vdev. 541fa9e4066Sahrens */ 5428488aeb5Staylor static replication_level_t * 54399653d4eSeschrock get_replication(nvlist_t *nvroot, boolean_t fatal) 544fa9e4066Sahrens { 545fa9e4066Sahrens nvlist_t **top; 546fa9e4066Sahrens uint_t t, toplevels; 547fa9e4066Sahrens nvlist_t **child; 548fa9e4066Sahrens uint_t c, children; 549fa9e4066Sahrens nvlist_t *nv; 550fa9e4066Sahrens char *type; 551fa9e4066Sahrens replication_level_t lastrep, rep, *ret; 55299653d4eSeschrock boolean_t dontreport; 553fa9e4066Sahrens 554fa9e4066Sahrens ret = safe_malloc(sizeof (replication_level_t)); 555fa9e4066Sahrens 556fa9e4066Sahrens verify(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 557fa9e4066Sahrens &top, &toplevels) == 0); 558fa9e4066Sahrens 55999653d4eSeschrock lastrep.zprl_type = NULL; 560fa9e4066Sahrens for (t = 0; t < toplevels; t++) { 5618654d025Sperrin uint64_t is_log = B_FALSE; 5628654d025Sperrin 563fa9e4066Sahrens nv = top[t]; 564fa9e4066Sahrens 5658654d025Sperrin /* 5668654d025Sperrin * For separate logs we ignore the top level vdev replication 5678654d025Sperrin * constraints. 5688654d025Sperrin */ 5698654d025Sperrin (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG, &is_log); 5708654d025Sperrin if (is_log) 5718654d025Sperrin continue; 5728654d025Sperrin 5738654d025Sperrin verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, 5748654d025Sperrin &type) == 0); 575fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 576fa9e4066Sahrens &child, &children) != 0) { 577fa9e4066Sahrens /* 578fa9e4066Sahrens * This is a 'file' or 'disk' vdev. 579fa9e4066Sahrens */ 58099653d4eSeschrock rep.zprl_type = type; 58199653d4eSeschrock rep.zprl_children = 1; 58299653d4eSeschrock rep.zprl_parity = 0; 583fa9e4066Sahrens } else { 584fa9e4066Sahrens uint64_t vdev_size; 585fa9e4066Sahrens 586fa9e4066Sahrens /* 587fa9e4066Sahrens * This is a mirror or RAID-Z vdev. Go through and make 588fa9e4066Sahrens * sure the contents are all the same (files vs. disks), 589fa9e4066Sahrens * keeping track of the number of elements in the 590fa9e4066Sahrens * process. 591fa9e4066Sahrens * 592fa9e4066Sahrens * We also check that the size of each vdev (if it can 593fa9e4066Sahrens * be determined) is the same. 594fa9e4066Sahrens */ 59599653d4eSeschrock rep.zprl_type = type; 59699653d4eSeschrock rep.zprl_children = 0; 59799653d4eSeschrock 59899653d4eSeschrock if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) { 59999653d4eSeschrock verify(nvlist_lookup_uint64(nv, 60099653d4eSeschrock ZPOOL_CONFIG_NPARITY, 60199653d4eSeschrock &rep.zprl_parity) == 0); 60299653d4eSeschrock assert(rep.zprl_parity != 0); 60399653d4eSeschrock } else { 60499653d4eSeschrock rep.zprl_parity = 0; 60599653d4eSeschrock } 606fa9e4066Sahrens 607fa9e4066Sahrens /* 6088654d025Sperrin * The 'dontreport' variable indicates that we've 609fa9e4066Sahrens * already reported an error for this spec, so don't 610fa9e4066Sahrens * bother doing it again. 611fa9e4066Sahrens */ 612fa9e4066Sahrens type = NULL; 613fa9e4066Sahrens dontreport = 0; 614fa9e4066Sahrens vdev_size = -1ULL; 615fa9e4066Sahrens for (c = 0; c < children; c++) { 616fa9e4066Sahrens nvlist_t *cnv = child[c]; 617fa9e4066Sahrens char *path; 618fa9e4066Sahrens struct stat64 statbuf; 619fa9e4066Sahrens uint64_t size = -1ULL; 620fa9e4066Sahrens char *childtype; 621fa9e4066Sahrens int fd, err; 622fa9e4066Sahrens 62399653d4eSeschrock rep.zprl_children++; 624fa9e4066Sahrens 625fa9e4066Sahrens verify(nvlist_lookup_string(cnv, 626fa9e4066Sahrens ZPOOL_CONFIG_TYPE, &childtype) == 0); 62794de1d4cSeschrock 62894de1d4cSeschrock /* 6298654d025Sperrin * If this is a replacing or spare vdev, then 63094de1d4cSeschrock * get the real first child of the vdev. 63194de1d4cSeschrock */ 63294de1d4cSeschrock if (strcmp(childtype, 63394de1d4cSeschrock VDEV_TYPE_REPLACING) == 0 || 63494de1d4cSeschrock strcmp(childtype, VDEV_TYPE_SPARE) == 0) { 63594de1d4cSeschrock nvlist_t **rchild; 63694de1d4cSeschrock uint_t rchildren; 63794de1d4cSeschrock 63894de1d4cSeschrock verify(nvlist_lookup_nvlist_array(cnv, 63994de1d4cSeschrock ZPOOL_CONFIG_CHILDREN, &rchild, 64094de1d4cSeschrock &rchildren) == 0); 64194de1d4cSeschrock assert(rchildren == 2); 64294de1d4cSeschrock cnv = rchild[0]; 64394de1d4cSeschrock 64494de1d4cSeschrock verify(nvlist_lookup_string(cnv, 64594de1d4cSeschrock ZPOOL_CONFIG_TYPE, 64694de1d4cSeschrock &childtype) == 0); 64794de1d4cSeschrock } 64894de1d4cSeschrock 649fa9e4066Sahrens verify(nvlist_lookup_string(cnv, 650fa9e4066Sahrens ZPOOL_CONFIG_PATH, &path) == 0); 651fa9e4066Sahrens 652fa9e4066Sahrens /* 653fa9e4066Sahrens * If we have a raidz/mirror that combines disks 654fa9e4066Sahrens * with files, report it as an error. 655fa9e4066Sahrens */ 656fa9e4066Sahrens if (!dontreport && type != NULL && 657fa9e4066Sahrens strcmp(type, childtype) != 0) { 658fa9e4066Sahrens if (ret != NULL) 659fa9e4066Sahrens free(ret); 660fa9e4066Sahrens ret = NULL; 661fa9e4066Sahrens if (fatal) 662fa9e4066Sahrens vdev_error(gettext( 663fa9e4066Sahrens "mismatched replication " 664fa9e4066Sahrens "level: %s contains both " 665fa9e4066Sahrens "files and devices\n"), 66699653d4eSeschrock rep.zprl_type); 667fa9e4066Sahrens else 668fa9e4066Sahrens return (NULL); 66999653d4eSeschrock dontreport = B_TRUE; 670fa9e4066Sahrens } 671fa9e4066Sahrens 672fa9e4066Sahrens /* 673fa9e4066Sahrens * According to stat(2), the value of 'st_size' 674fa9e4066Sahrens * is undefined for block devices and character 675fa9e4066Sahrens * devices. But there is no effective way to 676fa9e4066Sahrens * determine the real size in userland. 677fa9e4066Sahrens * 678fa9e4066Sahrens * Instead, we'll take advantage of an 679fa9e4066Sahrens * implementation detail of spec_size(). If the 680fa9e4066Sahrens * device is currently open, then we (should) 681fa9e4066Sahrens * return a valid size. 682fa9e4066Sahrens * 683fa9e4066Sahrens * If we still don't get a valid size (indicated 684fa9e4066Sahrens * by a size of 0 or MAXOFFSET_T), then ignore 685fa9e4066Sahrens * this device altogether. 686fa9e4066Sahrens */ 687fa9e4066Sahrens if ((fd = open(path, O_RDONLY)) >= 0) { 688fa9e4066Sahrens err = fstat64(fd, &statbuf); 689fa9e4066Sahrens (void) close(fd); 690fa9e4066Sahrens } else { 691fa9e4066Sahrens err = stat64(path, &statbuf); 692fa9e4066Sahrens } 693fa9e4066Sahrens 694fa9e4066Sahrens if (err != 0 || 695fa9e4066Sahrens statbuf.st_size == 0 || 696fa9e4066Sahrens statbuf.st_size == MAXOFFSET_T) 697fa9e4066Sahrens continue; 698fa9e4066Sahrens 699fa9e4066Sahrens size = statbuf.st_size; 700fa9e4066Sahrens 701fa9e4066Sahrens /* 7028488aeb5Staylor * Also make sure that devices and 7038488aeb5Staylor * slices have a consistent size. If 7048488aeb5Staylor * they differ by a significant amount 7058488aeb5Staylor * (~16MB) then report an error. 706fa9e4066Sahrens */ 7078488aeb5Staylor if (!dontreport && 7088488aeb5Staylor (vdev_size != -1ULL && 7098488aeb5Staylor (labs(size - vdev_size) > 7108488aeb5Staylor ZPOOL_FUZZ))) { 711fa9e4066Sahrens if (ret != NULL) 712fa9e4066Sahrens free(ret); 713fa9e4066Sahrens ret = NULL; 714fa9e4066Sahrens if (fatal) 715fa9e4066Sahrens vdev_error(gettext( 716fa9e4066Sahrens "%s contains devices of " 717fa9e4066Sahrens "different sizes\n"), 71899653d4eSeschrock rep.zprl_type); 719fa9e4066Sahrens else 720fa9e4066Sahrens return (NULL); 72199653d4eSeschrock dontreport = B_TRUE; 722fa9e4066Sahrens } 723fa9e4066Sahrens 724fa9e4066Sahrens type = childtype; 725fa9e4066Sahrens vdev_size = size; 726fa9e4066Sahrens } 727fa9e4066Sahrens } 728fa9e4066Sahrens 729fa9e4066Sahrens /* 730fa9e4066Sahrens * At this point, we have the replication of the last toplevel 731fa9e4066Sahrens * vdev in 'rep'. Compare it to 'lastrep' to see if its 732fa9e4066Sahrens * different. 733fa9e4066Sahrens */ 73499653d4eSeschrock if (lastrep.zprl_type != NULL) { 73599653d4eSeschrock if (strcmp(lastrep.zprl_type, rep.zprl_type) != 0) { 736fa9e4066Sahrens if (ret != NULL) 737fa9e4066Sahrens free(ret); 738fa9e4066Sahrens ret = NULL; 739fa9e4066Sahrens if (fatal) 740fa9e4066Sahrens vdev_error(gettext( 74199653d4eSeschrock "mismatched replication level: " 74299653d4eSeschrock "both %s and %s vdevs are " 743fa9e4066Sahrens "present\n"), 74499653d4eSeschrock lastrep.zprl_type, rep.zprl_type); 745fa9e4066Sahrens else 746fa9e4066Sahrens return (NULL); 74799653d4eSeschrock } else if (lastrep.zprl_parity != rep.zprl_parity) { 748fa9e4066Sahrens if (ret) 749fa9e4066Sahrens free(ret); 750fa9e4066Sahrens ret = NULL; 751fa9e4066Sahrens if (fatal) 752fa9e4066Sahrens vdev_error(gettext( 75399653d4eSeschrock "mismatched replication level: " 75499653d4eSeschrock "both %llu and %llu device parity " 75599653d4eSeschrock "%s vdevs are present\n"), 75699653d4eSeschrock lastrep.zprl_parity, 75799653d4eSeschrock rep.zprl_parity, 75899653d4eSeschrock rep.zprl_type); 75999653d4eSeschrock else 76099653d4eSeschrock return (NULL); 76199653d4eSeschrock } else if (lastrep.zprl_children != rep.zprl_children) { 76299653d4eSeschrock if (ret) 76399653d4eSeschrock free(ret); 76499653d4eSeschrock ret = NULL; 76599653d4eSeschrock if (fatal) 76699653d4eSeschrock vdev_error(gettext( 76799653d4eSeschrock "mismatched replication level: " 76899653d4eSeschrock "both %llu-way and %llu-way %s " 769fa9e4066Sahrens "vdevs are present\n"), 77099653d4eSeschrock lastrep.zprl_children, 77199653d4eSeschrock rep.zprl_children, 77299653d4eSeschrock rep.zprl_type); 773fa9e4066Sahrens else 774fa9e4066Sahrens return (NULL); 775fa9e4066Sahrens } 776fa9e4066Sahrens } 777fa9e4066Sahrens lastrep = rep; 778fa9e4066Sahrens } 779fa9e4066Sahrens 78099653d4eSeschrock if (ret != NULL) 78199653d4eSeschrock *ret = rep; 782fa9e4066Sahrens 783fa9e4066Sahrens return (ret); 784fa9e4066Sahrens } 785fa9e4066Sahrens 786fa9e4066Sahrens /* 787fa9e4066Sahrens * Check the replication level of the vdev spec against the current pool. Calls 788fa9e4066Sahrens * get_replication() to make sure the new spec is self-consistent. If the pool 789fa9e4066Sahrens * has a consistent replication level, then we ignore any errors. Otherwise, 790fa9e4066Sahrens * report any difference between the two. 791fa9e4066Sahrens */ 7928488aeb5Staylor static int 793fa9e4066Sahrens check_replication(nvlist_t *config, nvlist_t *newroot) 794fa9e4066Sahrens { 7958488aeb5Staylor nvlist_t **child; 7968488aeb5Staylor uint_t children; 797fa9e4066Sahrens replication_level_t *current = NULL, *new; 798fa9e4066Sahrens int ret; 799fa9e4066Sahrens 800fa9e4066Sahrens /* 801fa9e4066Sahrens * If we have a current pool configuration, check to see if it's 802fa9e4066Sahrens * self-consistent. If not, simply return success. 803fa9e4066Sahrens */ 804fa9e4066Sahrens if (config != NULL) { 805fa9e4066Sahrens nvlist_t *nvroot; 806fa9e4066Sahrens 807fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 808fa9e4066Sahrens &nvroot) == 0); 80999653d4eSeschrock if ((current = get_replication(nvroot, B_FALSE)) == NULL) 810fa9e4066Sahrens return (0); 811fa9e4066Sahrens } 8128488aeb5Staylor /* 8138488aeb5Staylor * for spares there may be no children, and therefore no 8148488aeb5Staylor * replication level to check 8158488aeb5Staylor */ 8168488aeb5Staylor if ((nvlist_lookup_nvlist_array(newroot, ZPOOL_CONFIG_CHILDREN, 8178488aeb5Staylor &child, &children) != 0) || (children == 0)) { 8188488aeb5Staylor free(current); 8198488aeb5Staylor return (0); 8208488aeb5Staylor } 821fa9e4066Sahrens 8228654d025Sperrin /* 8238654d025Sperrin * If all we have is logs then there's no replication level to check. 8248654d025Sperrin */ 8258654d025Sperrin if (num_logs(newroot) == children) { 8268654d025Sperrin free(current); 8278654d025Sperrin return (0); 8288654d025Sperrin } 8298654d025Sperrin 830fa9e4066Sahrens /* 831fa9e4066Sahrens * Get the replication level of the new vdev spec, reporting any 832fa9e4066Sahrens * inconsistencies found. 833fa9e4066Sahrens */ 83499653d4eSeschrock if ((new = get_replication(newroot, B_TRUE)) == NULL) { 835fa9e4066Sahrens free(current); 836fa9e4066Sahrens return (-1); 837fa9e4066Sahrens } 838fa9e4066Sahrens 839fa9e4066Sahrens /* 840fa9e4066Sahrens * Check to see if the new vdev spec matches the replication level of 841fa9e4066Sahrens * the current pool. 842fa9e4066Sahrens */ 843fa9e4066Sahrens ret = 0; 844fa9e4066Sahrens if (current != NULL) { 84599653d4eSeschrock if (strcmp(current->zprl_type, new->zprl_type) != 0) { 846fa9e4066Sahrens vdev_error(gettext( 84799653d4eSeschrock "mismatched replication level: pool uses %s " 84899653d4eSeschrock "and new vdev is %s\n"), 84999653d4eSeschrock current->zprl_type, new->zprl_type); 85099653d4eSeschrock ret = -1; 85199653d4eSeschrock } else if (current->zprl_parity != new->zprl_parity) { 85299653d4eSeschrock vdev_error(gettext( 85399653d4eSeschrock "mismatched replication level: pool uses %llu " 85499653d4eSeschrock "device parity and new vdev uses %llu\n"), 85599653d4eSeschrock current->zprl_parity, new->zprl_parity); 85699653d4eSeschrock ret = -1; 85799653d4eSeschrock } else if (current->zprl_children != new->zprl_children) { 85899653d4eSeschrock vdev_error(gettext( 85999653d4eSeschrock "mismatched replication level: pool uses %llu-way " 86099653d4eSeschrock "%s and new vdev uses %llu-way %s\n"), 86199653d4eSeschrock current->zprl_children, current->zprl_type, 86299653d4eSeschrock new->zprl_children, new->zprl_type); 863fa9e4066Sahrens ret = -1; 864fa9e4066Sahrens } 865fa9e4066Sahrens } 866fa9e4066Sahrens 867fa9e4066Sahrens free(new); 868fa9e4066Sahrens if (current != NULL) 869fa9e4066Sahrens free(current); 870fa9e4066Sahrens 871fa9e4066Sahrens return (ret); 872fa9e4066Sahrens } 873fa9e4066Sahrens 874fa9e4066Sahrens /* 875fa9e4066Sahrens * Go through and find any whole disks in the vdev specification, labelling them 876fa9e4066Sahrens * as appropriate. When constructing the vdev spec, we were unable to open this 877fa9e4066Sahrens * device in order to provide a devid. Now that we have labelled the disk and 878fa9e4066Sahrens * know that slice 0 is valid, we can construct the devid now. 879fa9e4066Sahrens * 8808488aeb5Staylor * If the disk was already labeled with an EFI label, we will have gotten the 881fa9e4066Sahrens * devid already (because we were able to open the whole disk). Otherwise, we 882fa9e4066Sahrens * need to get the devid after we label the disk. 883fa9e4066Sahrens */ 8848488aeb5Staylor static int 8858488aeb5Staylor make_disks(zpool_handle_t *zhp, nvlist_t *nv) 886fa9e4066Sahrens { 887fa9e4066Sahrens nvlist_t **child; 888fa9e4066Sahrens uint_t c, children; 889fa9e4066Sahrens char *type, *path, *diskname; 890fa9e4066Sahrens char buf[MAXPATHLEN]; 891afefbcddSeschrock uint64_t wholedisk; 892fa9e4066Sahrens int fd; 893fa9e4066Sahrens int ret; 894fa9e4066Sahrens ddi_devid_t devid; 895fa9e4066Sahrens char *minor = NULL, *devid_str = NULL; 896fa9e4066Sahrens 897fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); 898fa9e4066Sahrens 899fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 900fa9e4066Sahrens &child, &children) != 0) { 901fa9e4066Sahrens 902fa9e4066Sahrens if (strcmp(type, VDEV_TYPE_DISK) != 0) 903fa9e4066Sahrens return (0); 904fa9e4066Sahrens 905fa9e4066Sahrens /* 906fa9e4066Sahrens * We have a disk device. Get the path to the device 9078488aeb5Staylor * and see if it's a whole disk by appending the backup 908fa9e4066Sahrens * slice and stat()ing the device. 909fa9e4066Sahrens */ 910fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 911afefbcddSeschrock if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK, 912afefbcddSeschrock &wholedisk) != 0 || !wholedisk) 913fa9e4066Sahrens return (0); 914fa9e4066Sahrens 915fa9e4066Sahrens diskname = strrchr(path, '/'); 916fa9e4066Sahrens assert(diskname != NULL); 917fa9e4066Sahrens diskname++; 9188488aeb5Staylor if (zpool_label_disk(g_zfs, zhp, diskname) == -1) 919fa9e4066Sahrens return (-1); 920fa9e4066Sahrens 921fa9e4066Sahrens /* 922fa9e4066Sahrens * Fill in the devid, now that we've labeled the disk. 923fa9e4066Sahrens */ 924fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%ss0", path); 925fa9e4066Sahrens if ((fd = open(buf, O_RDONLY)) < 0) { 926fa9e4066Sahrens (void) fprintf(stderr, 927fa9e4066Sahrens gettext("cannot open '%s': %s\n"), 928fa9e4066Sahrens buf, strerror(errno)); 929fa9e4066Sahrens return (-1); 930fa9e4066Sahrens } 931fa9e4066Sahrens 932fa9e4066Sahrens if (devid_get(fd, &devid) == 0) { 933fa9e4066Sahrens if (devid_get_minor_name(fd, &minor) == 0 && 934fa9e4066Sahrens (devid_str = devid_str_encode(devid, minor)) != 935fa9e4066Sahrens NULL) { 936fa9e4066Sahrens verify(nvlist_add_string(nv, 937fa9e4066Sahrens ZPOOL_CONFIG_DEVID, devid_str) == 0); 938fa9e4066Sahrens } 939fa9e4066Sahrens if (devid_str != NULL) 940fa9e4066Sahrens devid_str_free(devid_str); 941fa9e4066Sahrens if (minor != NULL) 942fa9e4066Sahrens devid_str_free(minor); 943fa9e4066Sahrens devid_free(devid); 944fa9e4066Sahrens } 945fa9e4066Sahrens 946afefbcddSeschrock /* 947afefbcddSeschrock * Update the path to refer to the 's0' slice. The presence of 948afefbcddSeschrock * the 'whole_disk' field indicates to the CLI that we should 949afefbcddSeschrock * chop off the slice number when displaying the device in 950afefbcddSeschrock * future output. 951afefbcddSeschrock */ 952afefbcddSeschrock verify(nvlist_add_string(nv, ZPOOL_CONFIG_PATH, buf) == 0); 953afefbcddSeschrock 954fa9e4066Sahrens (void) close(fd); 955fa9e4066Sahrens 956fa9e4066Sahrens return (0); 957fa9e4066Sahrens } 958fa9e4066Sahrens 959fa9e4066Sahrens for (c = 0; c < children; c++) 9608488aeb5Staylor if ((ret = make_disks(zhp, child[c])) != 0) 961fa9e4066Sahrens return (ret); 962fa9e4066Sahrens 96399653d4eSeschrock if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 96499653d4eSeschrock &child, &children) == 0) 96599653d4eSeschrock for (c = 0; c < children; c++) 9668488aeb5Staylor if ((ret = make_disks(zhp, child[c])) != 0) 96799653d4eSeschrock return (ret); 96899653d4eSeschrock 969fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 970fa94a07fSbrendan &child, &children) == 0) 971fa94a07fSbrendan for (c = 0; c < children; c++) 972fa94a07fSbrendan if ((ret = make_disks(zhp, child[c])) != 0) 973fa94a07fSbrendan return (ret); 974fa94a07fSbrendan 975fa9e4066Sahrens return (0); 976fa9e4066Sahrens } 977fa9e4066Sahrens 97899653d4eSeschrock /* 97999653d4eSeschrock * Determine if the given path is a hot spare within the given configuration. 98099653d4eSeschrock */ 98199653d4eSeschrock static boolean_t 98299653d4eSeschrock is_spare(nvlist_t *config, const char *path) 98399653d4eSeschrock { 98499653d4eSeschrock int fd; 98599653d4eSeschrock pool_state_t state; 9863ccfa83cSahrens char *name = NULL; 98799653d4eSeschrock nvlist_t *label; 98899653d4eSeschrock uint64_t guid, spareguid; 98999653d4eSeschrock nvlist_t *nvroot; 99099653d4eSeschrock nvlist_t **spares; 99199653d4eSeschrock uint_t i, nspares; 99299653d4eSeschrock boolean_t inuse; 99399653d4eSeschrock 99499653d4eSeschrock if ((fd = open(path, O_RDONLY)) < 0) 99599653d4eSeschrock return (B_FALSE); 99699653d4eSeschrock 99799653d4eSeschrock if (zpool_in_use(g_zfs, fd, &state, &name, &inuse) != 0 || 99899653d4eSeschrock !inuse || 99999653d4eSeschrock state != POOL_STATE_SPARE || 100099653d4eSeschrock zpool_read_label(fd, &label) != 0) { 10013ccfa83cSahrens free(name); 100299653d4eSeschrock (void) close(fd); 100399653d4eSeschrock return (B_FALSE); 100499653d4eSeschrock } 10053ccfa83cSahrens free(name); 100699653d4eSeschrock (void) close(fd); 1007*3f9d6ad7SLin Ling 100899653d4eSeschrock verify(nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID, &guid) == 0); 100999653d4eSeschrock nvlist_free(label); 101099653d4eSeschrock 101199653d4eSeschrock verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 101299653d4eSeschrock &nvroot) == 0); 101399653d4eSeschrock if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 101499653d4eSeschrock &spares, &nspares) == 0) { 101599653d4eSeschrock for (i = 0; i < nspares; i++) { 101699653d4eSeschrock verify(nvlist_lookup_uint64(spares[i], 101799653d4eSeschrock ZPOOL_CONFIG_GUID, &spareguid) == 0); 101899653d4eSeschrock if (spareguid == guid) 101999653d4eSeschrock return (B_TRUE); 102099653d4eSeschrock } 102199653d4eSeschrock } 102299653d4eSeschrock 102399653d4eSeschrock return (B_FALSE); 102499653d4eSeschrock } 102599653d4eSeschrock 1026fa9e4066Sahrens /* 1027fa9e4066Sahrens * Go through and find any devices that are in use. We rely on libdiskmgt for 1028fa9e4066Sahrens * the majority of this task. 1029fa9e4066Sahrens */ 10308488aeb5Staylor static int 1031*3f9d6ad7SLin Ling check_in_use(nvlist_t *config, nvlist_t *nv, boolean_t force, 1032*3f9d6ad7SLin Ling boolean_t replacing, boolean_t isspare) 1033fa9e4066Sahrens { 1034fa9e4066Sahrens nvlist_t **child; 1035fa9e4066Sahrens uint_t c, children; 1036fa9e4066Sahrens char *type, *path; 1037fa9e4066Sahrens int ret; 103899653d4eSeschrock char buf[MAXPATHLEN]; 103999653d4eSeschrock uint64_t wholedisk; 1040fa9e4066Sahrens 1041fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); 1042fa9e4066Sahrens 1043fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1044fa9e4066Sahrens &child, &children) != 0) { 1045fa9e4066Sahrens 1046fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0); 1047fa9e4066Sahrens 104899653d4eSeschrock /* 104999653d4eSeschrock * As a generic check, we look to see if this is a replace of a 105099653d4eSeschrock * hot spare within the same pool. If so, we allow it 105199653d4eSeschrock * regardless of what libdiskmgt or zpool_in_use() says. 105299653d4eSeschrock */ 1053*3f9d6ad7SLin Ling if (replacing) { 105499653d4eSeschrock if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK, 105599653d4eSeschrock &wholedisk) == 0 && wholedisk) 105699653d4eSeschrock (void) snprintf(buf, sizeof (buf), "%ss0", 105799653d4eSeschrock path); 105899653d4eSeschrock else 105999653d4eSeschrock (void) strlcpy(buf, path, sizeof (buf)); 1060*3f9d6ad7SLin Ling 106199653d4eSeschrock if (is_spare(config, buf)) 106299653d4eSeschrock return (0); 106399653d4eSeschrock } 106499653d4eSeschrock 1065fa9e4066Sahrens if (strcmp(type, VDEV_TYPE_DISK) == 0) 106699653d4eSeschrock ret = check_device(path, force, isspare); 1067fa9e4066Sahrens 1068fa9e4066Sahrens if (strcmp(type, VDEV_TYPE_FILE) == 0) 106999653d4eSeschrock ret = check_file(path, force, isspare); 1070fa9e4066Sahrens 1071fa9e4066Sahrens return (ret); 1072fa9e4066Sahrens } 1073fa9e4066Sahrens 1074fa9e4066Sahrens for (c = 0; c < children; c++) 107599653d4eSeschrock if ((ret = check_in_use(config, child[c], force, 1076*3f9d6ad7SLin Ling replacing, B_FALSE)) != 0) 1077fa9e4066Sahrens return (ret); 1078fa9e4066Sahrens 107999653d4eSeschrock if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 108099653d4eSeschrock &child, &children) == 0) 108199653d4eSeschrock for (c = 0; c < children; c++) 108299653d4eSeschrock if ((ret = check_in_use(config, child[c], force, 1083*3f9d6ad7SLin Ling replacing, B_TRUE)) != 0) 108499653d4eSeschrock return (ret); 1085fa94a07fSbrendan 1086fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 1087fa94a07fSbrendan &child, &children) == 0) 1088fa94a07fSbrendan for (c = 0; c < children; c++) 1089fa94a07fSbrendan if ((ret = check_in_use(config, child[c], force, 1090*3f9d6ad7SLin Ling replacing, B_FALSE)) != 0) 1091fa94a07fSbrendan return (ret); 1092fa94a07fSbrendan 1093fa9e4066Sahrens return (0); 1094fa9e4066Sahrens } 1095fa9e4066Sahrens 10968488aeb5Staylor static const char * 1097f94275ceSAdam Leventhal is_grouping(const char *type, int *mindev, int *maxdev) 109899653d4eSeschrock { 1099f94275ceSAdam Leventhal if (strncmp(type, "raidz", 5) == 0) { 1100f94275ceSAdam Leventhal const char *p = type + 5; 1101f94275ceSAdam Leventhal char *end; 1102f94275ceSAdam Leventhal long nparity; 1103f94275ceSAdam Leventhal 1104f94275ceSAdam Leventhal if (*p == '\0') { 1105f94275ceSAdam Leventhal nparity = 1; 1106f94275ceSAdam Leventhal } else if (*p == '0') { 1107f94275ceSAdam Leventhal return (NULL); /* no zero prefixes allowed */ 1108f94275ceSAdam Leventhal } else { 1109f94275ceSAdam Leventhal errno = 0; 1110f94275ceSAdam Leventhal nparity = strtol(p, &end, 10); 1111f94275ceSAdam Leventhal if (errno != 0 || nparity < 1 || nparity >= 255 || 1112f94275ceSAdam Leventhal *end != '\0') 1113f94275ceSAdam Leventhal return (NULL); 1114f94275ceSAdam Leventhal } 111599653d4eSeschrock 111699653d4eSeschrock if (mindev != NULL) 1117f94275ceSAdam Leventhal *mindev = nparity + 1; 1118f94275ceSAdam Leventhal if (maxdev != NULL) 1119f94275ceSAdam Leventhal *maxdev = 255; 112099653d4eSeschrock return (VDEV_TYPE_RAIDZ); 112199653d4eSeschrock } 112299653d4eSeschrock 1123f94275ceSAdam Leventhal if (maxdev != NULL) 1124f94275ceSAdam Leventhal *maxdev = INT_MAX; 1125f94275ceSAdam Leventhal 112699653d4eSeschrock if (strcmp(type, "mirror") == 0) { 112799653d4eSeschrock if (mindev != NULL) 112899653d4eSeschrock *mindev = 2; 112999653d4eSeschrock return (VDEV_TYPE_MIRROR); 113099653d4eSeschrock } 113199653d4eSeschrock 113299653d4eSeschrock if (strcmp(type, "spare") == 0) { 113399653d4eSeschrock if (mindev != NULL) 113499653d4eSeschrock *mindev = 1; 113599653d4eSeschrock return (VDEV_TYPE_SPARE); 113699653d4eSeschrock } 113799653d4eSeschrock 11388654d025Sperrin if (strcmp(type, "log") == 0) { 11398654d025Sperrin if (mindev != NULL) 11408654d025Sperrin *mindev = 1; 11418654d025Sperrin return (VDEV_TYPE_LOG); 11428654d025Sperrin } 11438654d025Sperrin 1144fa94a07fSbrendan if (strcmp(type, "cache") == 0) { 1145fa94a07fSbrendan if (mindev != NULL) 1146fa94a07fSbrendan *mindev = 1; 1147fa94a07fSbrendan return (VDEV_TYPE_L2CACHE); 1148fa94a07fSbrendan } 1149fa94a07fSbrendan 115099653d4eSeschrock return (NULL); 115199653d4eSeschrock } 115299653d4eSeschrock 1153fa9e4066Sahrens /* 1154fa9e4066Sahrens * Construct a syntactically valid vdev specification, 1155fa9e4066Sahrens * and ensure that all devices and files exist and can be opened. 1156fa9e4066Sahrens * Note: we don't bother freeing anything in the error paths 1157fa9e4066Sahrens * because the program is just going to exit anyway. 1158fa9e4066Sahrens */ 1159fa9e4066Sahrens nvlist_t * 1160fa9e4066Sahrens construct_spec(int argc, char **argv) 1161fa9e4066Sahrens { 1162fa94a07fSbrendan nvlist_t *nvroot, *nv, **top, **spares, **l2cache; 1163f94275ceSAdam Leventhal int t, toplevels, mindev, maxdev, nspares, nlogs, nl2cache; 116499653d4eSeschrock const char *type; 11658654d025Sperrin uint64_t is_log; 11668654d025Sperrin boolean_t seen_logs; 1167fa9e4066Sahrens 1168fa9e4066Sahrens top = NULL; 1169fa9e4066Sahrens toplevels = 0; 117099653d4eSeschrock spares = NULL; 1171fa94a07fSbrendan l2cache = NULL; 117299653d4eSeschrock nspares = 0; 11738654d025Sperrin nlogs = 0; 1174fa94a07fSbrendan nl2cache = 0; 11758654d025Sperrin is_log = B_FALSE; 11768654d025Sperrin seen_logs = B_FALSE; 1177fa9e4066Sahrens 1178fa9e4066Sahrens while (argc > 0) { 1179fa9e4066Sahrens nv = NULL; 1180fa9e4066Sahrens 1181fa9e4066Sahrens /* 1182fa9e4066Sahrens * If it's a mirror or raidz, the subsequent arguments are 1183fa9e4066Sahrens * its leaves -- until we encounter the next mirror or raidz. 1184fa9e4066Sahrens */ 1185f94275ceSAdam Leventhal if ((type = is_grouping(argv[0], &mindev, &maxdev)) != NULL) { 1186fa9e4066Sahrens nvlist_t **child = NULL; 118799653d4eSeschrock int c, children = 0; 118899653d4eSeschrock 11898654d025Sperrin if (strcmp(type, VDEV_TYPE_SPARE) == 0) { 11908654d025Sperrin if (spares != NULL) { 11918654d025Sperrin (void) fprintf(stderr, 11928654d025Sperrin gettext("invalid vdev " 11938654d025Sperrin "specification: 'spare' can be " 11948654d025Sperrin "specified only once\n")); 11958654d025Sperrin return (NULL); 11968654d025Sperrin } 11978654d025Sperrin is_log = B_FALSE; 11988654d025Sperrin } 11998654d025Sperrin 12008654d025Sperrin if (strcmp(type, VDEV_TYPE_LOG) == 0) { 12018654d025Sperrin if (seen_logs) { 12028654d025Sperrin (void) fprintf(stderr, 12038654d025Sperrin gettext("invalid vdev " 12048654d025Sperrin "specification: 'log' can be " 12058654d025Sperrin "specified only once\n")); 12068654d025Sperrin return (NULL); 12078654d025Sperrin } 12088654d025Sperrin seen_logs = B_TRUE; 12098654d025Sperrin is_log = B_TRUE; 12108654d025Sperrin argc--; 12118654d025Sperrin argv++; 12128654d025Sperrin /* 12138654d025Sperrin * A log is not a real grouping device. 12148654d025Sperrin * We just set is_log and continue. 12158654d025Sperrin */ 12168654d025Sperrin continue; 12178654d025Sperrin } 12188654d025Sperrin 1219fa94a07fSbrendan if (strcmp(type, VDEV_TYPE_L2CACHE) == 0) { 1220fa94a07fSbrendan if (l2cache != NULL) { 1221fa94a07fSbrendan (void) fprintf(stderr, 1222fa94a07fSbrendan gettext("invalid vdev " 1223fa94a07fSbrendan "specification: 'cache' can be " 1224fa94a07fSbrendan "specified only once\n")); 1225fa94a07fSbrendan return (NULL); 1226fa94a07fSbrendan } 1227fa94a07fSbrendan is_log = B_FALSE; 1228fa94a07fSbrendan } 1229fa94a07fSbrendan 12308654d025Sperrin if (is_log) { 12318654d025Sperrin if (strcmp(type, VDEV_TYPE_MIRROR) != 0) { 12328654d025Sperrin (void) fprintf(stderr, 12338654d025Sperrin gettext("invalid vdev " 12348654d025Sperrin "specification: unsupported 'log' " 12358654d025Sperrin "device: %s\n"), type); 12368654d025Sperrin return (NULL); 12378654d025Sperrin } 12388654d025Sperrin nlogs++; 123999653d4eSeschrock } 1240fa9e4066Sahrens 1241fa9e4066Sahrens for (c = 1; c < argc; c++) { 1242f94275ceSAdam Leventhal if (is_grouping(argv[c], NULL, NULL) != NULL) 1243fa9e4066Sahrens break; 1244fa9e4066Sahrens children++; 1245fa9e4066Sahrens child = realloc(child, 1246fa9e4066Sahrens children * sizeof (nvlist_t *)); 1247fa9e4066Sahrens if (child == NULL) 12485ad82045Snd zpool_no_memory(); 12498654d025Sperrin if ((nv = make_leaf_vdev(argv[c], B_FALSE)) 12508654d025Sperrin == NULL) 1251fa9e4066Sahrens return (NULL); 1252fa9e4066Sahrens child[children - 1] = nv; 1253fa9e4066Sahrens } 1254fa9e4066Sahrens 125599653d4eSeschrock if (children < mindev) { 125699653d4eSeschrock (void) fprintf(stderr, gettext("invalid vdev " 125799653d4eSeschrock "specification: %s requires at least %d " 125899653d4eSeschrock "devices\n"), argv[0], mindev); 1259fa9e4066Sahrens return (NULL); 1260fa9e4066Sahrens } 1261fa9e4066Sahrens 1262f94275ceSAdam Leventhal if (children > maxdev) { 1263f94275ceSAdam Leventhal (void) fprintf(stderr, gettext("invalid vdev " 1264f94275ceSAdam Leventhal "specification: %s supports no more than " 1265f94275ceSAdam Leventhal "%d devices\n"), argv[0], maxdev); 1266f94275ceSAdam Leventhal return (NULL); 1267f94275ceSAdam Leventhal } 1268f94275ceSAdam Leventhal 126999653d4eSeschrock argc -= c; 127099653d4eSeschrock argv += c; 127199653d4eSeschrock 127299653d4eSeschrock if (strcmp(type, VDEV_TYPE_SPARE) == 0) { 127399653d4eSeschrock spares = child; 127499653d4eSeschrock nspares = children; 127599653d4eSeschrock continue; 1276fa94a07fSbrendan } else if (strcmp(type, VDEV_TYPE_L2CACHE) == 0) { 1277fa94a07fSbrendan l2cache = child; 1278fa94a07fSbrendan nl2cache = children; 1279fa94a07fSbrendan continue; 128099653d4eSeschrock } else { 128199653d4eSeschrock verify(nvlist_alloc(&nv, NV_UNIQUE_NAME, 128299653d4eSeschrock 0) == 0); 128399653d4eSeschrock verify(nvlist_add_string(nv, ZPOOL_CONFIG_TYPE, 128499653d4eSeschrock type) == 0); 12858654d025Sperrin verify(nvlist_add_uint64(nv, 12868654d025Sperrin ZPOOL_CONFIG_IS_LOG, is_log) == 0); 128799653d4eSeschrock if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) { 128899653d4eSeschrock verify(nvlist_add_uint64(nv, 128999653d4eSeschrock ZPOOL_CONFIG_NPARITY, 129099653d4eSeschrock mindev - 1) == 0); 129199653d4eSeschrock } 129299653d4eSeschrock verify(nvlist_add_nvlist_array(nv, 129399653d4eSeschrock ZPOOL_CONFIG_CHILDREN, child, 129499653d4eSeschrock children) == 0); 1295fa9e4066Sahrens 129699653d4eSeschrock for (c = 0; c < children; c++) 129799653d4eSeschrock nvlist_free(child[c]); 129899653d4eSeschrock free(child); 129999653d4eSeschrock } 1300fa9e4066Sahrens } else { 1301fa9e4066Sahrens /* 1302fa9e4066Sahrens * We have a device. Pass off to make_leaf_vdev() to 1303fa9e4066Sahrens * construct the appropriate nvlist describing the vdev. 1304fa9e4066Sahrens */ 13058654d025Sperrin if ((nv = make_leaf_vdev(argv[0], is_log)) == NULL) 1306fa9e4066Sahrens return (NULL); 13078654d025Sperrin if (is_log) 13088654d025Sperrin nlogs++; 1309fa9e4066Sahrens argc--; 1310fa9e4066Sahrens argv++; 1311fa9e4066Sahrens } 1312fa9e4066Sahrens 1313fa9e4066Sahrens toplevels++; 1314fa9e4066Sahrens top = realloc(top, toplevels * sizeof (nvlist_t *)); 1315fa9e4066Sahrens if (top == NULL) 13165ad82045Snd zpool_no_memory(); 1317fa9e4066Sahrens top[toplevels - 1] = nv; 1318fa9e4066Sahrens } 1319fa9e4066Sahrens 1320fa94a07fSbrendan if (toplevels == 0 && nspares == 0 && nl2cache == 0) { 132199653d4eSeschrock (void) fprintf(stderr, gettext("invalid vdev " 132299653d4eSeschrock "specification: at least one toplevel vdev must be " 132399653d4eSeschrock "specified\n")); 132499653d4eSeschrock return (NULL); 132599653d4eSeschrock } 132699653d4eSeschrock 13278654d025Sperrin if (seen_logs && nlogs == 0) { 13288654d025Sperrin (void) fprintf(stderr, gettext("invalid vdev specification: " 13298654d025Sperrin "log requires at least 1 device\n")); 13308654d025Sperrin return (NULL); 13318654d025Sperrin } 13328654d025Sperrin 1333fa9e4066Sahrens /* 1334fa9e4066Sahrens * Finally, create nvroot and add all top-level vdevs to it. 1335fa9e4066Sahrens */ 1336fa9e4066Sahrens verify(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, 0) == 0); 1337fa9e4066Sahrens verify(nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE, 1338fa9e4066Sahrens VDEV_TYPE_ROOT) == 0); 1339fa9e4066Sahrens verify(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 1340fa9e4066Sahrens top, toplevels) == 0); 134199653d4eSeschrock if (nspares != 0) 134299653d4eSeschrock verify(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 134399653d4eSeschrock spares, nspares) == 0); 1344fa94a07fSbrendan if (nl2cache != 0) 1345fa94a07fSbrendan verify(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 1346fa94a07fSbrendan l2cache, nl2cache) == 0); 1347fa9e4066Sahrens 1348fa9e4066Sahrens for (t = 0; t < toplevels; t++) 1349fa9e4066Sahrens nvlist_free(top[t]); 135099653d4eSeschrock for (t = 0; t < nspares; t++) 135199653d4eSeschrock nvlist_free(spares[t]); 1352fa94a07fSbrendan for (t = 0; t < nl2cache; t++) 1353fa94a07fSbrendan nvlist_free(l2cache[t]); 135499653d4eSeschrock if (spares) 135599653d4eSeschrock free(spares); 1356fa94a07fSbrendan if (l2cache) 1357fa94a07fSbrendan free(l2cache); 1358fa9e4066Sahrens free(top); 1359fa9e4066Sahrens 1360fa9e4066Sahrens return (nvroot); 1361fa9e4066Sahrens } 1362fa9e4066Sahrens 13631195e687SMark J Musante nvlist_t * 13641195e687SMark J Musante split_mirror_vdev(zpool_handle_t *zhp, char *newname, nvlist_t *props, 13651195e687SMark J Musante splitflags_t flags, int argc, char **argv) 13661195e687SMark J Musante { 13671195e687SMark J Musante nvlist_t *newroot = NULL, **child; 13681195e687SMark J Musante uint_t c, children; 13691195e687SMark J Musante 13701195e687SMark J Musante if (argc > 0) { 13711195e687SMark J Musante if ((newroot = construct_spec(argc, argv)) == NULL) { 13721195e687SMark J Musante (void) fprintf(stderr, gettext("Unable to build a " 13731195e687SMark J Musante "pool from the specified devices\n")); 13741195e687SMark J Musante return (NULL); 13751195e687SMark J Musante } 13761195e687SMark J Musante 13771195e687SMark J Musante if (!flags.dryrun && make_disks(zhp, newroot) != 0) { 13781195e687SMark J Musante nvlist_free(newroot); 13791195e687SMark J Musante return (NULL); 13801195e687SMark J Musante } 13811195e687SMark J Musante 13821195e687SMark J Musante /* avoid any tricks in the spec */ 13831195e687SMark J Musante verify(nvlist_lookup_nvlist_array(newroot, 13841195e687SMark J Musante ZPOOL_CONFIG_CHILDREN, &child, &children) == 0); 13851195e687SMark J Musante for (c = 0; c < children; c++) { 13861195e687SMark J Musante char *path; 13871195e687SMark J Musante const char *type; 13881195e687SMark J Musante int min, max; 13891195e687SMark J Musante 13901195e687SMark J Musante verify(nvlist_lookup_string(child[c], 13911195e687SMark J Musante ZPOOL_CONFIG_PATH, &path) == 0); 13921195e687SMark J Musante if ((type = is_grouping(path, &min, &max)) != NULL) { 13931195e687SMark J Musante (void) fprintf(stderr, gettext("Cannot use " 13941195e687SMark J Musante "'%s' as a device for splitting\n"), type); 13951195e687SMark J Musante nvlist_free(newroot); 13961195e687SMark J Musante return (NULL); 13971195e687SMark J Musante } 13981195e687SMark J Musante } 13991195e687SMark J Musante } 14001195e687SMark J Musante 14011195e687SMark J Musante if (zpool_vdev_split(zhp, newname, &newroot, props, flags) != 0) { 14021195e687SMark J Musante if (newroot != NULL) 14031195e687SMark J Musante nvlist_free(newroot); 14041195e687SMark J Musante return (NULL); 14051195e687SMark J Musante } 14061195e687SMark J Musante 14071195e687SMark J Musante return (newroot); 14081195e687SMark J Musante } 14098488aeb5Staylor 1410fa9e4066Sahrens /* 1411fa9e4066Sahrens * Get and validate the contents of the given vdev specification. This ensures 1412fa9e4066Sahrens * that the nvlist returned is well-formed, that all the devices exist, and that 1413fa9e4066Sahrens * they are not currently in use by any other known consumer. The 'poolconfig' 1414fa9e4066Sahrens * parameter is the current configuration of the pool when adding devices 1415fa9e4066Sahrens * existing pool, and is used to perform additional checks, such as changing the 1416fa9e4066Sahrens * replication level of the pool. It can be 'NULL' to indicate that this is a 1417fa9e4066Sahrens * new pool. The 'force' flag controls whether devices should be forcefully 1418fa9e4066Sahrens * added, even if they appear in use. 1419fa9e4066Sahrens */ 1420fa9e4066Sahrens nvlist_t * 14218488aeb5Staylor make_root_vdev(zpool_handle_t *zhp, int force, int check_rep, 1422*3f9d6ad7SLin Ling boolean_t replacing, boolean_t dryrun, int argc, char **argv) 1423fa9e4066Sahrens { 1424fa9e4066Sahrens nvlist_t *newroot; 14258488aeb5Staylor nvlist_t *poolconfig = NULL; 1426fa9e4066Sahrens is_force = force; 1427fa9e4066Sahrens 1428fa9e4066Sahrens /* 1429fa9e4066Sahrens * Construct the vdev specification. If this is successful, we know 1430fa9e4066Sahrens * that we have a valid specification, and that all devices can be 1431fa9e4066Sahrens * opened. 1432fa9e4066Sahrens */ 1433fa9e4066Sahrens if ((newroot = construct_spec(argc, argv)) == NULL) 1434fa9e4066Sahrens return (NULL); 1435fa9e4066Sahrens 14368488aeb5Staylor if (zhp && ((poolconfig = zpool_get_config(zhp, NULL)) == NULL)) 14378488aeb5Staylor return (NULL); 14388488aeb5Staylor 1439fa9e4066Sahrens /* 1440fa9e4066Sahrens * Validate each device to make sure that its not shared with another 1441fa9e4066Sahrens * subsystem. We do this even if 'force' is set, because there are some 1442fa9e4066Sahrens * uses (such as a dedicated dump device) that even '-f' cannot 1443fa9e4066Sahrens * override. 1444fa9e4066Sahrens */ 1445*3f9d6ad7SLin Ling if (check_in_use(poolconfig, newroot, force, replacing, B_FALSE) != 0) { 1446fa9e4066Sahrens nvlist_free(newroot); 1447fa9e4066Sahrens return (NULL); 1448fa9e4066Sahrens } 1449fa9e4066Sahrens 1450fa9e4066Sahrens /* 1451fa9e4066Sahrens * Check the replication level of the given vdevs and report any errors 1452fa9e4066Sahrens * found. We include the existing pool spec, if any, as we need to 1453fa9e4066Sahrens * catch changes against the existing replication level. 1454fa9e4066Sahrens */ 1455fa9e4066Sahrens if (check_rep && check_replication(poolconfig, newroot) != 0) { 1456fa9e4066Sahrens nvlist_free(newroot); 1457fa9e4066Sahrens return (NULL); 1458fa9e4066Sahrens } 1459fa9e4066Sahrens 1460fa9e4066Sahrens /* 1461fa9e4066Sahrens * Run through the vdev specification and label any whole disks found. 1462fa9e4066Sahrens */ 1463705040edSEric Taylor if (!dryrun && make_disks(zhp, newroot) != 0) { 1464fa9e4066Sahrens nvlist_free(newroot); 1465fa9e4066Sahrens return (NULL); 1466fa9e4066Sahrens } 1467fa9e4066Sahrens 1468fa9e4066Sahrens return (newroot); 1469fa9e4066Sahrens } 1470