xref: /illumos-gate/usr/src/lib/libzfs/common/libzfs_import.c (revision 0d166b18feda26f6f45f5be1c0c8c5e539b90e6c)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * Pool import support functions.
28  *
29  * To import a pool, we rely on reading the configuration information from the
30  * ZFS label of each device.  If we successfully read the label, then we
31  * organize the configuration information in the following hierarchy:
32  *
33  * 	pool guid -> toplevel vdev guid -> label txg
34  *
35  * Duplicate entries matching this same tuple will be discarded.  Once we have
36  * examined every device, we pick the best label txg config for each toplevel
37  * vdev.  We then arrange these toplevel vdevs into a complete pool config, and
38  * update any paths that have changed.  Finally, we attempt to import the pool
39  * using our derived config, and record the results.
40  */
41 
42 #include <ctype.h>
43 #include <devid.h>
44 #include <dirent.h>
45 #include <errno.h>
46 #include <libintl.h>
47 #include <stddef.h>
48 #include <stdlib.h>
49 #include <string.h>
50 #include <sys/stat.h>
51 #include <unistd.h>
52 #include <fcntl.h>
53 #include <sys/vtoc.h>
54 #include <sys/dktp/fdisk.h>
55 #include <sys/efi_partition.h>
56 #include <thread_pool.h>
57 
58 #include <sys/vdev_impl.h>
59 
60 #include "libzfs.h"
61 #include "libzfs_impl.h"
62 
63 /*
64  * Intermediate structures used to gather configuration information.
65  */
66 typedef struct config_entry {
67 	uint64_t		ce_txg;
68 	nvlist_t		*ce_config;
69 	struct config_entry	*ce_next;
70 } config_entry_t;
71 
72 typedef struct vdev_entry {
73 	uint64_t		ve_guid;
74 	config_entry_t		*ve_configs;
75 	struct vdev_entry	*ve_next;
76 } vdev_entry_t;
77 
78 typedef struct pool_entry {
79 	uint64_t		pe_guid;
80 	vdev_entry_t		*pe_vdevs;
81 	struct pool_entry	*pe_next;
82 } pool_entry_t;
83 
84 typedef struct name_entry {
85 	char			*ne_name;
86 	uint64_t		ne_guid;
87 	struct name_entry	*ne_next;
88 } name_entry_t;
89 
90 typedef struct pool_list {
91 	pool_entry_t		*pools;
92 	name_entry_t		*names;
93 } pool_list_t;
94 
95 static char *
96 get_devid(const char *path)
97 {
98 	int fd;
99 	ddi_devid_t devid;
100 	char *minor, *ret;
101 
102 	if ((fd = open(path, O_RDONLY)) < 0)
103 		return (NULL);
104 
105 	minor = NULL;
106 	ret = NULL;
107 	if (devid_get(fd, &devid) == 0) {
108 		if (devid_get_minor_name(fd, &minor) == 0)
109 			ret = devid_str_encode(devid, minor);
110 		if (minor != NULL)
111 			devid_str_free(minor);
112 		devid_free(devid);
113 	}
114 	(void) close(fd);
115 
116 	return (ret);
117 }
118 
119 
120 /*
121  * Go through and fix up any path and/or devid information for the given vdev
122  * configuration.
123  */
124 static int
125 fix_paths(nvlist_t *nv, name_entry_t *names)
126 {
127 	nvlist_t **child;
128 	uint_t c, children;
129 	uint64_t guid;
130 	name_entry_t *ne, *best;
131 	char *path, *devid;
132 	int matched;
133 
134 	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
135 	    &child, &children) == 0) {
136 		for (c = 0; c < children; c++)
137 			if (fix_paths(child[c], names) != 0)
138 				return (-1);
139 		return (0);
140 	}
141 
142 	/*
143 	 * This is a leaf (file or disk) vdev.  In either case, go through
144 	 * the name list and see if we find a matching guid.  If so, replace
145 	 * the path and see if we can calculate a new devid.
146 	 *
147 	 * There may be multiple names associated with a particular guid, in
148 	 * which case we have overlapping slices or multiple paths to the same
149 	 * disk.  If this is the case, then we want to pick the path that is
150 	 * the most similar to the original, where "most similar" is the number
151 	 * of matching characters starting from the end of the path.  This will
152 	 * preserve slice numbers even if the disks have been reorganized, and
153 	 * will also catch preferred disk names if multiple paths exist.
154 	 */
155 	verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) == 0);
156 	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) != 0)
157 		path = NULL;
158 
159 	matched = 0;
160 	best = NULL;
161 	for (ne = names; ne != NULL; ne = ne->ne_next) {
162 		if (ne->ne_guid == guid) {
163 			const char *src, *dst;
164 			int count;
165 
166 			if (path == NULL) {
167 				best = ne;
168 				break;
169 			}
170 
171 			src = ne->ne_name + strlen(ne->ne_name) - 1;
172 			dst = path + strlen(path) - 1;
173 			for (count = 0; src >= ne->ne_name && dst >= path;
174 			    src--, dst--, count++)
175 				if (*src != *dst)
176 					break;
177 
178 			/*
179 			 * At this point, 'count' is the number of characters
180 			 * matched from the end.
181 			 */
182 			if (count > matched || best == NULL) {
183 				best = ne;
184 				matched = count;
185 			}
186 		}
187 	}
188 
189 	if (best == NULL)
190 		return (0);
191 
192 	if (nvlist_add_string(nv, ZPOOL_CONFIG_PATH, best->ne_name) != 0)
193 		return (-1);
194 
195 	if ((devid = get_devid(best->ne_name)) == NULL) {
196 		(void) nvlist_remove_all(nv, ZPOOL_CONFIG_DEVID);
197 	} else {
198 		if (nvlist_add_string(nv, ZPOOL_CONFIG_DEVID, devid) != 0)
199 			return (-1);
200 		devid_str_free(devid);
201 	}
202 
203 	return (0);
204 }
205 
206 /*
207  * Add the given configuration to the list of known devices.
208  */
209 static int
210 add_config(libzfs_handle_t *hdl, pool_list_t *pl, const char *path,
211     nvlist_t *config)
212 {
213 	uint64_t pool_guid, vdev_guid, top_guid, txg, state;
214 	pool_entry_t *pe;
215 	vdev_entry_t *ve;
216 	config_entry_t *ce;
217 	name_entry_t *ne;
218 
219 	/*
220 	 * If this is a hot spare not currently in use or level 2 cache
221 	 * device, add it to the list of names to translate, but don't do
222 	 * anything else.
223 	 */
224 	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
225 	    &state) == 0 &&
226 	    (state == POOL_STATE_SPARE || state == POOL_STATE_L2CACHE) &&
227 	    nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID, &vdev_guid) == 0) {
228 		if ((ne = zfs_alloc(hdl, sizeof (name_entry_t))) == NULL)
229 			return (-1);
230 
231 		if ((ne->ne_name = zfs_strdup(hdl, path)) == NULL) {
232 			free(ne);
233 			return (-1);
234 		}
235 		ne->ne_guid = vdev_guid;
236 		ne->ne_next = pl->names;
237 		pl->names = ne;
238 		return (0);
239 	}
240 
241 	/*
242 	 * If we have a valid config but cannot read any of these fields, then
243 	 * it means we have a half-initialized label.  In vdev_label_init()
244 	 * we write a label with txg == 0 so that we can identify the device
245 	 * in case the user refers to the same disk later on.  If we fail to
246 	 * create the pool, we'll be left with a label in this state
247 	 * which should not be considered part of a valid pool.
248 	 */
249 	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
250 	    &pool_guid) != 0 ||
251 	    nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID,
252 	    &vdev_guid) != 0 ||
253 	    nvlist_lookup_uint64(config, ZPOOL_CONFIG_TOP_GUID,
254 	    &top_guid) != 0 ||
255 	    nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG,
256 	    &txg) != 0 || txg == 0) {
257 		nvlist_free(config);
258 		return (0);
259 	}
260 
261 	/*
262 	 * First, see if we know about this pool.  If not, then add it to the
263 	 * list of known pools.
264 	 */
265 	for (pe = pl->pools; pe != NULL; pe = pe->pe_next) {
266 		if (pe->pe_guid == pool_guid)
267 			break;
268 	}
269 
270 	if (pe == NULL) {
271 		if ((pe = zfs_alloc(hdl, sizeof (pool_entry_t))) == NULL) {
272 			nvlist_free(config);
273 			return (-1);
274 		}
275 		pe->pe_guid = pool_guid;
276 		pe->pe_next = pl->pools;
277 		pl->pools = pe;
278 	}
279 
280 	/*
281 	 * Second, see if we know about this toplevel vdev.  Add it if its
282 	 * missing.
283 	 */
284 	for (ve = pe->pe_vdevs; ve != NULL; ve = ve->ve_next) {
285 		if (ve->ve_guid == top_guid)
286 			break;
287 	}
288 
289 	if (ve == NULL) {
290 		if ((ve = zfs_alloc(hdl, sizeof (vdev_entry_t))) == NULL) {
291 			nvlist_free(config);
292 			return (-1);
293 		}
294 		ve->ve_guid = top_guid;
295 		ve->ve_next = pe->pe_vdevs;
296 		pe->pe_vdevs = ve;
297 	}
298 
299 	/*
300 	 * Third, see if we have a config with a matching transaction group.  If
301 	 * so, then we do nothing.  Otherwise, add it to the list of known
302 	 * configs.
303 	 */
304 	for (ce = ve->ve_configs; ce != NULL; ce = ce->ce_next) {
305 		if (ce->ce_txg == txg)
306 			break;
307 	}
308 
309 	if (ce == NULL) {
310 		if ((ce = zfs_alloc(hdl, sizeof (config_entry_t))) == NULL) {
311 			nvlist_free(config);
312 			return (-1);
313 		}
314 		ce->ce_txg = txg;
315 		ce->ce_config = config;
316 		ce->ce_next = ve->ve_configs;
317 		ve->ve_configs = ce;
318 	} else {
319 		nvlist_free(config);
320 	}
321 
322 	/*
323 	 * At this point we've successfully added our config to the list of
324 	 * known configs.  The last thing to do is add the vdev guid -> path
325 	 * mappings so that we can fix up the configuration as necessary before
326 	 * doing the import.
327 	 */
328 	if ((ne = zfs_alloc(hdl, sizeof (name_entry_t))) == NULL)
329 		return (-1);
330 
331 	if ((ne->ne_name = zfs_strdup(hdl, path)) == NULL) {
332 		free(ne);
333 		return (-1);
334 	}
335 
336 	ne->ne_guid = vdev_guid;
337 	ne->ne_next = pl->names;
338 	pl->names = ne;
339 
340 	return (0);
341 }
342 
343 /*
344  * Returns true if the named pool matches the given GUID.
345  */
346 static int
347 pool_active(libzfs_handle_t *hdl, const char *name, uint64_t guid,
348     boolean_t *isactive)
349 {
350 	zpool_handle_t *zhp;
351 	uint64_t theguid;
352 
353 	if (zpool_open_silent(hdl, name, &zhp) != 0)
354 		return (-1);
355 
356 	if (zhp == NULL) {
357 		*isactive = B_FALSE;
358 		return (0);
359 	}
360 
361 	verify(nvlist_lookup_uint64(zhp->zpool_config, ZPOOL_CONFIG_POOL_GUID,
362 	    &theguid) == 0);
363 
364 	zpool_close(zhp);
365 
366 	*isactive = (theguid == guid);
367 	return (0);
368 }
369 
370 static nvlist_t *
371 refresh_config(libzfs_handle_t *hdl, nvlist_t *config)
372 {
373 	nvlist_t *nvl;
374 	zfs_cmd_t zc = { 0 };
375 	int err;
376 
377 	if (zcmd_write_conf_nvlist(hdl, &zc, config) != 0)
378 		return (NULL);
379 
380 	if (zcmd_alloc_dst_nvlist(hdl, &zc,
381 	    zc.zc_nvlist_conf_size * 2) != 0) {
382 		zcmd_free_nvlists(&zc);
383 		return (NULL);
384 	}
385 
386 	while ((err = ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_TRYIMPORT,
387 	    &zc)) != 0 && errno == ENOMEM) {
388 		if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
389 			zcmd_free_nvlists(&zc);
390 			return (NULL);
391 		}
392 	}
393 
394 	if (err) {
395 		zcmd_free_nvlists(&zc);
396 		return (NULL);
397 	}
398 
399 	if (zcmd_read_dst_nvlist(hdl, &zc, &nvl) != 0) {
400 		zcmd_free_nvlists(&zc);
401 		return (NULL);
402 	}
403 
404 	zcmd_free_nvlists(&zc);
405 	return (nvl);
406 }
407 
408 /*
409  * Determine if the vdev id is a hole in the namespace.
410  */
411 boolean_t
412 vdev_is_hole(uint64_t *hole_array, uint_t holes, uint_t id)
413 {
414 	for (int c = 0; c < holes; c++) {
415 
416 		/* Top-level is a hole */
417 		if (hole_array[c] == id)
418 			return (B_TRUE);
419 	}
420 	return (B_FALSE);
421 }
422 
423 /*
424  * Convert our list of pools into the definitive set of configurations.  We
425  * start by picking the best config for each toplevel vdev.  Once that's done,
426  * we assemble the toplevel vdevs into a full config for the pool.  We make a
427  * pass to fix up any incorrect paths, and then add it to the main list to
428  * return to the user.
429  */
430 static nvlist_t *
431 get_configs(libzfs_handle_t *hdl, pool_list_t *pl, boolean_t active_ok)
432 {
433 	pool_entry_t *pe;
434 	vdev_entry_t *ve;
435 	config_entry_t *ce;
436 	nvlist_t *ret = NULL, *config = NULL, *tmp, *nvtop, *nvroot;
437 	nvlist_t **spares, **l2cache;
438 	uint_t i, nspares, nl2cache;
439 	boolean_t config_seen;
440 	uint64_t best_txg;
441 	char *name, *hostname;
442 	uint64_t version, guid;
443 	uint_t children = 0;
444 	nvlist_t **child = NULL;
445 	uint_t holes;
446 	uint64_t *hole_array, max_id;
447 	uint_t c;
448 	boolean_t isactive;
449 	uint64_t hostid;
450 	nvlist_t *nvl;
451 	boolean_t found_one = B_FALSE;
452 	boolean_t valid_top_config = B_FALSE;
453 
454 	if (nvlist_alloc(&ret, 0, 0) != 0)
455 		goto nomem;
456 
457 	for (pe = pl->pools; pe != NULL; pe = pe->pe_next) {
458 		uint64_t id, max_txg = 0;
459 
460 		if (nvlist_alloc(&config, NV_UNIQUE_NAME, 0) != 0)
461 			goto nomem;
462 		config_seen = B_FALSE;
463 
464 		/*
465 		 * Iterate over all toplevel vdevs.  Grab the pool configuration
466 		 * from the first one we find, and then go through the rest and
467 		 * add them as necessary to the 'vdevs' member of the config.
468 		 */
469 		for (ve = pe->pe_vdevs; ve != NULL; ve = ve->ve_next) {
470 
471 			/*
472 			 * Determine the best configuration for this vdev by
473 			 * selecting the config with the latest transaction
474 			 * group.
475 			 */
476 			best_txg = 0;
477 			for (ce = ve->ve_configs; ce != NULL;
478 			    ce = ce->ce_next) {
479 
480 				if (ce->ce_txg > best_txg) {
481 					tmp = ce->ce_config;
482 					best_txg = ce->ce_txg;
483 				}
484 			}
485 
486 			/*
487 			 * We rely on the fact that the max txg for the
488 			 * pool will contain the most up-to-date information
489 			 * about the valid top-levels in the vdev namespace.
490 			 */
491 			if (best_txg > max_txg) {
492 				(void) nvlist_remove(config,
493 				    ZPOOL_CONFIG_VDEV_CHILDREN,
494 				    DATA_TYPE_UINT64);
495 				(void) nvlist_remove(config,
496 				    ZPOOL_CONFIG_HOLE_ARRAY,
497 				    DATA_TYPE_UINT64_ARRAY);
498 
499 				max_txg = best_txg;
500 				hole_array = NULL;
501 				holes = 0;
502 				max_id = 0;
503 				valid_top_config = B_FALSE;
504 
505 				if (nvlist_lookup_uint64(tmp,
506 				    ZPOOL_CONFIG_VDEV_CHILDREN, &max_id) == 0) {
507 					verify(nvlist_add_uint64(config,
508 					    ZPOOL_CONFIG_VDEV_CHILDREN,
509 					    max_id) == 0);
510 					valid_top_config = B_TRUE;
511 				}
512 
513 				if (nvlist_lookup_uint64_array(tmp,
514 				    ZPOOL_CONFIG_HOLE_ARRAY, &hole_array,
515 				    &holes) == 0) {
516 					verify(nvlist_add_uint64_array(config,
517 					    ZPOOL_CONFIG_HOLE_ARRAY,
518 					    hole_array, holes) == 0);
519 				}
520 			}
521 
522 			if (!config_seen) {
523 				/*
524 				 * Copy the relevant pieces of data to the pool
525 				 * configuration:
526 				 *
527 				 *	version
528 				 * 	pool guid
529 				 * 	name
530 				 * 	pool state
531 				 *	hostid (if available)
532 				 *	hostname (if available)
533 				 */
534 				uint64_t state;
535 
536 				verify(nvlist_lookup_uint64(tmp,
537 				    ZPOOL_CONFIG_VERSION, &version) == 0);
538 				if (nvlist_add_uint64(config,
539 				    ZPOOL_CONFIG_VERSION, version) != 0)
540 					goto nomem;
541 				verify(nvlist_lookup_uint64(tmp,
542 				    ZPOOL_CONFIG_POOL_GUID, &guid) == 0);
543 				if (nvlist_add_uint64(config,
544 				    ZPOOL_CONFIG_POOL_GUID, guid) != 0)
545 					goto nomem;
546 				verify(nvlist_lookup_string(tmp,
547 				    ZPOOL_CONFIG_POOL_NAME, &name) == 0);
548 				if (nvlist_add_string(config,
549 				    ZPOOL_CONFIG_POOL_NAME, name) != 0)
550 					goto nomem;
551 				verify(nvlist_lookup_uint64(tmp,
552 				    ZPOOL_CONFIG_POOL_STATE, &state) == 0);
553 				if (nvlist_add_uint64(config,
554 				    ZPOOL_CONFIG_POOL_STATE, state) != 0)
555 					goto nomem;
556 				hostid = 0;
557 				if (nvlist_lookup_uint64(tmp,
558 				    ZPOOL_CONFIG_HOSTID, &hostid) == 0) {
559 					if (nvlist_add_uint64(config,
560 					    ZPOOL_CONFIG_HOSTID, hostid) != 0)
561 						goto nomem;
562 					verify(nvlist_lookup_string(tmp,
563 					    ZPOOL_CONFIG_HOSTNAME,
564 					    &hostname) == 0);
565 					if (nvlist_add_string(config,
566 					    ZPOOL_CONFIG_HOSTNAME,
567 					    hostname) != 0)
568 						goto nomem;
569 				}
570 
571 				config_seen = B_TRUE;
572 			}
573 
574 			/*
575 			 * Add this top-level vdev to the child array.
576 			 */
577 			verify(nvlist_lookup_nvlist(tmp,
578 			    ZPOOL_CONFIG_VDEV_TREE, &nvtop) == 0);
579 			verify(nvlist_lookup_uint64(nvtop, ZPOOL_CONFIG_ID,
580 			    &id) == 0);
581 
582 			if (id >= children) {
583 				nvlist_t **newchild;
584 
585 				newchild = zfs_alloc(hdl, (id + 1) *
586 				    sizeof (nvlist_t *));
587 				if (newchild == NULL)
588 					goto nomem;
589 
590 				for (c = 0; c < children; c++)
591 					newchild[c] = child[c];
592 
593 				free(child);
594 				child = newchild;
595 				children = id + 1;
596 			}
597 			if (nvlist_dup(nvtop, &child[id], 0) != 0)
598 				goto nomem;
599 
600 		}
601 
602 		/*
603 		 * If we have information about all the top-levels then
604 		 * clean up the nvlist which we've constructed. This
605 		 * means removing any extraneous devices that are
606 		 * beyond the valid range or adding devices to the end
607 		 * of our array which appear to be missing.
608 		 */
609 		if (valid_top_config) {
610 			if (max_id < children) {
611 				for (c = max_id; c < children; c++)
612 					nvlist_free(child[c]);
613 				children = max_id;
614 			} else if (max_id > children) {
615 				nvlist_t **newchild;
616 
617 				newchild = zfs_alloc(hdl, (max_id) *
618 				    sizeof (nvlist_t *));
619 				if (newchild == NULL)
620 					goto nomem;
621 
622 				for (c = 0; c < children; c++)
623 					newchild[c] = child[c];
624 
625 				free(child);
626 				child = newchild;
627 				children = max_id;
628 			}
629 		}
630 
631 		verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
632 		    &guid) == 0);
633 
634 		/*
635 		 * The vdev namespace may contain holes as a result of
636 		 * device removal. We must add them back into the vdev
637 		 * tree before we process any missing devices.
638 		 */
639 		if (holes > 0) {
640 			ASSERT(valid_top_config);
641 
642 			for (c = 0; c < children; c++) {
643 				nvlist_t *holey;
644 
645 				if (child[c] != NULL ||
646 				    !vdev_is_hole(hole_array, holes, c))
647 					continue;
648 
649 				if (nvlist_alloc(&holey, NV_UNIQUE_NAME,
650 				    0) != 0)
651 					goto nomem;
652 
653 				/*
654 				 * Holes in the namespace are treated as
655 				 * "hole" top-level vdevs and have a
656 				 * special flag set on them.
657 				 */
658 				if (nvlist_add_string(holey,
659 				    ZPOOL_CONFIG_TYPE,
660 				    VDEV_TYPE_HOLE) != 0 ||
661 				    nvlist_add_uint64(holey,
662 				    ZPOOL_CONFIG_ID, c) != 0 ||
663 				    nvlist_add_uint64(holey,
664 				    ZPOOL_CONFIG_GUID, 0ULL) != 0)
665 					goto nomem;
666 				child[c] = holey;
667 			}
668 		}
669 
670 		/*
671 		 * Look for any missing top-level vdevs.  If this is the case,
672 		 * create a faked up 'missing' vdev as a placeholder.  We cannot
673 		 * simply compress the child array, because the kernel performs
674 		 * certain checks to make sure the vdev IDs match their location
675 		 * in the configuration.
676 		 */
677 		for (c = 0; c < children; c++) {
678 			if (child[c] == NULL) {
679 				nvlist_t *missing;
680 				if (nvlist_alloc(&missing, NV_UNIQUE_NAME,
681 				    0) != 0)
682 					goto nomem;
683 				if (nvlist_add_string(missing,
684 				    ZPOOL_CONFIG_TYPE,
685 				    VDEV_TYPE_MISSING) != 0 ||
686 				    nvlist_add_uint64(missing,
687 				    ZPOOL_CONFIG_ID, c) != 0 ||
688 				    nvlist_add_uint64(missing,
689 				    ZPOOL_CONFIG_GUID, 0ULL) != 0) {
690 					nvlist_free(missing);
691 					goto nomem;
692 				}
693 				child[c] = missing;
694 			}
695 		}
696 
697 		/*
698 		 * Put all of this pool's top-level vdevs into a root vdev.
699 		 */
700 		if (nvlist_alloc(&nvroot, NV_UNIQUE_NAME, 0) != 0)
701 			goto nomem;
702 		if (nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE,
703 		    VDEV_TYPE_ROOT) != 0 ||
704 		    nvlist_add_uint64(nvroot, ZPOOL_CONFIG_ID, 0ULL) != 0 ||
705 		    nvlist_add_uint64(nvroot, ZPOOL_CONFIG_GUID, guid) != 0 ||
706 		    nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
707 		    child, children) != 0) {
708 			nvlist_free(nvroot);
709 			goto nomem;
710 		}
711 
712 		for (c = 0; c < children; c++)
713 			nvlist_free(child[c]);
714 		free(child);
715 		children = 0;
716 		child = NULL;
717 
718 		/*
719 		 * Go through and fix up any paths and/or devids based on our
720 		 * known list of vdev GUID -> path mappings.
721 		 */
722 		if (fix_paths(nvroot, pl->names) != 0) {
723 			nvlist_free(nvroot);
724 			goto nomem;
725 		}
726 
727 		/*
728 		 * Add the root vdev to this pool's configuration.
729 		 */
730 		if (nvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
731 		    nvroot) != 0) {
732 			nvlist_free(nvroot);
733 			goto nomem;
734 		}
735 		nvlist_free(nvroot);
736 
737 		/*
738 		 * zdb uses this path to report on active pools that were
739 		 * imported or created using -R.
740 		 */
741 		if (active_ok)
742 			goto add_pool;
743 
744 		/*
745 		 * Determine if this pool is currently active, in which case we
746 		 * can't actually import it.
747 		 */
748 		verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
749 		    &name) == 0);
750 		verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
751 		    &guid) == 0);
752 
753 		if (pool_active(hdl, name, guid, &isactive) != 0)
754 			goto error;
755 
756 		if (isactive) {
757 			nvlist_free(config);
758 			config = NULL;
759 			continue;
760 		}
761 
762 		if ((nvl = refresh_config(hdl, config)) == NULL) {
763 			nvlist_free(config);
764 			config = NULL;
765 			continue;
766 		}
767 
768 		nvlist_free(config);
769 		config = nvl;
770 
771 		/*
772 		 * Go through and update the paths for spares, now that we have
773 		 * them.
774 		 */
775 		verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
776 		    &nvroot) == 0);
777 		if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
778 		    &spares, &nspares) == 0) {
779 			for (i = 0; i < nspares; i++) {
780 				if (fix_paths(spares[i], pl->names) != 0)
781 					goto nomem;
782 			}
783 		}
784 
785 		/*
786 		 * Update the paths for l2cache devices.
787 		 */
788 		if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
789 		    &l2cache, &nl2cache) == 0) {
790 			for (i = 0; i < nl2cache; i++) {
791 				if (fix_paths(l2cache[i], pl->names) != 0)
792 					goto nomem;
793 			}
794 		}
795 
796 		/*
797 		 * Restore the original information read from the actual label.
798 		 */
799 		(void) nvlist_remove(config, ZPOOL_CONFIG_HOSTID,
800 		    DATA_TYPE_UINT64);
801 		(void) nvlist_remove(config, ZPOOL_CONFIG_HOSTNAME,
802 		    DATA_TYPE_STRING);
803 		if (hostid != 0) {
804 			verify(nvlist_add_uint64(config, ZPOOL_CONFIG_HOSTID,
805 			    hostid) == 0);
806 			verify(nvlist_add_string(config, ZPOOL_CONFIG_HOSTNAME,
807 			    hostname) == 0);
808 		}
809 
810 add_pool:
811 		/*
812 		 * Add this pool to the list of configs.
813 		 */
814 		verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
815 		    &name) == 0);
816 		if (nvlist_add_nvlist(ret, name, config) != 0)
817 			goto nomem;
818 
819 		found_one = B_TRUE;
820 		nvlist_free(config);
821 		config = NULL;
822 	}
823 
824 	if (!found_one) {
825 		nvlist_free(ret);
826 		ret = NULL;
827 	}
828 
829 	return (ret);
830 
831 nomem:
832 	(void) no_memory(hdl);
833 error:
834 	nvlist_free(config);
835 	nvlist_free(ret);
836 	for (c = 0; c < children; c++)
837 		nvlist_free(child[c]);
838 	free(child);
839 
840 	return (NULL);
841 }
842 
843 /*
844  * Return the offset of the given label.
845  */
846 static uint64_t
847 label_offset(uint64_t size, int l)
848 {
849 	ASSERT(P2PHASE_TYPED(size, sizeof (vdev_label_t), uint64_t) == 0);
850 	return (l * sizeof (vdev_label_t) + (l < VDEV_LABELS / 2 ?
851 	    0 : size - VDEV_LABELS * sizeof (vdev_label_t)));
852 }
853 
854 /*
855  * Given a file descriptor, read the label information and return an nvlist
856  * describing the configuration, if there is one.
857  */
858 int
859 zpool_read_label(int fd, nvlist_t **config)
860 {
861 	struct stat64 statbuf;
862 	int l;
863 	vdev_label_t *label;
864 	uint64_t state, txg, size;
865 
866 	*config = NULL;
867 
868 	if (fstat64(fd, &statbuf) == -1)
869 		return (0);
870 	size = P2ALIGN_TYPED(statbuf.st_size, sizeof (vdev_label_t), uint64_t);
871 
872 	if ((label = malloc(sizeof (vdev_label_t))) == NULL)
873 		return (-1);
874 
875 	for (l = 0; l < VDEV_LABELS; l++) {
876 		if (pread64(fd, label, sizeof (vdev_label_t),
877 		    label_offset(size, l)) != sizeof (vdev_label_t))
878 			continue;
879 
880 		if (nvlist_unpack(label->vl_vdev_phys.vp_nvlist,
881 		    sizeof (label->vl_vdev_phys.vp_nvlist), config, 0) != 0)
882 			continue;
883 
884 		if (nvlist_lookup_uint64(*config, ZPOOL_CONFIG_POOL_STATE,
885 		    &state) != 0 || state > POOL_STATE_L2CACHE) {
886 			nvlist_free(*config);
887 			continue;
888 		}
889 
890 		if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
891 		    (nvlist_lookup_uint64(*config, ZPOOL_CONFIG_POOL_TXG,
892 		    &txg) != 0 || txg == 0)) {
893 			nvlist_free(*config);
894 			continue;
895 		}
896 
897 		free(label);
898 		return (0);
899 	}
900 
901 	free(label);
902 	*config = NULL;
903 	return (0);
904 }
905 
906 typedef struct rdsk_node {
907 	char *rn_name;
908 	int rn_dfd;
909 	libzfs_handle_t *rn_hdl;
910 	nvlist_t *rn_config;
911 	avl_tree_t *rn_avl;
912 	avl_node_t rn_node;
913 	boolean_t rn_nozpool;
914 } rdsk_node_t;
915 
916 static int
917 slice_cache_compare(const void *arg1, const void *arg2)
918 {
919 	const char  *nm1 = ((rdsk_node_t *)arg1)->rn_name;
920 	const char  *nm2 = ((rdsk_node_t *)arg2)->rn_name;
921 	char *nm1slice, *nm2slice;
922 	int rv;
923 
924 	/*
925 	 * slices zero and two are the most likely to provide results,
926 	 * so put those first
927 	 */
928 	nm1slice = strstr(nm1, "s0");
929 	nm2slice = strstr(nm2, "s0");
930 	if (nm1slice && !nm2slice) {
931 		return (-1);
932 	}
933 	if (!nm1slice && nm2slice) {
934 		return (1);
935 	}
936 	nm1slice = strstr(nm1, "s2");
937 	nm2slice = strstr(nm2, "s2");
938 	if (nm1slice && !nm2slice) {
939 		return (-1);
940 	}
941 	if (!nm1slice && nm2slice) {
942 		return (1);
943 	}
944 
945 	rv = strcmp(nm1, nm2);
946 	if (rv == 0)
947 		return (0);
948 	return (rv > 0 ? 1 : -1);
949 }
950 
951 static void
952 check_one_slice(avl_tree_t *r, char *diskname, uint_t partno,
953     diskaddr_t size, uint_t blksz)
954 {
955 	rdsk_node_t tmpnode;
956 	rdsk_node_t *node;
957 	char sname[MAXNAMELEN];
958 
959 	tmpnode.rn_name = &sname[0];
960 	(void) snprintf(tmpnode.rn_name, MAXNAMELEN, "%s%u",
961 	    diskname, partno);
962 	/*
963 	 * protect against division by zero for disk labels that
964 	 * contain a bogus sector size
965 	 */
966 	if (blksz == 0)
967 		blksz = DEV_BSIZE;
968 	/* too small to contain a zpool? */
969 	if ((size < (SPA_MINDEVSIZE / blksz)) &&
970 	    (node = avl_find(r, &tmpnode, NULL)))
971 		node->rn_nozpool = B_TRUE;
972 }
973 
974 static void
975 nozpool_all_slices(avl_tree_t *r, const char *sname)
976 {
977 	char diskname[MAXNAMELEN];
978 	char *ptr;
979 	int i;
980 
981 	(void) strncpy(diskname, sname, MAXNAMELEN);
982 	if (((ptr = strrchr(diskname, 's')) == NULL) &&
983 	    ((ptr = strrchr(diskname, 'p')) == NULL))
984 		return;
985 	ptr[0] = 's';
986 	ptr[1] = '\0';
987 	for (i = 0; i < NDKMAP; i++)
988 		check_one_slice(r, diskname, i, 0, 1);
989 	ptr[0] = 'p';
990 	for (i = 0; i <= FD_NUMPART; i++)
991 		check_one_slice(r, diskname, i, 0, 1);
992 }
993 
994 static void
995 check_slices(avl_tree_t *r, int fd, const char *sname)
996 {
997 	struct extvtoc vtoc;
998 	struct dk_gpt *gpt;
999 	char diskname[MAXNAMELEN];
1000 	char *ptr;
1001 	int i;
1002 
1003 	(void) strncpy(diskname, sname, MAXNAMELEN);
1004 	if ((ptr = strrchr(diskname, 's')) == NULL || !isdigit(ptr[1]))
1005 		return;
1006 	ptr[1] = '\0';
1007 
1008 	if (read_extvtoc(fd, &vtoc) >= 0) {
1009 		for (i = 0; i < NDKMAP; i++)
1010 			check_one_slice(r, diskname, i,
1011 			    vtoc.v_part[i].p_size, vtoc.v_sectorsz);
1012 	} else if (efi_alloc_and_read(fd, &gpt) >= 0) {
1013 		/*
1014 		 * on x86 we'll still have leftover links that point
1015 		 * to slices s[9-15], so use NDKMAP instead
1016 		 */
1017 		for (i = 0; i < NDKMAP; i++)
1018 			check_one_slice(r, diskname, i,
1019 			    gpt->efi_parts[i].p_size, gpt->efi_lbasize);
1020 		/* nodes p[1-4] are never used with EFI labels */
1021 		ptr[0] = 'p';
1022 		for (i = 1; i <= FD_NUMPART; i++)
1023 			check_one_slice(r, diskname, i, 0, 1);
1024 		efi_free(gpt);
1025 	}
1026 }
1027 
1028 static void
1029 zpool_open_func(void *arg)
1030 {
1031 	rdsk_node_t *rn = arg;
1032 	struct stat64 statbuf;
1033 	nvlist_t *config;
1034 	int fd;
1035 
1036 	if (rn->rn_nozpool)
1037 		return;
1038 	if ((fd = openat64(rn->rn_dfd, rn->rn_name, O_RDONLY)) < 0) {
1039 		/* symlink to a device that's no longer there */
1040 		if (errno == ENOENT)
1041 			nozpool_all_slices(rn->rn_avl, rn->rn_name);
1042 		return;
1043 	}
1044 	/*
1045 	 * Ignore failed stats.  We only want regular
1046 	 * files, character devs and block devs.
1047 	 */
1048 	if (fstat64(fd, &statbuf) != 0 ||
1049 	    (!S_ISREG(statbuf.st_mode) &&
1050 	    !S_ISCHR(statbuf.st_mode) &&
1051 	    !S_ISBLK(statbuf.st_mode))) {
1052 		(void) close(fd);
1053 		return;
1054 	}
1055 	/* this file is too small to hold a zpool */
1056 	if (S_ISREG(statbuf.st_mode) &&
1057 	    statbuf.st_size < SPA_MINDEVSIZE) {
1058 		(void) close(fd);
1059 		return;
1060 	} else if (!S_ISREG(statbuf.st_mode)) {
1061 		/*
1062 		 * Try to read the disk label first so we don't have to
1063 		 * open a bunch of minor nodes that can't have a zpool.
1064 		 */
1065 		check_slices(rn->rn_avl, fd, rn->rn_name);
1066 	}
1067 
1068 	if ((zpool_read_label(fd, &config)) != 0) {
1069 		(void) close(fd);
1070 		(void) no_memory(rn->rn_hdl);
1071 		return;
1072 	}
1073 	(void) close(fd);
1074 
1075 
1076 	rn->rn_config = config;
1077 	if (config != NULL) {
1078 		assert(rn->rn_nozpool == B_FALSE);
1079 	}
1080 }
1081 
1082 /*
1083  * Given a file descriptor, clear (zero) the label information.  This function
1084  * is currently only used in the appliance stack as part of the ZFS sysevent
1085  * module.
1086  */
1087 int
1088 zpool_clear_label(int fd)
1089 {
1090 	struct stat64 statbuf;
1091 	int l;
1092 	vdev_label_t *label;
1093 	uint64_t size;
1094 
1095 	if (fstat64(fd, &statbuf) == -1)
1096 		return (0);
1097 	size = P2ALIGN_TYPED(statbuf.st_size, sizeof (vdev_label_t), uint64_t);
1098 
1099 	if ((label = calloc(sizeof (vdev_label_t), 1)) == NULL)
1100 		return (-1);
1101 
1102 	for (l = 0; l < VDEV_LABELS; l++) {
1103 		if (pwrite64(fd, label, sizeof (vdev_label_t),
1104 		    label_offset(size, l)) != sizeof (vdev_label_t))
1105 			return (-1);
1106 	}
1107 
1108 	free(label);
1109 	return (0);
1110 }
1111 
1112 /*
1113  * Given a list of directories to search, find all pools stored on disk.  This
1114  * includes partial pools which are not available to import.  If no args are
1115  * given (argc is 0), then the default directory (/dev/dsk) is searched.
1116  * poolname or guid (but not both) are provided by the caller when trying
1117  * to import a specific pool.
1118  */
1119 static nvlist_t *
1120 zpool_find_import_impl(libzfs_handle_t *hdl, int argc, char **argv,
1121     boolean_t active_ok, char *poolname, uint64_t guid)
1122 {
1123 	int i;
1124 	DIR *dirp = NULL;
1125 	struct dirent64 *dp;
1126 	char path[MAXPATHLEN];
1127 	char *end;
1128 	size_t pathleft;
1129 	nvlist_t *ret = NULL;
1130 	static char *default_dir = "/dev/dsk";
1131 	pool_list_t pools = { 0 };
1132 	pool_entry_t *pe, *penext;
1133 	vdev_entry_t *ve, *venext;
1134 	config_entry_t *ce, *cenext;
1135 	name_entry_t *ne, *nenext;
1136 	avl_tree_t slice_cache;
1137 	rdsk_node_t *slice;
1138 	void *cookie;
1139 
1140 	verify(poolname == NULL || guid == 0);
1141 
1142 	if (argc == 0) {
1143 		argc = 1;
1144 		argv = &default_dir;
1145 	}
1146 
1147 	/*
1148 	 * Go through and read the label configuration information from every
1149 	 * possible device, organizing the information according to pool GUID
1150 	 * and toplevel GUID.
1151 	 */
1152 	for (i = 0; i < argc; i++) {
1153 		tpool_t *t;
1154 		char *rdsk;
1155 		int dfd;
1156 
1157 		/* use realpath to normalize the path */
1158 		if (realpath(argv[i], path) == 0) {
1159 			(void) zfs_error_fmt(hdl, EZFS_BADPATH,
1160 			    dgettext(TEXT_DOMAIN, "cannot open '%s'"),
1161 			    argv[i]);
1162 			goto error;
1163 		}
1164 		end = &path[strlen(path)];
1165 		*end++ = '/';
1166 		*end = 0;
1167 		pathleft = &path[sizeof (path)] - end;
1168 
1169 		/*
1170 		 * Using raw devices instead of block devices when we're
1171 		 * reading the labels skips a bunch of slow operations during
1172 		 * close(2) processing, so we replace /dev/dsk with /dev/rdsk.
1173 		 */
1174 		if (strcmp(path, "/dev/dsk/") == 0)
1175 			rdsk = "/dev/rdsk/";
1176 		else
1177 			rdsk = path;
1178 
1179 		if ((dfd = open64(rdsk, O_RDONLY)) < 0 ||
1180 		    (dirp = fdopendir(dfd)) == NULL) {
1181 			zfs_error_aux(hdl, strerror(errno));
1182 			(void) zfs_error_fmt(hdl, EZFS_BADPATH,
1183 			    dgettext(TEXT_DOMAIN, "cannot open '%s'"),
1184 			    rdsk);
1185 			goto error;
1186 		}
1187 
1188 		avl_create(&slice_cache, slice_cache_compare,
1189 		    sizeof (rdsk_node_t), offsetof(rdsk_node_t, rn_node));
1190 		/*
1191 		 * This is not MT-safe, but we have no MT consumers of libzfs
1192 		 */
1193 		while ((dp = readdir64(dirp)) != NULL) {
1194 			const char *name = dp->d_name;
1195 			if (name[0] == '.' &&
1196 			    (name[1] == 0 || (name[1] == '.' && name[2] == 0)))
1197 				continue;
1198 
1199 			slice = zfs_alloc(hdl, sizeof (rdsk_node_t));
1200 			slice->rn_name = zfs_strdup(hdl, name);
1201 			slice->rn_avl = &slice_cache;
1202 			slice->rn_dfd = dfd;
1203 			slice->rn_hdl = hdl;
1204 			slice->rn_nozpool = B_FALSE;
1205 			avl_add(&slice_cache, slice);
1206 		}
1207 		/*
1208 		 * create a thread pool to do all of this in parallel;
1209 		 * rn_nozpool is not protected, so this is racy in that
1210 		 * multiple tasks could decide that the same slice can
1211 		 * not hold a zpool, which is benign.  Also choose
1212 		 * double the number of processors; we hold a lot of
1213 		 * locks in the kernel, so going beyond this doesn't
1214 		 * buy us much.
1215 		 */
1216 		t = tpool_create(1, 2 * sysconf(_SC_NPROCESSORS_ONLN),
1217 		    0, NULL);
1218 		for (slice = avl_first(&slice_cache); slice;
1219 		    (slice = avl_walk(&slice_cache, slice,
1220 		    AVL_AFTER)))
1221 			(void) tpool_dispatch(t, zpool_open_func, slice);
1222 		tpool_wait(t);
1223 		tpool_destroy(t);
1224 
1225 		cookie = NULL;
1226 		while ((slice = avl_destroy_nodes(&slice_cache,
1227 		    &cookie)) != NULL) {
1228 			if (slice->rn_config != NULL) {
1229 				nvlist_t *config = slice->rn_config;
1230 				boolean_t matched = B_TRUE;
1231 
1232 				if (poolname != NULL) {
1233 					char *pname;
1234 
1235 					matched = nvlist_lookup_string(config,
1236 					    ZPOOL_CONFIG_POOL_NAME,
1237 					    &pname) == 0 &&
1238 					    strcmp(poolname, pname) == 0;
1239 				} else if (guid != 0) {
1240 					uint64_t this_guid;
1241 
1242 					matched = nvlist_lookup_uint64(config,
1243 					    ZPOOL_CONFIG_POOL_GUID,
1244 					    &this_guid) == 0 &&
1245 					    guid == this_guid;
1246 				}
1247 				if (!matched) {
1248 					nvlist_free(config);
1249 					config = NULL;
1250 					continue;
1251 				}
1252 				/* use the non-raw path for the config */
1253 				(void) strlcpy(end, slice->rn_name, pathleft);
1254 				if (add_config(hdl, &pools, path, config) != 0)
1255 					goto error;
1256 			}
1257 			free(slice->rn_name);
1258 			free(slice);
1259 		}
1260 		avl_destroy(&slice_cache);
1261 
1262 		(void) closedir(dirp);
1263 		dirp = NULL;
1264 	}
1265 
1266 	ret = get_configs(hdl, &pools, active_ok);
1267 
1268 error:
1269 	for (pe = pools.pools; pe != NULL; pe = penext) {
1270 		penext = pe->pe_next;
1271 		for (ve = pe->pe_vdevs; ve != NULL; ve = venext) {
1272 			venext = ve->ve_next;
1273 			for (ce = ve->ve_configs; ce != NULL; ce = cenext) {
1274 				cenext = ce->ce_next;
1275 				if (ce->ce_config)
1276 					nvlist_free(ce->ce_config);
1277 				free(ce);
1278 			}
1279 			free(ve);
1280 		}
1281 		free(pe);
1282 	}
1283 
1284 	for (ne = pools.names; ne != NULL; ne = nenext) {
1285 		nenext = ne->ne_next;
1286 		if (ne->ne_name)
1287 			free(ne->ne_name);
1288 		free(ne);
1289 	}
1290 
1291 	if (dirp)
1292 		(void) closedir(dirp);
1293 
1294 	return (ret);
1295 }
1296 
1297 nvlist_t *
1298 zpool_find_import(libzfs_handle_t *hdl, int argc, char **argv)
1299 {
1300 	return (zpool_find_import_impl(hdl, argc, argv, B_FALSE, NULL, 0));
1301 }
1302 
1303 nvlist_t *
1304 zpool_find_import_byname(libzfs_handle_t *hdl, int argc, char **argv,
1305     char *pool)
1306 {
1307 	return (zpool_find_import_impl(hdl, argc, argv, B_FALSE, pool, 0));
1308 }
1309 
1310 nvlist_t *
1311 zpool_find_import_byguid(libzfs_handle_t *hdl, int argc, char **argv,
1312     uint64_t guid)
1313 {
1314 	return (zpool_find_import_impl(hdl, argc, argv, B_FALSE, NULL, guid));
1315 }
1316 
1317 nvlist_t *
1318 zpool_find_import_activeok(libzfs_handle_t *hdl, int argc, char **argv)
1319 {
1320 	return (zpool_find_import_impl(hdl, argc, argv, B_TRUE, NULL, 0));
1321 }
1322 
1323 /*
1324  * Given a cache file, return the contents as a list of importable pools.
1325  * poolname or guid (but not both) are provided by the caller when trying
1326  * to import a specific pool.
1327  */
1328 nvlist_t *
1329 zpool_find_import_cached(libzfs_handle_t *hdl, const char *cachefile,
1330     char *poolname, uint64_t guid)
1331 {
1332 	char *buf;
1333 	int fd;
1334 	struct stat64 statbuf;
1335 	nvlist_t *raw, *src, *dst;
1336 	nvlist_t *pools;
1337 	nvpair_t *elem;
1338 	char *name;
1339 	uint64_t this_guid;
1340 	boolean_t active;
1341 
1342 	verify(poolname == NULL || guid == 0);
1343 
1344 	if ((fd = open(cachefile, O_RDONLY)) < 0) {
1345 		zfs_error_aux(hdl, "%s", strerror(errno));
1346 		(void) zfs_error(hdl, EZFS_BADCACHE,
1347 		    dgettext(TEXT_DOMAIN, "failed to open cache file"));
1348 		return (NULL);
1349 	}
1350 
1351 	if (fstat64(fd, &statbuf) != 0) {
1352 		zfs_error_aux(hdl, "%s", strerror(errno));
1353 		(void) close(fd);
1354 		(void) zfs_error(hdl, EZFS_BADCACHE,
1355 		    dgettext(TEXT_DOMAIN, "failed to get size of cache file"));
1356 		return (NULL);
1357 	}
1358 
1359 	if ((buf = zfs_alloc(hdl, statbuf.st_size)) == NULL) {
1360 		(void) close(fd);
1361 		return (NULL);
1362 	}
1363 
1364 	if (read(fd, buf, statbuf.st_size) != statbuf.st_size) {
1365 		(void) close(fd);
1366 		free(buf);
1367 		(void) zfs_error(hdl, EZFS_BADCACHE,
1368 		    dgettext(TEXT_DOMAIN,
1369 		    "failed to read cache file contents"));
1370 		return (NULL);
1371 	}
1372 
1373 	(void) close(fd);
1374 
1375 	if (nvlist_unpack(buf, statbuf.st_size, &raw, 0) != 0) {
1376 		free(buf);
1377 		(void) zfs_error(hdl, EZFS_BADCACHE,
1378 		    dgettext(TEXT_DOMAIN,
1379 		    "invalid or corrupt cache file contents"));
1380 		return (NULL);
1381 	}
1382 
1383 	free(buf);
1384 
1385 	/*
1386 	 * Go through and get the current state of the pools and refresh their
1387 	 * state.
1388 	 */
1389 	if (nvlist_alloc(&pools, 0, 0) != 0) {
1390 		(void) no_memory(hdl);
1391 		nvlist_free(raw);
1392 		return (NULL);
1393 	}
1394 
1395 	elem = NULL;
1396 	while ((elem = nvlist_next_nvpair(raw, elem)) != NULL) {
1397 		verify(nvpair_value_nvlist(elem, &src) == 0);
1398 
1399 		verify(nvlist_lookup_string(src, ZPOOL_CONFIG_POOL_NAME,
1400 		    &name) == 0);
1401 		if (poolname != NULL && strcmp(poolname, name) != 0)
1402 			continue;
1403 
1404 		verify(nvlist_lookup_uint64(src, ZPOOL_CONFIG_POOL_GUID,
1405 		    &this_guid) == 0);
1406 		if (guid != 0) {
1407 			verify(nvlist_lookup_uint64(src, ZPOOL_CONFIG_POOL_GUID,
1408 			    &this_guid) == 0);
1409 			if (guid != this_guid)
1410 				continue;
1411 		}
1412 
1413 		if (pool_active(hdl, name, this_guid, &active) != 0) {
1414 			nvlist_free(raw);
1415 			nvlist_free(pools);
1416 			return (NULL);
1417 		}
1418 
1419 		if (active)
1420 			continue;
1421 
1422 		if ((dst = refresh_config(hdl, src)) == NULL) {
1423 			nvlist_free(raw);
1424 			nvlist_free(pools);
1425 			return (NULL);
1426 		}
1427 
1428 		if (nvlist_add_nvlist(pools, nvpair_name(elem), dst) != 0) {
1429 			(void) no_memory(hdl);
1430 			nvlist_free(dst);
1431 			nvlist_free(raw);
1432 			nvlist_free(pools);
1433 			return (NULL);
1434 		}
1435 		nvlist_free(dst);
1436 	}
1437 
1438 	nvlist_free(raw);
1439 	return (pools);
1440 }
1441 
1442 
1443 boolean_t
1444 find_guid(nvlist_t *nv, uint64_t guid)
1445 {
1446 	uint64_t tmp;
1447 	nvlist_t **child;
1448 	uint_t c, children;
1449 
1450 	verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &tmp) == 0);
1451 	if (tmp == guid)
1452 		return (B_TRUE);
1453 
1454 	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
1455 	    &child, &children) == 0) {
1456 		for (c = 0; c < children; c++)
1457 			if (find_guid(child[c], guid))
1458 				return (B_TRUE);
1459 	}
1460 
1461 	return (B_FALSE);
1462 }
1463 
1464 typedef struct aux_cbdata {
1465 	const char	*cb_type;
1466 	uint64_t	cb_guid;
1467 	zpool_handle_t	*cb_zhp;
1468 } aux_cbdata_t;
1469 
1470 static int
1471 find_aux(zpool_handle_t *zhp, void *data)
1472 {
1473 	aux_cbdata_t *cbp = data;
1474 	nvlist_t **list;
1475 	uint_t i, count;
1476 	uint64_t guid;
1477 	nvlist_t *nvroot;
1478 
1479 	verify(nvlist_lookup_nvlist(zhp->zpool_config, ZPOOL_CONFIG_VDEV_TREE,
1480 	    &nvroot) == 0);
1481 
1482 	if (nvlist_lookup_nvlist_array(nvroot, cbp->cb_type,
1483 	    &list, &count) == 0) {
1484 		for (i = 0; i < count; i++) {
1485 			verify(nvlist_lookup_uint64(list[i],
1486 			    ZPOOL_CONFIG_GUID, &guid) == 0);
1487 			if (guid == cbp->cb_guid) {
1488 				cbp->cb_zhp = zhp;
1489 				return (1);
1490 			}
1491 		}
1492 	}
1493 
1494 	zpool_close(zhp);
1495 	return (0);
1496 }
1497 
1498 /*
1499  * Determines if the pool is in use.  If so, it returns true and the state of
1500  * the pool as well as the name of the pool.  Both strings are allocated and
1501  * must be freed by the caller.
1502  */
1503 int
1504 zpool_in_use(libzfs_handle_t *hdl, int fd, pool_state_t *state, char **namestr,
1505     boolean_t *inuse)
1506 {
1507 	nvlist_t *config;
1508 	char *name;
1509 	boolean_t ret;
1510 	uint64_t guid, vdev_guid;
1511 	zpool_handle_t *zhp;
1512 	nvlist_t *pool_config;
1513 	uint64_t stateval, isspare;
1514 	aux_cbdata_t cb = { 0 };
1515 	boolean_t isactive;
1516 
1517 	*inuse = B_FALSE;
1518 
1519 	if (zpool_read_label(fd, &config) != 0) {
1520 		(void) no_memory(hdl);
1521 		return (-1);
1522 	}
1523 
1524 	if (config == NULL)
1525 		return (0);
1526 
1527 	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
1528 	    &stateval) == 0);
1529 	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID,
1530 	    &vdev_guid) == 0);
1531 
1532 	if (stateval != POOL_STATE_SPARE && stateval != POOL_STATE_L2CACHE) {
1533 		verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
1534 		    &name) == 0);
1535 		verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
1536 		    &guid) == 0);
1537 	}
1538 
1539 	switch (stateval) {
1540 	case POOL_STATE_EXPORTED:
1541 		ret = B_TRUE;
1542 		break;
1543 
1544 	case POOL_STATE_ACTIVE:
1545 		/*
1546 		 * For an active pool, we have to determine if it's really part
1547 		 * of a currently active pool (in which case the pool will exist
1548 		 * and the guid will be the same), or whether it's part of an
1549 		 * active pool that was disconnected without being explicitly
1550 		 * exported.
1551 		 */
1552 		if (pool_active(hdl, name, guid, &isactive) != 0) {
1553 			nvlist_free(config);
1554 			return (-1);
1555 		}
1556 
1557 		if (isactive) {
1558 			/*
1559 			 * Because the device may have been removed while
1560 			 * offlined, we only report it as active if the vdev is
1561 			 * still present in the config.  Otherwise, pretend like
1562 			 * it's not in use.
1563 			 */
1564 			if ((zhp = zpool_open_canfail(hdl, name)) != NULL &&
1565 			    (pool_config = zpool_get_config(zhp, NULL))
1566 			    != NULL) {
1567 				nvlist_t *nvroot;
1568 
1569 				verify(nvlist_lookup_nvlist(pool_config,
1570 				    ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
1571 				ret = find_guid(nvroot, vdev_guid);
1572 			} else {
1573 				ret = B_FALSE;
1574 			}
1575 
1576 			/*
1577 			 * If this is an active spare within another pool, we
1578 			 * treat it like an unused hot spare.  This allows the
1579 			 * user to create a pool with a hot spare that currently
1580 			 * in use within another pool.  Since we return B_TRUE,
1581 			 * libdiskmgt will continue to prevent generic consumers
1582 			 * from using the device.
1583 			 */
1584 			if (ret && nvlist_lookup_uint64(config,
1585 			    ZPOOL_CONFIG_IS_SPARE, &isspare) == 0 && isspare)
1586 				stateval = POOL_STATE_SPARE;
1587 
1588 			if (zhp != NULL)
1589 				zpool_close(zhp);
1590 		} else {
1591 			stateval = POOL_STATE_POTENTIALLY_ACTIVE;
1592 			ret = B_TRUE;
1593 		}
1594 		break;
1595 
1596 	case POOL_STATE_SPARE:
1597 		/*
1598 		 * For a hot spare, it can be either definitively in use, or
1599 		 * potentially active.  To determine if it's in use, we iterate
1600 		 * over all pools in the system and search for one with a spare
1601 		 * with a matching guid.
1602 		 *
1603 		 * Due to the shared nature of spares, we don't actually report
1604 		 * the potentially active case as in use.  This means the user
1605 		 * can freely create pools on the hot spares of exported pools,
1606 		 * but to do otherwise makes the resulting code complicated, and
1607 		 * we end up having to deal with this case anyway.
1608 		 */
1609 		cb.cb_zhp = NULL;
1610 		cb.cb_guid = vdev_guid;
1611 		cb.cb_type = ZPOOL_CONFIG_SPARES;
1612 		if (zpool_iter(hdl, find_aux, &cb) == 1) {
1613 			name = (char *)zpool_get_name(cb.cb_zhp);
1614 			ret = TRUE;
1615 		} else {
1616 			ret = FALSE;
1617 		}
1618 		break;
1619 
1620 	case POOL_STATE_L2CACHE:
1621 
1622 		/*
1623 		 * Check if any pool is currently using this l2cache device.
1624 		 */
1625 		cb.cb_zhp = NULL;
1626 		cb.cb_guid = vdev_guid;
1627 		cb.cb_type = ZPOOL_CONFIG_L2CACHE;
1628 		if (zpool_iter(hdl, find_aux, &cb) == 1) {
1629 			name = (char *)zpool_get_name(cb.cb_zhp);
1630 			ret = TRUE;
1631 		} else {
1632 			ret = FALSE;
1633 		}
1634 		break;
1635 
1636 	default:
1637 		ret = B_FALSE;
1638 	}
1639 
1640 
1641 	if (ret) {
1642 		if ((*namestr = zfs_strdup(hdl, name)) == NULL) {
1643 			if (cb.cb_zhp)
1644 				zpool_close(cb.cb_zhp);
1645 			nvlist_free(config);
1646 			return (-1);
1647 		}
1648 		*state = (pool_state_t)stateval;
1649 	}
1650 
1651 	if (cb.cb_zhp)
1652 		zpool_close(cb.cb_zhp);
1653 
1654 	nvlist_free(config);
1655 	*inuse = ret;
1656 	return (0);
1657 }
1658