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 /*
233f9d6ad7SLin Ling * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24*09933095SBasil Crow * Copyright (c) 2013 by Delphix. All rights reserved.
25fa9e4066Sahrens */
26fa9e4066Sahrens
27fa9e4066Sahrens /*
28fa9e4066Sahrens * Functions to convert between a list of vdevs and an nvlist representing the
29fa9e4066Sahrens * configuration. Each entry in the list can be one of:
30fa9e4066Sahrens *
31fa9e4066Sahrens * Device vdevs
32fa9e4066Sahrens * disk=(path=..., devid=...)
33fa9e4066Sahrens * file=(path=...)
34fa9e4066Sahrens *
35fa9e4066Sahrens * Group vdevs
3699653d4eSeschrock * raidz[1|2]=(...)
37fa9e4066Sahrens * mirror=(...)
38fa9e4066Sahrens *
3999653d4eSeschrock * Hot spares
4099653d4eSeschrock *
41fa9e4066Sahrens * While the underlying implementation supports it, group vdevs cannot contain
42fa9e4066Sahrens * other group vdevs. All userland verification of devices is contained within
43fa9e4066Sahrens * this file. If successful, the nvlist returned can be passed directly to the
44fa9e4066Sahrens * kernel; we've done as much verification as possible in userland.
45fa9e4066Sahrens *
4699653d4eSeschrock * Hot spares are a special case, and passed down as an array of disk vdevs, at
4799653d4eSeschrock * the same level as the root of the vdev tree.
4899653d4eSeschrock *
498488aeb5Staylor * The only function exported by this file is 'make_root_vdev'. The
508488aeb5Staylor * function performs several passes:
51fa9e4066Sahrens *
52fa9e4066Sahrens * 1. Construct the vdev specification. Performs syntax validation and
53fa9e4066Sahrens * makes sure each device is valid.
54fa9e4066Sahrens * 2. Check for devices in use. Using libdiskmgt, makes sure that no
55fa9e4066Sahrens * devices are also in use. Some can be overridden using the 'force'
56fa9e4066Sahrens * flag, others cannot.
57fa9e4066Sahrens * 3. Check for replication errors if the 'force' flag is not specified.
58fa9e4066Sahrens * validates that the replication level is consistent across the
59fa9e4066Sahrens * entire pool.
608488aeb5Staylor * 4. Call libzfs to label any whole disks with an EFI label.
61fa9e4066Sahrens */
62fa9e4066Sahrens
63fa9e4066Sahrens #include <assert.h>
64fa9e4066Sahrens #include <devid.h>
65fa9e4066Sahrens #include <errno.h>
66fa9e4066Sahrens #include <fcntl.h>
67fa9e4066Sahrens #include <libdiskmgt.h>
68fa9e4066Sahrens #include <libintl.h>
69fa9e4066Sahrens #include <libnvpair.h>
70f94275ceSAdam Leventhal #include <limits.h>
71fa9e4066Sahrens #include <stdio.h>
72fa9e4066Sahrens #include <string.h>
73fa9e4066Sahrens #include <unistd.h>
74fa9e4066Sahrens #include <sys/efi_partition.h>
75fa9e4066Sahrens #include <sys/stat.h>
76fa9e4066Sahrens #include <sys/vtoc.h>
77fa9e4066Sahrens #include <sys/mntent.h>
78fa9e4066Sahrens
79fa9e4066Sahrens #include "zpool_util.h"
80fa9e4066Sahrens
81fa9e4066Sahrens #define DISK_ROOT "/dev/dsk"
82fa9e4066Sahrens #define RDISK_ROOT "/dev/rdsk"
83fa9e4066Sahrens #define BACKUP_SLICE "s2"
84fa9e4066Sahrens
85fa9e4066Sahrens /*
86fa9e4066Sahrens * For any given vdev specification, we can have multiple errors. The
87fa9e4066Sahrens * vdev_error() function keeps track of whether we have seen an error yet, and
88fa9e4066Sahrens * prints out a header if its the first error we've seen.
89fa9e4066Sahrens */
9099653d4eSeschrock boolean_t error_seen;
9199653d4eSeschrock boolean_t is_force;
92fa9e4066Sahrens
9399653d4eSeschrock /*PRINTFLIKE1*/
9499653d4eSeschrock static void
vdev_error(const char * fmt,...)95fa9e4066Sahrens vdev_error(const char *fmt, ...)
96fa9e4066Sahrens {
97fa9e4066Sahrens va_list ap;
98fa9e4066Sahrens
99fa9e4066Sahrens if (!error_seen) {
100fa9e4066Sahrens (void) fprintf(stderr, gettext("invalid vdev specification\n"));
101fa9e4066Sahrens if (!is_force)
102fa9e4066Sahrens (void) fprintf(stderr, gettext("use '-f' to override "
103fa9e4066Sahrens "the following errors:\n"));
104fa9e4066Sahrens else
105fa9e4066Sahrens (void) fprintf(stderr, gettext("the following errors "
106fa9e4066Sahrens "must be manually repaired:\n"));
10799653d4eSeschrock error_seen = B_TRUE;
108fa9e4066Sahrens }
109fa9e4066Sahrens
110fa9e4066Sahrens va_start(ap, fmt);
111fa9e4066Sahrens (void) vfprintf(stderr, fmt, ap);
112fa9e4066Sahrens va_end(ap);
113fa9e4066Sahrens }
114fa9e4066Sahrens
11546a2abf2Seschrock static void
libdiskmgt_error(int error)11646a2abf2Seschrock libdiskmgt_error(int error)
117fa9e4066Sahrens {
118ea8dc4b6Seschrock /*
11999653d4eSeschrock * ENXIO/ENODEV is a valid error message if the device doesn't live in
120ea8dc4b6Seschrock * /dev/dsk. Don't bother printing an error message in this case.
121ea8dc4b6Seschrock */
12299653d4eSeschrock if (error == ENXIO || error == ENODEV)
123ea8dc4b6Seschrock return;
124ea8dc4b6Seschrock
12546a2abf2Seschrock (void) fprintf(stderr, gettext("warning: device in use checking "
12646a2abf2Seschrock "failed: %s\n"), strerror(error));
127fa9e4066Sahrens }
128fa9e4066Sahrens
129fa9e4066Sahrens /*
13046a2abf2Seschrock * Validate a device, passing the bulk of the work off to libdiskmgt.
131fa9e4066Sahrens */
1328488aeb5Staylor static int
check_slice(const char * path,int force,boolean_t wholedisk,boolean_t isspare)13399653d4eSeschrock check_slice(const char *path, int force, boolean_t wholedisk, boolean_t isspare)
134fa9e4066Sahrens {
13546a2abf2Seschrock char *msg;
13646a2abf2Seschrock int error = 0;
13703a818bcSmmusante dm_who_type_t who;
138fa9e4066Sahrens
13903a818bcSmmusante if (force)
14003a818bcSmmusante who = DM_WHO_ZPOOL_FORCE;
14103a818bcSmmusante else if (isspare)
14203a818bcSmmusante who = DM_WHO_ZPOOL_SPARE;
14303a818bcSmmusante else
14403a818bcSmmusante who = DM_WHO_ZPOOL;
14503a818bcSmmusante
14603a818bcSmmusante if (dm_inuse((char *)path, &msg, who, &error) || error) {
14746a2abf2Seschrock if (error != 0) {
14846a2abf2Seschrock libdiskmgt_error(error);
14946a2abf2Seschrock return (0);
15046657f8dSmmusante } else {
15146a2abf2Seschrock vdev_error("%s", msg);
15246a2abf2Seschrock free(msg);
153181c2f42Smmusante return (-1);
15446a2abf2Seschrock }
155fa9e4066Sahrens }
156fa9e4066Sahrens
15746a2abf2Seschrock /*
15846a2abf2Seschrock * If we're given a whole disk, ignore overlapping slices since we're
15946a2abf2Seschrock * about to label it anyway.
16046a2abf2Seschrock */
16146a2abf2Seschrock error = 0;
16246a2abf2Seschrock if (!wholedisk && !force &&
16346a2abf2Seschrock (dm_isoverlapping((char *)path, &msg, &error) || error)) {
164181c2f42Smmusante if (error == 0) {
165181c2f42Smmusante /* dm_isoverlapping returned -1 */
166181c2f42Smmusante vdev_error(gettext("%s overlaps with %s\n"), path, msg);
167181c2f42Smmusante free(msg);
168181c2f42Smmusante return (-1);
169181c2f42Smmusante } else if (error != ENODEV) {
170181c2f42Smmusante /* libdiskmgt's devcache only handles physical drives */
17146a2abf2Seschrock libdiskmgt_error(error);
17246a2abf2Seschrock return (0);
173181c2f42Smmusante }
17446a2abf2Seschrock }
17546a2abf2Seschrock
176181c2f42Smmusante return (0);
177fa9e4066Sahrens }
178fa9e4066Sahrens
1798488aeb5Staylor
180fa9e4066Sahrens /*
181fa9e4066Sahrens * Validate a whole disk. Iterate over all slices on the disk and make sure
182fa9e4066Sahrens * that none is in use by calling check_slice().
183fa9e4066Sahrens */
1848488aeb5Staylor static int
check_disk(const char * name,dm_descriptor_t disk,int force,int isspare)18599653d4eSeschrock check_disk(const char *name, dm_descriptor_t disk, int force, int isspare)
186fa9e4066Sahrens {
187fa9e4066Sahrens dm_descriptor_t *drive, *media, *slice;
188fa9e4066Sahrens int err = 0;
189fa9e4066Sahrens int i;
190fa9e4066Sahrens int ret;
191fa9e4066Sahrens
192fa9e4066Sahrens /*
193fa9e4066Sahrens * Get the drive associated with this disk. This should never fail,
194fa9e4066Sahrens * because we already have an alias handle open for the device.
195fa9e4066Sahrens */
196fa9e4066Sahrens if ((drive = dm_get_associated_descriptors(disk, DM_DRIVE,
19746a2abf2Seschrock &err)) == NULL || *drive == NULL) {
19846a2abf2Seschrock if (err)
19946a2abf2Seschrock libdiskmgt_error(err);
20046a2abf2Seschrock return (0);
20146a2abf2Seschrock }
202fa9e4066Sahrens
203fa9e4066Sahrens if ((media = dm_get_associated_descriptors(*drive, DM_MEDIA,
20446a2abf2Seschrock &err)) == NULL) {
20546a2abf2Seschrock dm_free_descriptors(drive);
20646a2abf2Seschrock if (err)
20746a2abf2Seschrock libdiskmgt_error(err);
20846a2abf2Seschrock return (0);
20946a2abf2Seschrock }
210fa9e4066Sahrens
211fa9e4066Sahrens dm_free_descriptors(drive);
212fa9e4066Sahrens
213fa9e4066Sahrens /*
214fa9e4066Sahrens * It is possible that the user has specified a removable media drive,
215fa9e4066Sahrens * and the media is not present.
216fa9e4066Sahrens */
217fa9e4066Sahrens if (*media == NULL) {
218fa9e4066Sahrens dm_free_descriptors(media);
21946a2abf2Seschrock vdev_error(gettext("'%s' has no media in drive\n"), name);
220fa9e4066Sahrens return (-1);
221fa9e4066Sahrens }
222fa9e4066Sahrens
223fa9e4066Sahrens if ((slice = dm_get_associated_descriptors(*media, DM_SLICE,
22446a2abf2Seschrock &err)) == NULL) {
22546a2abf2Seschrock dm_free_descriptors(media);
22646a2abf2Seschrock if (err)
22746a2abf2Seschrock libdiskmgt_error(err);
22846a2abf2Seschrock return (0);
22946a2abf2Seschrock }
230fa9e4066Sahrens
231fa9e4066Sahrens dm_free_descriptors(media);
232fa9e4066Sahrens
233fa9e4066Sahrens ret = 0;
234fa9e4066Sahrens
235fa9e4066Sahrens /*
236fa9e4066Sahrens * Iterate over all slices and report any errors. We don't care about
237fa9e4066Sahrens * overlapping slices because we are using the whole disk.
238fa9e4066Sahrens */
239fa9e4066Sahrens for (i = 0; slice[i] != NULL; i++) {
24099653d4eSeschrock char *name = dm_get_name(slice[i], &err);
24199653d4eSeschrock
24299653d4eSeschrock if (check_slice(name, force, B_TRUE, isspare) != 0)
243fa9e4066Sahrens ret = -1;
24499653d4eSeschrock
24599653d4eSeschrock dm_free_name(name);
246fa9e4066Sahrens }
247fa9e4066Sahrens
248fa9e4066Sahrens dm_free_descriptors(slice);
249fa9e4066Sahrens return (ret);
250fa9e4066Sahrens }
251fa9e4066Sahrens
252fa9e4066Sahrens /*
25346a2abf2Seschrock * Validate a device.
254fa9e4066Sahrens */
2558488aeb5Staylor static int
check_device(const char * path,boolean_t force,boolean_t isspare)25699653d4eSeschrock check_device(const char *path, boolean_t force, boolean_t isspare)
257fa9e4066Sahrens {
258fa9e4066Sahrens dm_descriptor_t desc;
259fa9e4066Sahrens int err;
26046a2abf2Seschrock char *dev;
261fa9e4066Sahrens
262fa9e4066Sahrens /*
263fa9e4066Sahrens * For whole disks, libdiskmgt does not include the leading dev path.
264fa9e4066Sahrens */
265fa9e4066Sahrens dev = strrchr(path, '/');
266fa9e4066Sahrens assert(dev != NULL);
267fa9e4066Sahrens dev++;
26846a2abf2Seschrock if ((desc = dm_get_descriptor_by_name(DM_ALIAS, dev, &err)) != NULL) {
26999653d4eSeschrock err = check_disk(path, desc, force, isspare);
27046a2abf2Seschrock dm_free_descriptor(desc);
27146a2abf2Seschrock return (err);
272fa9e4066Sahrens }
273fa9e4066Sahrens
27499653d4eSeschrock return (check_slice(path, force, B_FALSE, isspare));
275fa9e4066Sahrens }
276fa9e4066Sahrens
277fa9e4066Sahrens /*
278fa9e4066Sahrens * Check that a file is valid. All we can do in this case is check that it's
279181c2f42Smmusante * not in use by another pool, and not in use by swap.
280fa9e4066Sahrens */
2818488aeb5Staylor static int
check_file(const char * file,boolean_t force,boolean_t isspare)28299653d4eSeschrock check_file(const char *file, boolean_t force, boolean_t isspare)
283fa9e4066Sahrens {
28446a2abf2Seschrock char *name;
285fa9e4066Sahrens int fd;
286fa9e4066Sahrens int ret = 0;
287181c2f42Smmusante int err;
28846a2abf2Seschrock pool_state_t state;
28999653d4eSeschrock boolean_t inuse;
290fa9e4066Sahrens
291181c2f42Smmusante if (dm_inuse_swap(file, &err)) {
292181c2f42Smmusante if (err)
293181c2f42Smmusante libdiskmgt_error(err);
294181c2f42Smmusante else
295181c2f42Smmusante vdev_error(gettext("%s is currently used by swap. "
296181c2f42Smmusante "Please see swap(1M).\n"), file);
297181c2f42Smmusante return (-1);
298181c2f42Smmusante }
299181c2f42Smmusante
300fa9e4066Sahrens if ((fd = open(file, O_RDONLY)) < 0)
301fa9e4066Sahrens return (0);
302fa9e4066Sahrens
30399653d4eSeschrock if (zpool_in_use(g_zfs, fd, &state, &name, &inuse) == 0 && inuse) {
30446a2abf2Seschrock const char *desc;
30546a2abf2Seschrock
30646a2abf2Seschrock switch (state) {
30746a2abf2Seschrock case POOL_STATE_ACTIVE:
30846a2abf2Seschrock desc = gettext("active");
30946a2abf2Seschrock break;
31046a2abf2Seschrock
31146a2abf2Seschrock case POOL_STATE_EXPORTED:
31246a2abf2Seschrock desc = gettext("exported");
31346a2abf2Seschrock break;
31446a2abf2Seschrock
31546a2abf2Seschrock case POOL_STATE_POTENTIALLY_ACTIVE:
31646a2abf2Seschrock desc = gettext("potentially active");
31746a2abf2Seschrock break;
31846a2abf2Seschrock
31946a2abf2Seschrock default:
32046a2abf2Seschrock desc = gettext("unknown");
32146a2abf2Seschrock break;
32246a2abf2Seschrock }
32346a2abf2Seschrock
32499653d4eSeschrock /*
32599653d4eSeschrock * Allow hot spares to be shared between pools.
32699653d4eSeschrock */
32799653d4eSeschrock if (state == POOL_STATE_SPARE && isspare)
32899653d4eSeschrock return (0);
32999653d4eSeschrock
33099653d4eSeschrock if (state == POOL_STATE_ACTIVE ||
33199653d4eSeschrock state == POOL_STATE_SPARE || !force) {
33299653d4eSeschrock switch (state) {
33399653d4eSeschrock case POOL_STATE_SPARE:
33499653d4eSeschrock vdev_error(gettext("%s is reserved as a hot "
33599653d4eSeschrock "spare for pool %s\n"), file, name);
33699653d4eSeschrock break;
33799653d4eSeschrock default:
33899653d4eSeschrock vdev_error(gettext("%s is part of %s pool "
33999653d4eSeschrock "'%s'\n"), file, desc, name);
34099653d4eSeschrock break;
34199653d4eSeschrock }
342fa9e4066Sahrens ret = -1;
343fa9e4066Sahrens }
344fa9e4066Sahrens
345fa9e4066Sahrens free(name);
346fa9e4066Sahrens }
347fa9e4066Sahrens
348fa9e4066Sahrens (void) close(fd);
349fa9e4066Sahrens return (ret);
350fa9e4066Sahrens }
351fa9e4066Sahrens
3528488aeb5Staylor
3538488aeb5Staylor /*
3548488aeb5Staylor * By "whole disk" we mean an entire physical disk (something we can
3558488aeb5Staylor * label, toggle the write cache on, etc.) as opposed to the full
3568488aeb5Staylor * capacity of a pseudo-device such as lofi or did. We act as if we
3578488aeb5Staylor * are labeling the disk, which should be a pretty good test of whether
3588488aeb5Staylor * it's a viable device or not. Returns B_TRUE if it is and B_FALSE if
3598488aeb5Staylor * it isn't.
3608488aeb5Staylor */
36199653d4eSeschrock static boolean_t
is_whole_disk(const char * arg)3628488aeb5Staylor is_whole_disk(const char *arg)
363fa9e4066Sahrens {
3648488aeb5Staylor struct dk_gpt *label;
3658488aeb5Staylor int fd;
366fa9e4066Sahrens char path[MAXPATHLEN];
367fa9e4066Sahrens
3688488aeb5Staylor (void) snprintf(path, sizeof (path), "%s%s%s",
3698488aeb5Staylor RDISK_ROOT, strrchr(arg, '/'), BACKUP_SLICE);
3708488aeb5Staylor if ((fd = open(path, O_RDWR | O_NDELAY)) < 0)
37199653d4eSeschrock return (B_FALSE);
3728488aeb5Staylor if (efi_alloc_and_init(fd, EFI_NUMPAR, &label) != 0) {
3738488aeb5Staylor (void) close(fd);
3748488aeb5Staylor return (B_FALSE);
3758488aeb5Staylor }
3768488aeb5Staylor efi_free(label);
3778488aeb5Staylor (void) close(fd);
3788488aeb5Staylor return (B_TRUE);
379fa9e4066Sahrens }
380fa9e4066Sahrens
381fa9e4066Sahrens /*
382fa9e4066Sahrens * Create a leaf vdev. Determine if this is a file or a device. If it's a
383fa9e4066Sahrens * device, fill in the device id to make a complete nvlist. Valid forms for a
384fa9e4066Sahrens * leaf vdev are:
385fa9e4066Sahrens *
386fa9e4066Sahrens * /dev/dsk/xxx Complete disk path
387fa9e4066Sahrens * /xxx Full path to file
388fa9e4066Sahrens * xxx Shorthand for /dev/dsk/xxx
389fa9e4066Sahrens */
3908488aeb5Staylor static nvlist_t *
make_leaf_vdev(const char * arg,uint64_t is_log)3918654d025Sperrin make_leaf_vdev(const char *arg, uint64_t is_log)
392fa9e4066Sahrens {
393fa9e4066Sahrens char path[MAXPATHLEN];
394fa9e4066Sahrens struct stat64 statbuf;
395fa9e4066Sahrens nvlist_t *vdev = NULL;
396fa9e4066Sahrens char *type = NULL;
39799653d4eSeschrock boolean_t wholedisk = B_FALSE;
398fa9e4066Sahrens
399fa9e4066Sahrens /*
400fa9e4066Sahrens * Determine what type of vdev this is, and put the full path into
401fa9e4066Sahrens * 'path'. We detect whether this is a device of file afterwards by
402fa9e4066Sahrens * checking the st_mode of the file.
403fa9e4066Sahrens */
404fa9e4066Sahrens if (arg[0] == '/') {
405fa9e4066Sahrens /*
406fa9e4066Sahrens * Complete device or file path. Exact type is determined by
407fa9e4066Sahrens * examining the file descriptor afterwards.
408fa9e4066Sahrens */
4098488aeb5Staylor wholedisk = is_whole_disk(arg);
4108488aeb5Staylor if (!wholedisk && (stat64(arg, &statbuf) != 0)) {
411fa9e4066Sahrens (void) fprintf(stderr,
412fa9e4066Sahrens gettext("cannot open '%s': %s\n"),
413fa9e4066Sahrens arg, strerror(errno));
414fa9e4066Sahrens return (NULL);
415fa9e4066Sahrens }
416fa9e4066Sahrens
417fa9e4066Sahrens (void) strlcpy(path, arg, sizeof (path));
418fa9e4066Sahrens } else {
419fa9e4066Sahrens /*
420fa9e4066Sahrens * This may be a short path for a device, or it could be total
421fa9e4066Sahrens * gibberish. Check to see if it's a known device in
422fa9e4066Sahrens * /dev/dsk/. As part of this check, see if we've been given a
423fa9e4066Sahrens * an entire disk (minus the slice number).
424fa9e4066Sahrens */
425fa9e4066Sahrens (void) snprintf(path, sizeof (path), "%s/%s", DISK_ROOT,
426fa9e4066Sahrens arg);
4278488aeb5Staylor wholedisk = is_whole_disk(path);
4288488aeb5Staylor if (!wholedisk && (stat64(path, &statbuf) != 0)) {
429fa9e4066Sahrens /*
430fa9e4066Sahrens * If we got ENOENT, then the user gave us
431fa9e4066Sahrens * gibberish, so try to direct them with a
432fa9e4066Sahrens * reasonable error message. Otherwise,
433fa9e4066Sahrens * regurgitate strerror() since it's the best we
434fa9e4066Sahrens * can do.
435fa9e4066Sahrens */
436fa9e4066Sahrens if (errno == ENOENT) {
437fa9e4066Sahrens (void) fprintf(stderr,
438fa9e4066Sahrens gettext("cannot open '%s': no such "
439fa9e4066Sahrens "device in %s\n"), arg, DISK_ROOT);
440fa9e4066Sahrens (void) fprintf(stderr,
441fa9e4066Sahrens gettext("must be a full path or "
442fa9e4066Sahrens "shorthand device name\n"));
443fa9e4066Sahrens return (NULL);
444fa9e4066Sahrens } else {
445fa9e4066Sahrens (void) fprintf(stderr,
446fa9e4066Sahrens gettext("cannot open '%s': %s\n"),
447fa9e4066Sahrens path, strerror(errno));
448fa9e4066Sahrens return (NULL);
449fa9e4066Sahrens }
450fa9e4066Sahrens }
451fa9e4066Sahrens }
452fa9e4066Sahrens
453fa9e4066Sahrens /*
454fa9e4066Sahrens * Determine whether this is a device or a file.
455fa9e4066Sahrens */
4568488aeb5Staylor if (wholedisk || S_ISBLK(statbuf.st_mode)) {
457fa9e4066Sahrens type = VDEV_TYPE_DISK;
458fa9e4066Sahrens } else if (S_ISREG(statbuf.st_mode)) {
459fa9e4066Sahrens type = VDEV_TYPE_FILE;
460fa9e4066Sahrens } else {
461fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot use '%s': must be a "
462fa9e4066Sahrens "block device or regular file\n"), path);
463fa9e4066Sahrens return (NULL);
464fa9e4066Sahrens }
465fa9e4066Sahrens
466fa9e4066Sahrens /*
467fa9e4066Sahrens * Finally, we have the complete device or file, and we know that it is
468fa9e4066Sahrens * acceptable to use. Construct the nvlist to describe this vdev. All
469fa9e4066Sahrens * vdevs have a 'path' element, and devices also have a 'devid' element.
470fa9e4066Sahrens */
471fa9e4066Sahrens verify(nvlist_alloc(&vdev, NV_UNIQUE_NAME, 0) == 0);
472fa9e4066Sahrens verify(nvlist_add_string(vdev, ZPOOL_CONFIG_PATH, path) == 0);
473fa9e4066Sahrens verify(nvlist_add_string(vdev, ZPOOL_CONFIG_TYPE, type) == 0);
4748654d025Sperrin verify(nvlist_add_uint64(vdev, ZPOOL_CONFIG_IS_LOG, is_log) == 0);
475afefbcddSeschrock if (strcmp(type, VDEV_TYPE_DISK) == 0)
476afefbcddSeschrock verify(nvlist_add_uint64(vdev, ZPOOL_CONFIG_WHOLE_DISK,
477afefbcddSeschrock (uint64_t)wholedisk) == 0);
478fa9e4066Sahrens
479fa9e4066Sahrens /*
480fa9e4066Sahrens * For a whole disk, defer getting its devid until after labeling it.
481fa9e4066Sahrens */
482fa9e4066Sahrens if (S_ISBLK(statbuf.st_mode) && !wholedisk) {
483fa9e4066Sahrens /*
484fa9e4066Sahrens * Get the devid for the device.
485fa9e4066Sahrens */
486fa9e4066Sahrens int fd;
487fa9e4066Sahrens ddi_devid_t devid;
488fa9e4066Sahrens char *minor = NULL, *devid_str = NULL;
489fa9e4066Sahrens
490fa9e4066Sahrens if ((fd = open(path, O_RDONLY)) < 0) {
491fa9e4066Sahrens (void) fprintf(stderr, gettext("cannot open '%s': "
492fa9e4066Sahrens "%s\n"), path, strerror(errno));
493fa9e4066Sahrens nvlist_free(vdev);
494fa9e4066Sahrens return (NULL);
495fa9e4066Sahrens }
496fa9e4066Sahrens
497fa9e4066Sahrens if (devid_get(fd, &devid) == 0) {
498fa9e4066Sahrens if (devid_get_minor_name(fd, &minor) == 0 &&
499fa9e4066Sahrens (devid_str = devid_str_encode(devid, minor)) !=
500fa9e4066Sahrens NULL) {
501fa9e4066Sahrens verify(nvlist_add_string(vdev,
502fa9e4066Sahrens ZPOOL_CONFIG_DEVID, devid_str) == 0);
503fa9e4066Sahrens }
504fa9e4066Sahrens if (devid_str != NULL)
505fa9e4066Sahrens devid_str_free(devid_str);
506fa9e4066Sahrens if (minor != NULL)
507fa9e4066Sahrens devid_str_free(minor);
508fa9e4066Sahrens devid_free(devid);
509fa9e4066Sahrens }
510fa9e4066Sahrens
511fa9e4066Sahrens (void) close(fd);
512fa9e4066Sahrens }
513fa9e4066Sahrens
514fa9e4066Sahrens return (vdev);
515fa9e4066Sahrens }
516fa9e4066Sahrens
517fa9e4066Sahrens /*
518fa9e4066Sahrens * Go through and verify the replication level of the pool is consistent.
519fa9e4066Sahrens * Performs the following checks:
520fa9e4066Sahrens *
521fa9e4066Sahrens * For the new spec, verifies that devices in mirrors and raidz are the
522fa9e4066Sahrens * same size.
523fa9e4066Sahrens *
524fa9e4066Sahrens * If the current configuration already has inconsistent replication
525fa9e4066Sahrens * levels, ignore any other potential problems in the new spec.
526fa9e4066Sahrens *
527fa9e4066Sahrens * Otherwise, make sure that the current spec (if there is one) and the new
528fa9e4066Sahrens * spec have consistent replication levels.
529fa9e4066Sahrens */
530fa9e4066Sahrens typedef struct replication_level {
53199653d4eSeschrock char *zprl_type;
53299653d4eSeschrock uint64_t zprl_children;
53399653d4eSeschrock uint64_t zprl_parity;
534fa9e4066Sahrens } replication_level_t;
535fa9e4066Sahrens
5368488aeb5Staylor #define ZPOOL_FUZZ (16 * 1024 * 1024)
5378488aeb5Staylor
538fa9e4066Sahrens /*
539fa9e4066Sahrens * Given a list of toplevel vdevs, return the current replication level. If
540fa9e4066Sahrens * the config is inconsistent, then NULL is returned. If 'fatal' is set, then
541fa9e4066Sahrens * an error message will be displayed for each self-inconsistent vdev.
542fa9e4066Sahrens */
5438488aeb5Staylor static replication_level_t *
get_replication(nvlist_t * nvroot,boolean_t fatal)54499653d4eSeschrock get_replication(nvlist_t *nvroot, boolean_t fatal)
545fa9e4066Sahrens {
546fa9e4066Sahrens nvlist_t **top;
547fa9e4066Sahrens uint_t t, toplevels;
548fa9e4066Sahrens nvlist_t **child;
549fa9e4066Sahrens uint_t c, children;
550fa9e4066Sahrens nvlist_t *nv;
551fa9e4066Sahrens char *type;
552fa9e4066Sahrens replication_level_t lastrep, rep, *ret;
55399653d4eSeschrock boolean_t dontreport;
554fa9e4066Sahrens
555fa9e4066Sahrens ret = safe_malloc(sizeof (replication_level_t));
556fa9e4066Sahrens
557fa9e4066Sahrens verify(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
558fa9e4066Sahrens &top, &toplevels) == 0);
559fa9e4066Sahrens
56099653d4eSeschrock lastrep.zprl_type = NULL;
561fa9e4066Sahrens for (t = 0; t < toplevels; t++) {
5628654d025Sperrin uint64_t is_log = B_FALSE;
5638654d025Sperrin
564fa9e4066Sahrens nv = top[t];
565fa9e4066Sahrens
5668654d025Sperrin /*
5678654d025Sperrin * For separate logs we ignore the top level vdev replication
5688654d025Sperrin * constraints.
5698654d025Sperrin */
5708654d025Sperrin (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG, &is_log);
5718654d025Sperrin if (is_log)
5728654d025Sperrin continue;
5738654d025Sperrin
5748654d025Sperrin verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE,
5758654d025Sperrin &type) == 0);
576fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
577fa9e4066Sahrens &child, &children) != 0) {
578fa9e4066Sahrens /*
579fa9e4066Sahrens * This is a 'file' or 'disk' vdev.
580fa9e4066Sahrens */
58199653d4eSeschrock rep.zprl_type = type;
58299653d4eSeschrock rep.zprl_children = 1;
58399653d4eSeschrock rep.zprl_parity = 0;
584fa9e4066Sahrens } else {
585fa9e4066Sahrens uint64_t vdev_size;
586fa9e4066Sahrens
587fa9e4066Sahrens /*
588fa9e4066Sahrens * This is a mirror or RAID-Z vdev. Go through and make
589fa9e4066Sahrens * sure the contents are all the same (files vs. disks),
590fa9e4066Sahrens * keeping track of the number of elements in the
591fa9e4066Sahrens * process.
592fa9e4066Sahrens *
593fa9e4066Sahrens * We also check that the size of each vdev (if it can
594fa9e4066Sahrens * be determined) is the same.
595fa9e4066Sahrens */
59699653d4eSeschrock rep.zprl_type = type;
59799653d4eSeschrock rep.zprl_children = 0;
59899653d4eSeschrock
59999653d4eSeschrock if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) {
60099653d4eSeschrock verify(nvlist_lookup_uint64(nv,
60199653d4eSeschrock ZPOOL_CONFIG_NPARITY,
60299653d4eSeschrock &rep.zprl_parity) == 0);
60399653d4eSeschrock assert(rep.zprl_parity != 0);
60499653d4eSeschrock } else {
60599653d4eSeschrock rep.zprl_parity = 0;
60699653d4eSeschrock }
607fa9e4066Sahrens
608fa9e4066Sahrens /*
6098654d025Sperrin * The 'dontreport' variable indicates that we've
610fa9e4066Sahrens * already reported an error for this spec, so don't
611fa9e4066Sahrens * bother doing it again.
612fa9e4066Sahrens */
613fa9e4066Sahrens type = NULL;
614fa9e4066Sahrens dontreport = 0;
615fa9e4066Sahrens vdev_size = -1ULL;
616fa9e4066Sahrens for (c = 0; c < children; c++) {
617fa9e4066Sahrens nvlist_t *cnv = child[c];
618fa9e4066Sahrens char *path;
619fa9e4066Sahrens struct stat64 statbuf;
620fa9e4066Sahrens uint64_t size = -1ULL;
621fa9e4066Sahrens char *childtype;
622fa9e4066Sahrens int fd, err;
623fa9e4066Sahrens
62499653d4eSeschrock rep.zprl_children++;
625fa9e4066Sahrens
626fa9e4066Sahrens verify(nvlist_lookup_string(cnv,
627fa9e4066Sahrens ZPOOL_CONFIG_TYPE, &childtype) == 0);
62894de1d4cSeschrock
62994de1d4cSeschrock /*
6308654d025Sperrin * If this is a replacing or spare vdev, then
63194de1d4cSeschrock * get the real first child of the vdev.
63294de1d4cSeschrock */
63394de1d4cSeschrock if (strcmp(childtype,
63494de1d4cSeschrock VDEV_TYPE_REPLACING) == 0 ||
63594de1d4cSeschrock strcmp(childtype, VDEV_TYPE_SPARE) == 0) {
63694de1d4cSeschrock nvlist_t **rchild;
63794de1d4cSeschrock uint_t rchildren;
63894de1d4cSeschrock
63994de1d4cSeschrock verify(nvlist_lookup_nvlist_array(cnv,
64094de1d4cSeschrock ZPOOL_CONFIG_CHILDREN, &rchild,
64194de1d4cSeschrock &rchildren) == 0);
64294de1d4cSeschrock assert(rchildren == 2);
64394de1d4cSeschrock cnv = rchild[0];
64494de1d4cSeschrock
64594de1d4cSeschrock verify(nvlist_lookup_string(cnv,
64694de1d4cSeschrock ZPOOL_CONFIG_TYPE,
64794de1d4cSeschrock &childtype) == 0);
64894de1d4cSeschrock }
64994de1d4cSeschrock
650fa9e4066Sahrens verify(nvlist_lookup_string(cnv,
651fa9e4066Sahrens ZPOOL_CONFIG_PATH, &path) == 0);
652fa9e4066Sahrens
653fa9e4066Sahrens /*
654fa9e4066Sahrens * If we have a raidz/mirror that combines disks
655fa9e4066Sahrens * with files, report it as an error.
656fa9e4066Sahrens */
657fa9e4066Sahrens if (!dontreport && type != NULL &&
658fa9e4066Sahrens strcmp(type, childtype) != 0) {
659fa9e4066Sahrens if (ret != NULL)
660fa9e4066Sahrens free(ret);
661fa9e4066Sahrens ret = NULL;
662fa9e4066Sahrens if (fatal)
663fa9e4066Sahrens vdev_error(gettext(
664fa9e4066Sahrens "mismatched replication "
665fa9e4066Sahrens "level: %s contains both "
666fa9e4066Sahrens "files and devices\n"),
66799653d4eSeschrock rep.zprl_type);
668fa9e4066Sahrens else
669fa9e4066Sahrens return (NULL);
67099653d4eSeschrock dontreport = B_TRUE;
671fa9e4066Sahrens }
672fa9e4066Sahrens
673fa9e4066Sahrens /*
674fa9e4066Sahrens * According to stat(2), the value of 'st_size'
675fa9e4066Sahrens * is undefined for block devices and character
676fa9e4066Sahrens * devices. But there is no effective way to
677fa9e4066Sahrens * determine the real size in userland.
678fa9e4066Sahrens *
679fa9e4066Sahrens * Instead, we'll take advantage of an
680fa9e4066Sahrens * implementation detail of spec_size(). If the
681fa9e4066Sahrens * device is currently open, then we (should)
682fa9e4066Sahrens * return a valid size.
683fa9e4066Sahrens *
684fa9e4066Sahrens * If we still don't get a valid size (indicated
685fa9e4066Sahrens * by a size of 0 or MAXOFFSET_T), then ignore
686fa9e4066Sahrens * this device altogether.
687fa9e4066Sahrens */
688fa9e4066Sahrens if ((fd = open(path, O_RDONLY)) >= 0) {
689fa9e4066Sahrens err = fstat64(fd, &statbuf);
690fa9e4066Sahrens (void) close(fd);
691fa9e4066Sahrens } else {
692fa9e4066Sahrens err = stat64(path, &statbuf);
693fa9e4066Sahrens }
694fa9e4066Sahrens
695fa9e4066Sahrens if (err != 0 ||
696fa9e4066Sahrens statbuf.st_size == 0 ||
697fa9e4066Sahrens statbuf.st_size == MAXOFFSET_T)
698fa9e4066Sahrens continue;
699fa9e4066Sahrens
700fa9e4066Sahrens size = statbuf.st_size;
701fa9e4066Sahrens
702fa9e4066Sahrens /*
7038488aeb5Staylor * Also make sure that devices and
7048488aeb5Staylor * slices have a consistent size. If
7058488aeb5Staylor * they differ by a significant amount
7068488aeb5Staylor * (~16MB) then report an error.
707fa9e4066Sahrens */
7088488aeb5Staylor if (!dontreport &&
7098488aeb5Staylor (vdev_size != -1ULL &&
7108488aeb5Staylor (labs(size - vdev_size) >
7118488aeb5Staylor ZPOOL_FUZZ))) {
712fa9e4066Sahrens if (ret != NULL)
713fa9e4066Sahrens free(ret);
714fa9e4066Sahrens ret = NULL;
715fa9e4066Sahrens if (fatal)
716fa9e4066Sahrens vdev_error(gettext(
717fa9e4066Sahrens "%s contains devices of "
718fa9e4066Sahrens "different sizes\n"),
71999653d4eSeschrock rep.zprl_type);
720fa9e4066Sahrens else
721fa9e4066Sahrens return (NULL);
72299653d4eSeschrock dontreport = B_TRUE;
723fa9e4066Sahrens }
724fa9e4066Sahrens
725fa9e4066Sahrens type = childtype;
726fa9e4066Sahrens vdev_size = size;
727fa9e4066Sahrens }
728fa9e4066Sahrens }
729fa9e4066Sahrens
730fa9e4066Sahrens /*
731fa9e4066Sahrens * At this point, we have the replication of the last toplevel
732fa9e4066Sahrens * vdev in 'rep'. Compare it to 'lastrep' to see if its
733fa9e4066Sahrens * different.
734fa9e4066Sahrens */
73599653d4eSeschrock if (lastrep.zprl_type != NULL) {
73699653d4eSeschrock if (strcmp(lastrep.zprl_type, rep.zprl_type) != 0) {
737fa9e4066Sahrens if (ret != NULL)
738fa9e4066Sahrens free(ret);
739fa9e4066Sahrens ret = NULL;
740fa9e4066Sahrens if (fatal)
741fa9e4066Sahrens vdev_error(gettext(
74299653d4eSeschrock "mismatched replication level: "
74399653d4eSeschrock "both %s and %s vdevs are "
744fa9e4066Sahrens "present\n"),
74599653d4eSeschrock lastrep.zprl_type, rep.zprl_type);
746fa9e4066Sahrens else
747fa9e4066Sahrens return (NULL);
74899653d4eSeschrock } else if (lastrep.zprl_parity != rep.zprl_parity) {
749fa9e4066Sahrens if (ret)
750fa9e4066Sahrens free(ret);
751fa9e4066Sahrens ret = NULL;
752fa9e4066Sahrens if (fatal)
753fa9e4066Sahrens vdev_error(gettext(
75499653d4eSeschrock "mismatched replication level: "
75599653d4eSeschrock "both %llu and %llu device parity "
75699653d4eSeschrock "%s vdevs are present\n"),
75799653d4eSeschrock lastrep.zprl_parity,
75899653d4eSeschrock rep.zprl_parity,
75999653d4eSeschrock rep.zprl_type);
76099653d4eSeschrock else
76199653d4eSeschrock return (NULL);
76299653d4eSeschrock } else if (lastrep.zprl_children != rep.zprl_children) {
76399653d4eSeschrock if (ret)
76499653d4eSeschrock free(ret);
76599653d4eSeschrock ret = NULL;
76699653d4eSeschrock if (fatal)
76799653d4eSeschrock vdev_error(gettext(
76899653d4eSeschrock "mismatched replication level: "
76999653d4eSeschrock "both %llu-way and %llu-way %s "
770fa9e4066Sahrens "vdevs are present\n"),
77199653d4eSeschrock lastrep.zprl_children,
77299653d4eSeschrock rep.zprl_children,
77399653d4eSeschrock rep.zprl_type);
774fa9e4066Sahrens else
775fa9e4066Sahrens return (NULL);
776fa9e4066Sahrens }
777fa9e4066Sahrens }
778fa9e4066Sahrens lastrep = rep;
779fa9e4066Sahrens }
780fa9e4066Sahrens
78199653d4eSeschrock if (ret != NULL)
78299653d4eSeschrock *ret = rep;
783fa9e4066Sahrens
784fa9e4066Sahrens return (ret);
785fa9e4066Sahrens }
786fa9e4066Sahrens
787fa9e4066Sahrens /*
788fa9e4066Sahrens * Check the replication level of the vdev spec against the current pool. Calls
789fa9e4066Sahrens * get_replication() to make sure the new spec is self-consistent. If the pool
790fa9e4066Sahrens * has a consistent replication level, then we ignore any errors. Otherwise,
791fa9e4066Sahrens * report any difference between the two.
792fa9e4066Sahrens */
7938488aeb5Staylor static int
check_replication(nvlist_t * config,nvlist_t * newroot)794fa9e4066Sahrens check_replication(nvlist_t *config, nvlist_t *newroot)
795fa9e4066Sahrens {
7968488aeb5Staylor nvlist_t **child;
7978488aeb5Staylor uint_t children;
798fa9e4066Sahrens replication_level_t *current = NULL, *new;
799fa9e4066Sahrens int ret;
800fa9e4066Sahrens
801fa9e4066Sahrens /*
802fa9e4066Sahrens * If we have a current pool configuration, check to see if it's
803fa9e4066Sahrens * self-consistent. If not, simply return success.
804fa9e4066Sahrens */
805fa9e4066Sahrens if (config != NULL) {
806fa9e4066Sahrens nvlist_t *nvroot;
807fa9e4066Sahrens
808fa9e4066Sahrens verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
809fa9e4066Sahrens &nvroot) == 0);
81099653d4eSeschrock if ((current = get_replication(nvroot, B_FALSE)) == NULL)
811fa9e4066Sahrens return (0);
812fa9e4066Sahrens }
8138488aeb5Staylor /*
8148488aeb5Staylor * for spares there may be no children, and therefore no
8158488aeb5Staylor * replication level to check
8168488aeb5Staylor */
8178488aeb5Staylor if ((nvlist_lookup_nvlist_array(newroot, ZPOOL_CONFIG_CHILDREN,
8188488aeb5Staylor &child, &children) != 0) || (children == 0)) {
8198488aeb5Staylor free(current);
8208488aeb5Staylor return (0);
8218488aeb5Staylor }
822fa9e4066Sahrens
823fa9e4066Sahrens /*
8248654d025Sperrin * If all we have is logs then there's no replication level to check.
8258654d025Sperrin */
8268654d025Sperrin if (num_logs(newroot) == children) {
8278654d025Sperrin free(current);
8288654d025Sperrin return (0);
8298654d025Sperrin }
8308654d025Sperrin
8318654d025Sperrin /*
832fa9e4066Sahrens * Get the replication level of the new vdev spec, reporting any
833fa9e4066Sahrens * inconsistencies found.
834fa9e4066Sahrens */
83599653d4eSeschrock if ((new = get_replication(newroot, B_TRUE)) == NULL) {
836fa9e4066Sahrens free(current);
837fa9e4066Sahrens return (-1);
838fa9e4066Sahrens }
839fa9e4066Sahrens
840fa9e4066Sahrens /*
841fa9e4066Sahrens * Check to see if the new vdev spec matches the replication level of
842fa9e4066Sahrens * the current pool.
843fa9e4066Sahrens */
844fa9e4066Sahrens ret = 0;
845fa9e4066Sahrens if (current != NULL) {
84699653d4eSeschrock if (strcmp(current->zprl_type, new->zprl_type) != 0) {
847fa9e4066Sahrens vdev_error(gettext(
84899653d4eSeschrock "mismatched replication level: pool uses %s "
84999653d4eSeschrock "and new vdev is %s\n"),
85099653d4eSeschrock current->zprl_type, new->zprl_type);
85199653d4eSeschrock ret = -1;
85299653d4eSeschrock } else if (current->zprl_parity != new->zprl_parity) {
85399653d4eSeschrock vdev_error(gettext(
85499653d4eSeschrock "mismatched replication level: pool uses %llu "
85599653d4eSeschrock "device parity and new vdev uses %llu\n"),
85699653d4eSeschrock current->zprl_parity, new->zprl_parity);
85799653d4eSeschrock ret = -1;
85899653d4eSeschrock } else if (current->zprl_children != new->zprl_children) {
85999653d4eSeschrock vdev_error(gettext(
86099653d4eSeschrock "mismatched replication level: pool uses %llu-way "
86199653d4eSeschrock "%s and new vdev uses %llu-way %s\n"),
86299653d4eSeschrock current->zprl_children, current->zprl_type,
86399653d4eSeschrock new->zprl_children, new->zprl_type);
864fa9e4066Sahrens ret = -1;
865fa9e4066Sahrens }
866fa9e4066Sahrens }
867fa9e4066Sahrens
868fa9e4066Sahrens free(new);
869fa9e4066Sahrens if (current != NULL)
870fa9e4066Sahrens free(current);
871fa9e4066Sahrens
872fa9e4066Sahrens return (ret);
873fa9e4066Sahrens }
874fa9e4066Sahrens
875fa9e4066Sahrens /*
876fa9e4066Sahrens * Go through and find any whole disks in the vdev specification, labelling them
877fa9e4066Sahrens * as appropriate. When constructing the vdev spec, we were unable to open this
878fa9e4066Sahrens * device in order to provide a devid. Now that we have labelled the disk and
879fa9e4066Sahrens * know that slice 0 is valid, we can construct the devid now.
880fa9e4066Sahrens *
8818488aeb5Staylor * If the disk was already labeled with an EFI label, we will have gotten the
882fa9e4066Sahrens * devid already (because we were able to open the whole disk). Otherwise, we
883fa9e4066Sahrens * need to get the devid after we label the disk.
884fa9e4066Sahrens */
8858488aeb5Staylor static int
make_disks(zpool_handle_t * zhp,nvlist_t * nv)8868488aeb5Staylor make_disks(zpool_handle_t *zhp, nvlist_t *nv)
887fa9e4066Sahrens {
888fa9e4066Sahrens nvlist_t **child;
889fa9e4066Sahrens uint_t c, children;
890fa9e4066Sahrens char *type, *path, *diskname;
891fa9e4066Sahrens char buf[MAXPATHLEN];
892afefbcddSeschrock uint64_t wholedisk;
893fa9e4066Sahrens int fd;
894fa9e4066Sahrens int ret;
895fa9e4066Sahrens ddi_devid_t devid;
896fa9e4066Sahrens char *minor = NULL, *devid_str = NULL;
897fa9e4066Sahrens
898fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0);
899fa9e4066Sahrens
900fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
901fa9e4066Sahrens &child, &children) != 0) {
902fa9e4066Sahrens
903fa9e4066Sahrens if (strcmp(type, VDEV_TYPE_DISK) != 0)
904fa9e4066Sahrens return (0);
905fa9e4066Sahrens
906fa9e4066Sahrens /*
907fa9e4066Sahrens * We have a disk device. Get the path to the device
9088488aeb5Staylor * and see if it's a whole disk by appending the backup
909fa9e4066Sahrens * slice and stat()ing the device.
910fa9e4066Sahrens */
911fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0);
912afefbcddSeschrock if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
913afefbcddSeschrock &wholedisk) != 0 || !wholedisk)
914fa9e4066Sahrens return (0);
915fa9e4066Sahrens
916fa9e4066Sahrens diskname = strrchr(path, '/');
917fa9e4066Sahrens assert(diskname != NULL);
918fa9e4066Sahrens diskname++;
9198488aeb5Staylor if (zpool_label_disk(g_zfs, zhp, diskname) == -1)
920fa9e4066Sahrens return (-1);
921fa9e4066Sahrens
922fa9e4066Sahrens /*
923fa9e4066Sahrens * Fill in the devid, now that we've labeled the disk.
924fa9e4066Sahrens */
925fa9e4066Sahrens (void) snprintf(buf, sizeof (buf), "%ss0", path);
926fa9e4066Sahrens if ((fd = open(buf, O_RDONLY)) < 0) {
927fa9e4066Sahrens (void) fprintf(stderr,
928fa9e4066Sahrens gettext("cannot open '%s': %s\n"),
929fa9e4066Sahrens buf, strerror(errno));
930fa9e4066Sahrens return (-1);
931fa9e4066Sahrens }
932fa9e4066Sahrens
933fa9e4066Sahrens if (devid_get(fd, &devid) == 0) {
934fa9e4066Sahrens if (devid_get_minor_name(fd, &minor) == 0 &&
935fa9e4066Sahrens (devid_str = devid_str_encode(devid, minor)) !=
936fa9e4066Sahrens NULL) {
937fa9e4066Sahrens verify(nvlist_add_string(nv,
938fa9e4066Sahrens ZPOOL_CONFIG_DEVID, devid_str) == 0);
939fa9e4066Sahrens }
940fa9e4066Sahrens if (devid_str != NULL)
941fa9e4066Sahrens devid_str_free(devid_str);
942fa9e4066Sahrens if (minor != NULL)
943fa9e4066Sahrens devid_str_free(minor);
944fa9e4066Sahrens devid_free(devid);
945fa9e4066Sahrens }
946fa9e4066Sahrens
947afefbcddSeschrock /*
948afefbcddSeschrock * Update the path to refer to the 's0' slice. The presence of
949afefbcddSeschrock * the 'whole_disk' field indicates to the CLI that we should
950afefbcddSeschrock * chop off the slice number when displaying the device in
951afefbcddSeschrock * future output.
952afefbcddSeschrock */
953afefbcddSeschrock verify(nvlist_add_string(nv, ZPOOL_CONFIG_PATH, buf) == 0);
954afefbcddSeschrock
955fa9e4066Sahrens (void) close(fd);
956fa9e4066Sahrens
957fa9e4066Sahrens return (0);
958fa9e4066Sahrens }
959fa9e4066Sahrens
960fa9e4066Sahrens for (c = 0; c < children; c++)
9618488aeb5Staylor if ((ret = make_disks(zhp, child[c])) != 0)
962fa9e4066Sahrens return (ret);
963fa9e4066Sahrens
96499653d4eSeschrock if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
96599653d4eSeschrock &child, &children) == 0)
96699653d4eSeschrock for (c = 0; c < children; c++)
9678488aeb5Staylor if ((ret = make_disks(zhp, child[c])) != 0)
96899653d4eSeschrock return (ret);
96999653d4eSeschrock
970fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
971fa94a07fSbrendan &child, &children) == 0)
972fa94a07fSbrendan for (c = 0; c < children; c++)
973fa94a07fSbrendan if ((ret = make_disks(zhp, child[c])) != 0)
974fa94a07fSbrendan return (ret);
975fa94a07fSbrendan
976fa9e4066Sahrens return (0);
977fa9e4066Sahrens }
978fa9e4066Sahrens
979fa9e4066Sahrens /*
98099653d4eSeschrock * Determine if the given path is a hot spare within the given configuration.
98199653d4eSeschrock */
98299653d4eSeschrock static boolean_t
is_spare(nvlist_t * config,const char * path)98399653d4eSeschrock is_spare(nvlist_t *config, const char *path)
98499653d4eSeschrock {
98599653d4eSeschrock int fd;
98699653d4eSeschrock pool_state_t state;
9873ccfa83cSahrens char *name = NULL;
98899653d4eSeschrock nvlist_t *label;
98999653d4eSeschrock uint64_t guid, spareguid;
99099653d4eSeschrock nvlist_t *nvroot;
99199653d4eSeschrock nvlist_t **spares;
99299653d4eSeschrock uint_t i, nspares;
99399653d4eSeschrock boolean_t inuse;
99499653d4eSeschrock
99599653d4eSeschrock if ((fd = open(path, O_RDONLY)) < 0)
99699653d4eSeschrock return (B_FALSE);
99799653d4eSeschrock
99899653d4eSeschrock if (zpool_in_use(g_zfs, fd, &state, &name, &inuse) != 0 ||
99999653d4eSeschrock !inuse ||
100099653d4eSeschrock state != POOL_STATE_SPARE ||
100199653d4eSeschrock zpool_read_label(fd, &label) != 0) {
10023ccfa83cSahrens free(name);
100399653d4eSeschrock (void) close(fd);
100499653d4eSeschrock return (B_FALSE);
100599653d4eSeschrock }
10063ccfa83cSahrens free(name);
100799653d4eSeschrock (void) close(fd);
10083f9d6ad7SLin Ling
100999653d4eSeschrock verify(nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID, &guid) == 0);
101099653d4eSeschrock nvlist_free(label);
101199653d4eSeschrock
101299653d4eSeschrock verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
101399653d4eSeschrock &nvroot) == 0);
101499653d4eSeschrock if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
101599653d4eSeschrock &spares, &nspares) == 0) {
101699653d4eSeschrock for (i = 0; i < nspares; i++) {
101799653d4eSeschrock verify(nvlist_lookup_uint64(spares[i],
101899653d4eSeschrock ZPOOL_CONFIG_GUID, &spareguid) == 0);
101999653d4eSeschrock if (spareguid == guid)
102099653d4eSeschrock return (B_TRUE);
102199653d4eSeschrock }
102299653d4eSeschrock }
102399653d4eSeschrock
102499653d4eSeschrock return (B_FALSE);
102599653d4eSeschrock }
102699653d4eSeschrock
102799653d4eSeschrock /*
1028fa9e4066Sahrens * Go through and find any devices that are in use. We rely on libdiskmgt for
1029fa9e4066Sahrens * the majority of this task.
1030fa9e4066Sahrens */
1031*09933095SBasil Crow static boolean_t
is_device_in_use(nvlist_t * config,nvlist_t * nv,boolean_t force,boolean_t replacing,boolean_t isspare)1032*09933095SBasil Crow is_device_in_use(nvlist_t *config, nvlist_t *nv, boolean_t force,
10333f9d6ad7SLin Ling boolean_t replacing, boolean_t isspare)
1034fa9e4066Sahrens {
1035fa9e4066Sahrens nvlist_t **child;
1036fa9e4066Sahrens uint_t c, children;
1037fa9e4066Sahrens char *type, *path;
1038fa9e4066Sahrens int ret;
103999653d4eSeschrock char buf[MAXPATHLEN];
104099653d4eSeschrock uint64_t wholedisk;
1041*09933095SBasil Crow boolean_t anyinuse = B_FALSE;
1042fa9e4066Sahrens
1043fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0);
1044fa9e4066Sahrens
1045fa9e4066Sahrens if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
1046fa9e4066Sahrens &child, &children) != 0) {
1047fa9e4066Sahrens
1048fa9e4066Sahrens verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0);
1049fa9e4066Sahrens
105099653d4eSeschrock /*
105199653d4eSeschrock * As a generic check, we look to see if this is a replace of a
105299653d4eSeschrock * hot spare within the same pool. If so, we allow it
105399653d4eSeschrock * regardless of what libdiskmgt or zpool_in_use() says.
105499653d4eSeschrock */
10553f9d6ad7SLin Ling if (replacing) {
105699653d4eSeschrock if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
105799653d4eSeschrock &wholedisk) == 0 && wholedisk)
105899653d4eSeschrock (void) snprintf(buf, sizeof (buf), "%ss0",
105999653d4eSeschrock path);
106099653d4eSeschrock else
106199653d4eSeschrock (void) strlcpy(buf, path, sizeof (buf));
10623f9d6ad7SLin Ling
106399653d4eSeschrock if (is_spare(config, buf))
1064*09933095SBasil Crow return (B_FALSE);
106599653d4eSeschrock }
106699653d4eSeschrock
1067fa9e4066Sahrens if (strcmp(type, VDEV_TYPE_DISK) == 0)
106899653d4eSeschrock ret = check_device(path, force, isspare);
1069*09933095SBasil Crow else if (strcmp(type, VDEV_TYPE_FILE) == 0)
107099653d4eSeschrock ret = check_file(path, force, isspare);
1071fa9e4066Sahrens
1072*09933095SBasil Crow return (ret != 0);
1073fa9e4066Sahrens }
1074fa9e4066Sahrens
1075fa9e4066Sahrens for (c = 0; c < children; c++)
1076*09933095SBasil Crow if (is_device_in_use(config, child[c], force, replacing,
1077*09933095SBasil Crow B_FALSE))
1078*09933095SBasil Crow anyinuse = B_TRUE;
107999653d4eSeschrock
108099653d4eSeschrock if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
108199653d4eSeschrock &child, &children) == 0)
108299653d4eSeschrock for (c = 0; c < children; c++)
1083*09933095SBasil Crow if (is_device_in_use(config, child[c], force, replacing,
1084*09933095SBasil Crow B_TRUE))
1085*09933095SBasil Crow anyinuse = B_TRUE;
1086fa94a07fSbrendan
1087fa94a07fSbrendan if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
1088fa94a07fSbrendan &child, &children) == 0)
1089fa94a07fSbrendan for (c = 0; c < children; c++)
1090*09933095SBasil Crow if (is_device_in_use(config, child[c], force, replacing,
1091*09933095SBasil Crow B_FALSE))
1092*09933095SBasil Crow anyinuse = B_TRUE;
1093fa94a07fSbrendan
1094*09933095SBasil Crow return (anyinuse);
1095fa9e4066Sahrens }
1096fa9e4066Sahrens
10978488aeb5Staylor static const char *
is_grouping(const char * type,int * mindev,int * maxdev)1098f94275ceSAdam Leventhal is_grouping(const char *type, int *mindev, int *maxdev)
109999653d4eSeschrock {
1100f94275ceSAdam Leventhal if (strncmp(type, "raidz", 5) == 0) {
1101f94275ceSAdam Leventhal const char *p = type + 5;
1102f94275ceSAdam Leventhal char *end;
1103f94275ceSAdam Leventhal long nparity;
1104f94275ceSAdam Leventhal
1105f94275ceSAdam Leventhal if (*p == '\0') {
1106f94275ceSAdam Leventhal nparity = 1;
1107f94275ceSAdam Leventhal } else if (*p == '0') {
1108f94275ceSAdam Leventhal return (NULL); /* no zero prefixes allowed */
1109f94275ceSAdam Leventhal } else {
1110f94275ceSAdam Leventhal errno = 0;
1111f94275ceSAdam Leventhal nparity = strtol(p, &end, 10);
1112f94275ceSAdam Leventhal if (errno != 0 || nparity < 1 || nparity >= 255 ||
1113f94275ceSAdam Leventhal *end != '\0')
1114f94275ceSAdam Leventhal return (NULL);
1115f94275ceSAdam Leventhal }
1116f94275ceSAdam Leventhal
111799653d4eSeschrock if (mindev != NULL)
1118f94275ceSAdam Leventhal *mindev = nparity + 1;
1119f94275ceSAdam Leventhal if (maxdev != NULL)
1120f94275ceSAdam Leventhal *maxdev = 255;
112199653d4eSeschrock return (VDEV_TYPE_RAIDZ);
112299653d4eSeschrock }
112399653d4eSeschrock
1124f94275ceSAdam Leventhal if (maxdev != NULL)
1125f94275ceSAdam Leventhal *maxdev = INT_MAX;
112699653d4eSeschrock
112799653d4eSeschrock if (strcmp(type, "mirror") == 0) {
112899653d4eSeschrock if (mindev != NULL)
112999653d4eSeschrock *mindev = 2;
113099653d4eSeschrock return (VDEV_TYPE_MIRROR);
113199653d4eSeschrock }
113299653d4eSeschrock
113399653d4eSeschrock if (strcmp(type, "spare") == 0) {
113499653d4eSeschrock if (mindev != NULL)
113599653d4eSeschrock *mindev = 1;
113699653d4eSeschrock return (VDEV_TYPE_SPARE);
113799653d4eSeschrock }
113899653d4eSeschrock
11398654d025Sperrin if (strcmp(type, "log") == 0) {
11408654d025Sperrin if (mindev != NULL)
11418654d025Sperrin *mindev = 1;
11428654d025Sperrin return (VDEV_TYPE_LOG);
11438654d025Sperrin }
11448654d025Sperrin
1145fa94a07fSbrendan if (strcmp(type, "cache") == 0) {
1146fa94a07fSbrendan if (mindev != NULL)
1147fa94a07fSbrendan *mindev = 1;
1148fa94a07fSbrendan return (VDEV_TYPE_L2CACHE);
1149fa94a07fSbrendan }
1150fa94a07fSbrendan
115199653d4eSeschrock return (NULL);
115299653d4eSeschrock }
115399653d4eSeschrock
1154fa9e4066Sahrens /*
1155fa9e4066Sahrens * Construct a syntactically valid vdev specification,
1156fa9e4066Sahrens * and ensure that all devices and files exist and can be opened.
1157fa9e4066Sahrens * Note: we don't bother freeing anything in the error paths
1158fa9e4066Sahrens * because the program is just going to exit anyway.
1159fa9e4066Sahrens */
1160fa9e4066Sahrens nvlist_t *
construct_spec(int argc,char ** argv)1161fa9e4066Sahrens construct_spec(int argc, char **argv)
1162fa9e4066Sahrens {
1163fa94a07fSbrendan nvlist_t *nvroot, *nv, **top, **spares, **l2cache;
1164f94275ceSAdam Leventhal int t, toplevels, mindev, maxdev, nspares, nlogs, nl2cache;
116599653d4eSeschrock const char *type;
11668654d025Sperrin uint64_t is_log;
11678654d025Sperrin boolean_t seen_logs;
1168fa9e4066Sahrens
1169fa9e4066Sahrens top = NULL;
1170fa9e4066Sahrens toplevels = 0;
117199653d4eSeschrock spares = NULL;
1172fa94a07fSbrendan l2cache = NULL;
117399653d4eSeschrock nspares = 0;
11748654d025Sperrin nlogs = 0;
1175fa94a07fSbrendan nl2cache = 0;
11768654d025Sperrin is_log = B_FALSE;
11778654d025Sperrin seen_logs = B_FALSE;
1178fa9e4066Sahrens
1179fa9e4066Sahrens while (argc > 0) {
1180fa9e4066Sahrens nv = NULL;
1181fa9e4066Sahrens
1182fa9e4066Sahrens /*
1183fa9e4066Sahrens * If it's a mirror or raidz, the subsequent arguments are
1184fa9e4066Sahrens * its leaves -- until we encounter the next mirror or raidz.
1185fa9e4066Sahrens */
1186f94275ceSAdam Leventhal if ((type = is_grouping(argv[0], &mindev, &maxdev)) != NULL) {
1187fa9e4066Sahrens nvlist_t **child = NULL;
118899653d4eSeschrock int c, children = 0;
118999653d4eSeschrock
11908654d025Sperrin if (strcmp(type, VDEV_TYPE_SPARE) == 0) {
11918654d025Sperrin if (spares != NULL) {
11928654d025Sperrin (void) fprintf(stderr,
11938654d025Sperrin gettext("invalid vdev "
119499653d4eSeschrock "specification: 'spare' can be "
119599653d4eSeschrock "specified only once\n"));
119699653d4eSeschrock return (NULL);
119799653d4eSeschrock }
11988654d025Sperrin is_log = B_FALSE;
11998654d025Sperrin }
12008654d025Sperrin
12018654d025Sperrin if (strcmp(type, VDEV_TYPE_LOG) == 0) {
12028654d025Sperrin if (seen_logs) {
12038654d025Sperrin (void) fprintf(stderr,
12048654d025Sperrin gettext("invalid vdev "
12058654d025Sperrin "specification: 'log' can be "
12068654d025Sperrin "specified only once\n"));
12078654d025Sperrin return (NULL);
12088654d025Sperrin }
12098654d025Sperrin seen_logs = B_TRUE;
12108654d025Sperrin is_log = B_TRUE;
12118654d025Sperrin argc--;
12128654d025Sperrin argv++;
12138654d025Sperrin /*
12148654d025Sperrin * A log is not a real grouping device.
12158654d025Sperrin * We just set is_log and continue.
12168654d025Sperrin */
12178654d025Sperrin continue;
12188654d025Sperrin }
12198654d025Sperrin
1220fa94a07fSbrendan if (strcmp(type, VDEV_TYPE_L2CACHE) == 0) {
1221fa94a07fSbrendan if (l2cache != NULL) {
1222fa94a07fSbrendan (void) fprintf(stderr,
1223fa94a07fSbrendan gettext("invalid vdev "
1224fa94a07fSbrendan "specification: 'cache' can be "
1225fa94a07fSbrendan "specified only once\n"));
1226fa94a07fSbrendan return (NULL);
1227fa94a07fSbrendan }
1228fa94a07fSbrendan is_log = B_FALSE;
1229fa94a07fSbrendan }
1230fa94a07fSbrendan
12318654d025Sperrin if (is_log) {
12328654d025Sperrin if (strcmp(type, VDEV_TYPE_MIRROR) != 0) {
12338654d025Sperrin (void) fprintf(stderr,
12348654d025Sperrin gettext("invalid vdev "
12358654d025Sperrin "specification: unsupported 'log' "
12368654d025Sperrin "device: %s\n"), type);
12378654d025Sperrin return (NULL);
12388654d025Sperrin }
12398654d025Sperrin nlogs++;
12408654d025Sperrin }
1241fa9e4066Sahrens
1242fa9e4066Sahrens for (c = 1; c < argc; c++) {
1243f94275ceSAdam Leventhal if (is_grouping(argv[c], NULL, NULL) != NULL)
1244fa9e4066Sahrens break;
1245fa9e4066Sahrens children++;
1246fa9e4066Sahrens child = realloc(child,
1247fa9e4066Sahrens children * sizeof (nvlist_t *));
1248fa9e4066Sahrens if (child == NULL)
12495ad82045Snd150628 zpool_no_memory();
12508654d025Sperrin if ((nv = make_leaf_vdev(argv[c], B_FALSE))
12518654d025Sperrin == NULL)
1252fa9e4066Sahrens return (NULL);
1253fa9e4066Sahrens child[children - 1] = nv;
1254fa9e4066Sahrens }
1255fa9e4066Sahrens
125699653d4eSeschrock if (children < mindev) {
125799653d4eSeschrock (void) fprintf(stderr, gettext("invalid vdev "
125899653d4eSeschrock "specification: %s requires at least %d "
125999653d4eSeschrock "devices\n"), argv[0], mindev);
1260fa9e4066Sahrens return (NULL);
1261fa9e4066Sahrens }
1262fa9e4066Sahrens
1263f94275ceSAdam Leventhal if (children > maxdev) {
1264f94275ceSAdam Leventhal (void) fprintf(stderr, gettext("invalid vdev "
1265f94275ceSAdam Leventhal "specification: %s supports no more than "
1266f94275ceSAdam Leventhal "%d devices\n"), argv[0], maxdev);
1267f94275ceSAdam Leventhal return (NULL);
1268f94275ceSAdam Leventhal }
1269f94275ceSAdam Leventhal
127099653d4eSeschrock argc -= c;
127199653d4eSeschrock argv += c;
127299653d4eSeschrock
127399653d4eSeschrock if (strcmp(type, VDEV_TYPE_SPARE) == 0) {
127499653d4eSeschrock spares = child;
127599653d4eSeschrock nspares = children;
127699653d4eSeschrock continue;
1277fa94a07fSbrendan } else if (strcmp(type, VDEV_TYPE_L2CACHE) == 0) {
1278fa94a07fSbrendan l2cache = child;
1279fa94a07fSbrendan nl2cache = children;
1280fa94a07fSbrendan continue;
128199653d4eSeschrock } else {
128299653d4eSeschrock verify(nvlist_alloc(&nv, NV_UNIQUE_NAME,
128399653d4eSeschrock 0) == 0);
1284fa9e4066Sahrens verify(nvlist_add_string(nv, ZPOOL_CONFIG_TYPE,
1285fa9e4066Sahrens type) == 0);
12868654d025Sperrin verify(nvlist_add_uint64(nv,
12878654d025Sperrin ZPOOL_CONFIG_IS_LOG, is_log) == 0);
128899653d4eSeschrock if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) {
128999653d4eSeschrock verify(nvlist_add_uint64(nv,
129099653d4eSeschrock ZPOOL_CONFIG_NPARITY,
129199653d4eSeschrock mindev - 1) == 0);
129299653d4eSeschrock }
1293fa9e4066Sahrens verify(nvlist_add_nvlist_array(nv,
129499653d4eSeschrock ZPOOL_CONFIG_CHILDREN, child,
129599653d4eSeschrock children) == 0);
1296fa9e4066Sahrens
1297fa9e4066Sahrens for (c = 0; c < children; c++)
1298fa9e4066Sahrens nvlist_free(child[c]);
1299fa9e4066Sahrens free(child);
130099653d4eSeschrock }
1301fa9e4066Sahrens } else {
1302fa9e4066Sahrens /*
1303fa9e4066Sahrens * We have a device. Pass off to make_leaf_vdev() to
1304fa9e4066Sahrens * construct the appropriate nvlist describing the vdev.
1305fa9e4066Sahrens */
13068654d025Sperrin if ((nv = make_leaf_vdev(argv[0], is_log)) == NULL)
1307fa9e4066Sahrens return (NULL);
13088654d025Sperrin if (is_log)
13098654d025Sperrin nlogs++;
1310fa9e4066Sahrens argc--;
1311fa9e4066Sahrens argv++;
1312fa9e4066Sahrens }
1313fa9e4066Sahrens
1314fa9e4066Sahrens toplevels++;
1315fa9e4066Sahrens top = realloc(top, toplevels * sizeof (nvlist_t *));
1316fa9e4066Sahrens if (top == NULL)
13175ad82045Snd150628 zpool_no_memory();
1318fa9e4066Sahrens top[toplevels - 1] = nv;
1319fa9e4066Sahrens }
1320fa9e4066Sahrens
1321fa94a07fSbrendan if (toplevels == 0 && nspares == 0 && nl2cache == 0) {
132299653d4eSeschrock (void) fprintf(stderr, gettext("invalid vdev "
132399653d4eSeschrock "specification: at least one toplevel vdev must be "
132499653d4eSeschrock "specified\n"));
132599653d4eSeschrock return (NULL);
132699653d4eSeschrock }
132799653d4eSeschrock
13288654d025Sperrin if (seen_logs && nlogs == 0) {
13298654d025Sperrin (void) fprintf(stderr, gettext("invalid vdev specification: "
13308654d025Sperrin "log requires at least 1 device\n"));
13318654d025Sperrin return (NULL);
13328654d025Sperrin }
13338654d025Sperrin
1334fa9e4066Sahrens /*
1335fa9e4066Sahrens * Finally, create nvroot and add all top-level vdevs to it.
1336fa9e4066Sahrens */
1337fa9e4066Sahrens verify(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, 0) == 0);
1338fa9e4066Sahrens verify(nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE,
1339fa9e4066Sahrens VDEV_TYPE_ROOT) == 0);
1340fa9e4066Sahrens verify(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
1341fa9e4066Sahrens top, toplevels) == 0);
134299653d4eSeschrock if (nspares != 0)
134399653d4eSeschrock verify(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
134499653d4eSeschrock spares, nspares) == 0);
1345fa94a07fSbrendan if (nl2cache != 0)
1346fa94a07fSbrendan verify(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
1347fa94a07fSbrendan l2cache, nl2cache) == 0);
1348fa9e4066Sahrens
1349fa9e4066Sahrens for (t = 0; t < toplevels; t++)
1350fa9e4066Sahrens nvlist_free(top[t]);
135199653d4eSeschrock for (t = 0; t < nspares; t++)
135299653d4eSeschrock nvlist_free(spares[t]);
1353fa94a07fSbrendan for (t = 0; t < nl2cache; t++)
1354fa94a07fSbrendan nvlist_free(l2cache[t]);
135599653d4eSeschrock if (spares)
135699653d4eSeschrock free(spares);
1357fa94a07fSbrendan if (l2cache)
1358fa94a07fSbrendan free(l2cache);
1359fa9e4066Sahrens free(top);
1360fa9e4066Sahrens
1361fa9e4066Sahrens return (nvroot);
1362fa9e4066Sahrens }
1363fa9e4066Sahrens
13641195e687SMark J Musante nvlist_t *
split_mirror_vdev(zpool_handle_t * zhp,char * newname,nvlist_t * props,splitflags_t flags,int argc,char ** argv)13651195e687SMark J Musante split_mirror_vdev(zpool_handle_t *zhp, char *newname, nvlist_t *props,
13661195e687SMark J Musante splitflags_t flags, int argc, char **argv)
13671195e687SMark J Musante {
13681195e687SMark J Musante nvlist_t *newroot = NULL, **child;
13691195e687SMark J Musante uint_t c, children;
13701195e687SMark J Musante
13711195e687SMark J Musante if (argc > 0) {
13721195e687SMark J Musante if ((newroot = construct_spec(argc, argv)) == NULL) {
13731195e687SMark J Musante (void) fprintf(stderr, gettext("Unable to build a "
13741195e687SMark J Musante "pool from the specified devices\n"));
13751195e687SMark J Musante return (NULL);
13761195e687SMark J Musante }
13771195e687SMark J Musante
13781195e687SMark J Musante if (!flags.dryrun && make_disks(zhp, newroot) != 0) {
13791195e687SMark J Musante nvlist_free(newroot);
13801195e687SMark J Musante return (NULL);
13811195e687SMark J Musante }
13821195e687SMark J Musante
13831195e687SMark J Musante /* avoid any tricks in the spec */
13841195e687SMark J Musante verify(nvlist_lookup_nvlist_array(newroot,
13851195e687SMark J Musante ZPOOL_CONFIG_CHILDREN, &child, &children) == 0);
13861195e687SMark J Musante for (c = 0; c < children; c++) {
13871195e687SMark J Musante char *path;
13881195e687SMark J Musante const char *type;
13891195e687SMark J Musante int min, max;
13901195e687SMark J Musante
13911195e687SMark J Musante verify(nvlist_lookup_string(child[c],
13921195e687SMark J Musante ZPOOL_CONFIG_PATH, &path) == 0);
13931195e687SMark J Musante if ((type = is_grouping(path, &min, &max)) != NULL) {
13941195e687SMark J Musante (void) fprintf(stderr, gettext("Cannot use "
13951195e687SMark J Musante "'%s' as a device for splitting\n"), type);
13961195e687SMark J Musante nvlist_free(newroot);
13971195e687SMark J Musante return (NULL);
13981195e687SMark J Musante }
13991195e687SMark J Musante }
14001195e687SMark J Musante }
14011195e687SMark J Musante
14021195e687SMark J Musante if (zpool_vdev_split(zhp, newname, &newroot, props, flags) != 0) {
14031195e687SMark J Musante if (newroot != NULL)
14041195e687SMark J Musante nvlist_free(newroot);
14051195e687SMark J Musante return (NULL);
14061195e687SMark J Musante }
14071195e687SMark J Musante
14081195e687SMark J Musante return (newroot);
14091195e687SMark J Musante }
14108488aeb5Staylor
1411fa9e4066Sahrens /*
1412fa9e4066Sahrens * Get and validate the contents of the given vdev specification. This ensures
1413fa9e4066Sahrens * that the nvlist returned is well-formed, that all the devices exist, and that
1414fa9e4066Sahrens * they are not currently in use by any other known consumer. The 'poolconfig'
1415fa9e4066Sahrens * parameter is the current configuration of the pool when adding devices
1416fa9e4066Sahrens * existing pool, and is used to perform additional checks, such as changing the
1417fa9e4066Sahrens * replication level of the pool. It can be 'NULL' to indicate that this is a
1418fa9e4066Sahrens * new pool. The 'force' flag controls whether devices should be forcefully
1419fa9e4066Sahrens * added, even if they appear in use.
1420fa9e4066Sahrens */
1421fa9e4066Sahrens nvlist_t *
make_root_vdev(zpool_handle_t * zhp,int force,int check_rep,boolean_t replacing,boolean_t dryrun,int argc,char ** argv)14228488aeb5Staylor make_root_vdev(zpool_handle_t *zhp, int force, int check_rep,
14233f9d6ad7SLin Ling boolean_t replacing, boolean_t dryrun, int argc, char **argv)
1424fa9e4066Sahrens {
1425fa9e4066Sahrens nvlist_t *newroot;
14268488aeb5Staylor nvlist_t *poolconfig = NULL;
1427fa9e4066Sahrens is_force = force;
1428fa9e4066Sahrens
1429fa9e4066Sahrens /*
1430fa9e4066Sahrens * Construct the vdev specification. If this is successful, we know
1431fa9e4066Sahrens * that we have a valid specification, and that all devices can be
1432fa9e4066Sahrens * opened.
1433fa9e4066Sahrens */
1434fa9e4066Sahrens if ((newroot = construct_spec(argc, argv)) == NULL)
1435fa9e4066Sahrens return (NULL);
1436fa9e4066Sahrens
14378488aeb5Staylor if (zhp && ((poolconfig = zpool_get_config(zhp, NULL)) == NULL))
14388488aeb5Staylor return (NULL);
14398488aeb5Staylor
1440fa9e4066Sahrens /*
1441fa9e4066Sahrens * Validate each device to make sure that its not shared with another
1442fa9e4066Sahrens * subsystem. We do this even if 'force' is set, because there are some
1443fa9e4066Sahrens * uses (such as a dedicated dump device) that even '-f' cannot
1444fa9e4066Sahrens * override.
1445fa9e4066Sahrens */
1446*09933095SBasil Crow if (is_device_in_use(poolconfig, newroot, force, replacing, B_FALSE)) {
1447fa9e4066Sahrens nvlist_free(newroot);
1448fa9e4066Sahrens return (NULL);
1449fa9e4066Sahrens }
1450fa9e4066Sahrens
1451fa9e4066Sahrens /*
1452fa9e4066Sahrens * Check the replication level of the given vdevs and report any errors
1453fa9e4066Sahrens * found. We include the existing pool spec, if any, as we need to
1454fa9e4066Sahrens * catch changes against the existing replication level.
1455fa9e4066Sahrens */
1456fa9e4066Sahrens if (check_rep && check_replication(poolconfig, newroot) != 0) {
1457fa9e4066Sahrens nvlist_free(newroot);
1458fa9e4066Sahrens return (NULL);
1459fa9e4066Sahrens }
1460fa9e4066Sahrens
1461fa9e4066Sahrens /*
1462fa9e4066Sahrens * Run through the vdev specification and label any whole disks found.
1463fa9e4066Sahrens */
1464705040edSEric Taylor if (!dryrun && make_disks(zhp, newroot) != 0) {
1465fa9e4066Sahrens nvlist_free(newroot);
1466fa9e4066Sahrens return (NULL);
1467fa9e4066Sahrens }
1468fa9e4066Sahrens
1469fa9e4066Sahrens return (newroot);
1470fa9e4066Sahrens }
1471