xref: /titanic_50/usr/src/uts/common/fs/zfs/spa.c (revision 11b942e373071da9f760d7e6208bc79a7bbf7d3c)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright (c) 2011, 2014 by Delphix. All rights reserved.
25  * Copyright (c) 2013, 2014, Nexenta Systems, Inc.  All rights reserved.
26  * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
27  */
28 
29 /*
30  * SPA: Storage Pool Allocator
31  *
32  * This file contains all the routines used when modifying on-disk SPA state.
33  * This includes opening, importing, destroying, exporting a pool, and syncing a
34  * pool.
35  */
36 
37 #include <sys/zfs_context.h>
38 #include <sys/fm/fs/zfs.h>
39 #include <sys/spa_impl.h>
40 #include <sys/zio.h>
41 #include <sys/zio_checksum.h>
42 #include <sys/dmu.h>
43 #include <sys/dmu_tx.h>
44 #include <sys/zap.h>
45 #include <sys/zil.h>
46 #include <sys/ddt.h>
47 #include <sys/vdev_impl.h>
48 #include <sys/metaslab.h>
49 #include <sys/metaslab_impl.h>
50 #include <sys/uberblock_impl.h>
51 #include <sys/txg.h>
52 #include <sys/avl.h>
53 #include <sys/dmu_traverse.h>
54 #include <sys/dmu_objset.h>
55 #include <sys/unique.h>
56 #include <sys/dsl_pool.h>
57 #include <sys/dsl_dataset.h>
58 #include <sys/dsl_dir.h>
59 #include <sys/dsl_prop.h>
60 #include <sys/dsl_synctask.h>
61 #include <sys/fs/zfs.h>
62 #include <sys/arc.h>
63 #include <sys/callb.h>
64 #include <sys/systeminfo.h>
65 #include <sys/spa_boot.h>
66 #include <sys/zfs_ioctl.h>
67 #include <sys/dsl_scan.h>
68 #include <sys/zfeature.h>
69 #include <sys/dsl_destroy.h>
70 
71 #ifdef	_KERNEL
72 #include <sys/bootprops.h>
73 #include <sys/callb.h>
74 #include <sys/cpupart.h>
75 #include <sys/pool.h>
76 #include <sys/sysdc.h>
77 #include <sys/zone.h>
78 #endif	/* _KERNEL */
79 
80 #include "zfs_prop.h"
81 #include "zfs_comutil.h"
82 
83 /*
84  * The interval, in seconds, at which failed configuration cache file writes
85  * should be retried.
86  */
87 static int zfs_ccw_retry_interval = 300;
88 
89 typedef enum zti_modes {
90 	ZTI_MODE_FIXED,			/* value is # of threads (min 1) */
91 	ZTI_MODE_BATCH,			/* cpu-intensive; value is ignored */
92 	ZTI_MODE_NULL,			/* don't create a taskq */
93 	ZTI_NMODES
94 } zti_modes_t;
95 
96 #define	ZTI_P(n, q)	{ ZTI_MODE_FIXED, (n), (q) }
97 #define	ZTI_BATCH	{ ZTI_MODE_BATCH, 0, 1 }
98 #define	ZTI_NULL	{ ZTI_MODE_NULL, 0, 0 }
99 
100 #define	ZTI_N(n)	ZTI_P(n, 1)
101 #define	ZTI_ONE		ZTI_N(1)
102 
103 typedef struct zio_taskq_info {
104 	zti_modes_t zti_mode;
105 	uint_t zti_value;
106 	uint_t zti_count;
107 } zio_taskq_info_t;
108 
109 static const char *const zio_taskq_types[ZIO_TASKQ_TYPES] = {
110 	"issue", "issue_high", "intr", "intr_high"
111 };
112 
113 /*
114  * This table defines the taskq settings for each ZFS I/O type. When
115  * initializing a pool, we use this table to create an appropriately sized
116  * taskq. Some operations are low volume and therefore have a small, static
117  * number of threads assigned to their taskqs using the ZTI_N(#) or ZTI_ONE
118  * macros. Other operations process a large amount of data; the ZTI_BATCH
119  * macro causes us to create a taskq oriented for throughput. Some operations
120  * are so high frequency and short-lived that the taskq itself can become a a
121  * point of lock contention. The ZTI_P(#, #) macro indicates that we need an
122  * additional degree of parallelism specified by the number of threads per-
123  * taskq and the number of taskqs; when dispatching an event in this case, the
124  * particular taskq is chosen at random.
125  *
126  * The different taskq priorities are to handle the different contexts (issue
127  * and interrupt) and then to reserve threads for ZIO_PRIORITY_NOW I/Os that
128  * need to be handled with minimum delay.
129  */
130 const zio_taskq_info_t zio_taskqs[ZIO_TYPES][ZIO_TASKQ_TYPES] = {
131 	/* ISSUE	ISSUE_HIGH	INTR		INTR_HIGH */
132 	{ ZTI_ONE,	ZTI_NULL,	ZTI_ONE,	ZTI_NULL }, /* NULL */
133 	{ ZTI_N(8),	ZTI_NULL,	ZTI_P(12, 8),	ZTI_NULL }, /* READ */
134 	{ ZTI_BATCH,	ZTI_N(5),	ZTI_N(8),	ZTI_N(5) }, /* WRITE */
135 	{ ZTI_P(12, 8),	ZTI_NULL,	ZTI_ONE,	ZTI_NULL }, /* FREE */
136 	{ ZTI_ONE,	ZTI_NULL,	ZTI_ONE,	ZTI_NULL }, /* CLAIM */
137 	{ ZTI_ONE,	ZTI_NULL,	ZTI_ONE,	ZTI_NULL }, /* IOCTL */
138 };
139 
140 static void spa_sync_version(void *arg, dmu_tx_t *tx);
141 static void spa_sync_props(void *arg, dmu_tx_t *tx);
142 static boolean_t spa_has_active_shared_spare(spa_t *spa);
143 static int spa_load_impl(spa_t *spa, uint64_t, nvlist_t *config,
144     spa_load_state_t state, spa_import_type_t type, boolean_t mosconfig,
145     char **ereport);
146 static void spa_vdev_resilver_done(spa_t *spa);
147 
148 uint_t		zio_taskq_batch_pct = 75;	/* 1 thread per cpu in pset */
149 id_t		zio_taskq_psrset_bind = PS_NONE;
150 boolean_t	zio_taskq_sysdc = B_TRUE;	/* use SDC scheduling class */
151 uint_t		zio_taskq_basedc = 80;		/* base duty cycle */
152 
153 boolean_t	spa_create_process = B_TRUE;	/* no process ==> no sysdc */
154 extern int	zfs_sync_pass_deferred_free;
155 
156 /*
157  * This (illegal) pool name is used when temporarily importing a spa_t in order
158  * to get the vdev stats associated with the imported devices.
159  */
160 #define	TRYIMPORT_NAME	"$import"
161 
162 /*
163  * ==========================================================================
164  * SPA properties routines
165  * ==========================================================================
166  */
167 
168 /*
169  * Add a (source=src, propname=propval) list to an nvlist.
170  */
171 static void
172 spa_prop_add_list(nvlist_t *nvl, zpool_prop_t prop, char *strval,
173     uint64_t intval, zprop_source_t src)
174 {
175 	const char *propname = zpool_prop_to_name(prop);
176 	nvlist_t *propval;
177 
178 	VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0);
179 	VERIFY(nvlist_add_uint64(propval, ZPROP_SOURCE, src) == 0);
180 
181 	if (strval != NULL)
182 		VERIFY(nvlist_add_string(propval, ZPROP_VALUE, strval) == 0);
183 	else
184 		VERIFY(nvlist_add_uint64(propval, ZPROP_VALUE, intval) == 0);
185 
186 	VERIFY(nvlist_add_nvlist(nvl, propname, propval) == 0);
187 	nvlist_free(propval);
188 }
189 
190 /*
191  * Get property values from the spa configuration.
192  */
193 static void
194 spa_prop_get_config(spa_t *spa, nvlist_t **nvp)
195 {
196 	vdev_t *rvd = spa->spa_root_vdev;
197 	dsl_pool_t *pool = spa->spa_dsl_pool;
198 	uint64_t size, alloc, cap, version;
199 	zprop_source_t src = ZPROP_SRC_NONE;
200 	spa_config_dirent_t *dp;
201 	metaslab_class_t *mc = spa_normal_class(spa);
202 
203 	ASSERT(MUTEX_HELD(&spa->spa_props_lock));
204 
205 	if (rvd != NULL) {
206 		alloc = metaslab_class_get_alloc(spa_normal_class(spa));
207 		size = metaslab_class_get_space(spa_normal_class(spa));
208 		spa_prop_add_list(*nvp, ZPOOL_PROP_NAME, spa_name(spa), 0, src);
209 		spa_prop_add_list(*nvp, ZPOOL_PROP_SIZE, NULL, size, src);
210 		spa_prop_add_list(*nvp, ZPOOL_PROP_ALLOCATED, NULL, alloc, src);
211 		spa_prop_add_list(*nvp, ZPOOL_PROP_FREE, NULL,
212 		    size - alloc, src);
213 
214 		spa_prop_add_list(*nvp, ZPOOL_PROP_FRAGMENTATION, NULL,
215 		    metaslab_class_fragmentation(mc), src);
216 		spa_prop_add_list(*nvp, ZPOOL_PROP_EXPANDSZ, NULL,
217 		    metaslab_class_expandable_space(mc), src);
218 		spa_prop_add_list(*nvp, ZPOOL_PROP_READONLY, NULL,
219 		    (spa_mode(spa) == FREAD), src);
220 
221 		cap = (size == 0) ? 0 : (alloc * 100 / size);
222 		spa_prop_add_list(*nvp, ZPOOL_PROP_CAPACITY, NULL, cap, src);
223 
224 		spa_prop_add_list(*nvp, ZPOOL_PROP_DEDUPRATIO, NULL,
225 		    ddt_get_pool_dedup_ratio(spa), src);
226 
227 		spa_prop_add_list(*nvp, ZPOOL_PROP_HEALTH, NULL,
228 		    rvd->vdev_state, src);
229 
230 		version = spa_version(spa);
231 		if (version == zpool_prop_default_numeric(ZPOOL_PROP_VERSION))
232 			src = ZPROP_SRC_DEFAULT;
233 		else
234 			src = ZPROP_SRC_LOCAL;
235 		spa_prop_add_list(*nvp, ZPOOL_PROP_VERSION, NULL, version, src);
236 	}
237 
238 	if (pool != NULL) {
239 		/*
240 		 * The $FREE directory was introduced in SPA_VERSION_DEADLISTS,
241 		 * when opening pools before this version freedir will be NULL.
242 		 */
243 		if (pool->dp_free_dir != NULL) {
244 			spa_prop_add_list(*nvp, ZPOOL_PROP_FREEING, NULL,
245 			    dsl_dir_phys(pool->dp_free_dir)->dd_used_bytes,
246 			    src);
247 		} else {
248 			spa_prop_add_list(*nvp, ZPOOL_PROP_FREEING,
249 			    NULL, 0, src);
250 		}
251 
252 		if (pool->dp_leak_dir != NULL) {
253 			spa_prop_add_list(*nvp, ZPOOL_PROP_LEAKED, NULL,
254 			    dsl_dir_phys(pool->dp_leak_dir)->dd_used_bytes,
255 			    src);
256 		} else {
257 			spa_prop_add_list(*nvp, ZPOOL_PROP_LEAKED,
258 			    NULL, 0, src);
259 		}
260 	}
261 
262 	spa_prop_add_list(*nvp, ZPOOL_PROP_GUID, NULL, spa_guid(spa), src);
263 
264 	if (spa->spa_comment != NULL) {
265 		spa_prop_add_list(*nvp, ZPOOL_PROP_COMMENT, spa->spa_comment,
266 		    0, ZPROP_SRC_LOCAL);
267 	}
268 
269 	if (spa->spa_root != NULL)
270 		spa_prop_add_list(*nvp, ZPOOL_PROP_ALTROOT, spa->spa_root,
271 		    0, ZPROP_SRC_LOCAL);
272 
273 	if (spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_BLOCKS)) {
274 		spa_prop_add_list(*nvp, ZPOOL_PROP_MAXBLOCKSIZE, NULL,
275 		    MIN(zfs_max_recordsize, SPA_MAXBLOCKSIZE), ZPROP_SRC_NONE);
276 	} else {
277 		spa_prop_add_list(*nvp, ZPOOL_PROP_MAXBLOCKSIZE, NULL,
278 		    SPA_OLD_MAXBLOCKSIZE, ZPROP_SRC_NONE);
279 	}
280 
281 	if ((dp = list_head(&spa->spa_config_list)) != NULL) {
282 		if (dp->scd_path == NULL) {
283 			spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE,
284 			    "none", 0, ZPROP_SRC_LOCAL);
285 		} else if (strcmp(dp->scd_path, spa_config_path) != 0) {
286 			spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE,
287 			    dp->scd_path, 0, ZPROP_SRC_LOCAL);
288 		}
289 	}
290 }
291 
292 /*
293  * Get zpool property values.
294  */
295 int
296 spa_prop_get(spa_t *spa, nvlist_t **nvp)
297 {
298 	objset_t *mos = spa->spa_meta_objset;
299 	zap_cursor_t zc;
300 	zap_attribute_t za;
301 	int err;
302 
303 	VERIFY(nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0);
304 
305 	mutex_enter(&spa->spa_props_lock);
306 
307 	/*
308 	 * Get properties from the spa config.
309 	 */
310 	spa_prop_get_config(spa, nvp);
311 
312 	/* If no pool property object, no more prop to get. */
313 	if (mos == NULL || spa->spa_pool_props_object == 0) {
314 		mutex_exit(&spa->spa_props_lock);
315 		return (0);
316 	}
317 
318 	/*
319 	 * Get properties from the MOS pool property object.
320 	 */
321 	for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object);
322 	    (err = zap_cursor_retrieve(&zc, &za)) == 0;
323 	    zap_cursor_advance(&zc)) {
324 		uint64_t intval = 0;
325 		char *strval = NULL;
326 		zprop_source_t src = ZPROP_SRC_DEFAULT;
327 		zpool_prop_t prop;
328 
329 		if ((prop = zpool_name_to_prop(za.za_name)) == ZPROP_INVAL)
330 			continue;
331 
332 		switch (za.za_integer_length) {
333 		case 8:
334 			/* integer property */
335 			if (za.za_first_integer !=
336 			    zpool_prop_default_numeric(prop))
337 				src = ZPROP_SRC_LOCAL;
338 
339 			if (prop == ZPOOL_PROP_BOOTFS) {
340 				dsl_pool_t *dp;
341 				dsl_dataset_t *ds = NULL;
342 
343 				dp = spa_get_dsl(spa);
344 				dsl_pool_config_enter(dp, FTAG);
345 				if (err = dsl_dataset_hold_obj(dp,
346 				    za.za_first_integer, FTAG, &ds)) {
347 					dsl_pool_config_exit(dp, FTAG);
348 					break;
349 				}
350 
351 				strval = kmem_alloc(
352 				    MAXNAMELEN + strlen(MOS_DIR_NAME) + 1,
353 				    KM_SLEEP);
354 				dsl_dataset_name(ds, strval);
355 				dsl_dataset_rele(ds, FTAG);
356 				dsl_pool_config_exit(dp, FTAG);
357 			} else {
358 				strval = NULL;
359 				intval = za.za_first_integer;
360 			}
361 
362 			spa_prop_add_list(*nvp, prop, strval, intval, src);
363 
364 			if (strval != NULL)
365 				kmem_free(strval,
366 				    MAXNAMELEN + strlen(MOS_DIR_NAME) + 1);
367 
368 			break;
369 
370 		case 1:
371 			/* string property */
372 			strval = kmem_alloc(za.za_num_integers, KM_SLEEP);
373 			err = zap_lookup(mos, spa->spa_pool_props_object,
374 			    za.za_name, 1, za.za_num_integers, strval);
375 			if (err) {
376 				kmem_free(strval, za.za_num_integers);
377 				break;
378 			}
379 			spa_prop_add_list(*nvp, prop, strval, 0, src);
380 			kmem_free(strval, za.za_num_integers);
381 			break;
382 
383 		default:
384 			break;
385 		}
386 	}
387 	zap_cursor_fini(&zc);
388 	mutex_exit(&spa->spa_props_lock);
389 out:
390 	if (err && err != ENOENT) {
391 		nvlist_free(*nvp);
392 		*nvp = NULL;
393 		return (err);
394 	}
395 
396 	return (0);
397 }
398 
399 /*
400  * Validate the given pool properties nvlist and modify the list
401  * for the property values to be set.
402  */
403 static int
404 spa_prop_validate(spa_t *spa, nvlist_t *props)
405 {
406 	nvpair_t *elem;
407 	int error = 0, reset_bootfs = 0;
408 	uint64_t objnum = 0;
409 	boolean_t has_feature = B_FALSE;
410 
411 	elem = NULL;
412 	while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
413 		uint64_t intval;
414 		char *strval, *slash, *check, *fname;
415 		const char *propname = nvpair_name(elem);
416 		zpool_prop_t prop = zpool_name_to_prop(propname);
417 
418 		switch (prop) {
419 		case ZPROP_INVAL:
420 			if (!zpool_prop_feature(propname)) {
421 				error = SET_ERROR(EINVAL);
422 				break;
423 			}
424 
425 			/*
426 			 * Sanitize the input.
427 			 */
428 			if (nvpair_type(elem) != DATA_TYPE_UINT64) {
429 				error = SET_ERROR(EINVAL);
430 				break;
431 			}
432 
433 			if (nvpair_value_uint64(elem, &intval) != 0) {
434 				error = SET_ERROR(EINVAL);
435 				break;
436 			}
437 
438 			if (intval != 0) {
439 				error = SET_ERROR(EINVAL);
440 				break;
441 			}
442 
443 			fname = strchr(propname, '@') + 1;
444 			if (zfeature_lookup_name(fname, NULL) != 0) {
445 				error = SET_ERROR(EINVAL);
446 				break;
447 			}
448 
449 			has_feature = B_TRUE;
450 			break;
451 
452 		case ZPOOL_PROP_VERSION:
453 			error = nvpair_value_uint64(elem, &intval);
454 			if (!error &&
455 			    (intval < spa_version(spa) ||
456 			    intval > SPA_VERSION_BEFORE_FEATURES ||
457 			    has_feature))
458 				error = SET_ERROR(EINVAL);
459 			break;
460 
461 		case ZPOOL_PROP_DELEGATION:
462 		case ZPOOL_PROP_AUTOREPLACE:
463 		case ZPOOL_PROP_LISTSNAPS:
464 		case ZPOOL_PROP_AUTOEXPAND:
465 			error = nvpair_value_uint64(elem, &intval);
466 			if (!error && intval > 1)
467 				error = SET_ERROR(EINVAL);
468 			break;
469 
470 		case ZPOOL_PROP_BOOTFS:
471 			/*
472 			 * If the pool version is less than SPA_VERSION_BOOTFS,
473 			 * or the pool is still being created (version == 0),
474 			 * the bootfs property cannot be set.
475 			 */
476 			if (spa_version(spa) < SPA_VERSION_BOOTFS) {
477 				error = SET_ERROR(ENOTSUP);
478 				break;
479 			}
480 
481 			/*
482 			 * Make sure the vdev config is bootable
483 			 */
484 			if (!vdev_is_bootable(spa->spa_root_vdev)) {
485 				error = SET_ERROR(ENOTSUP);
486 				break;
487 			}
488 
489 			reset_bootfs = 1;
490 
491 			error = nvpair_value_string(elem, &strval);
492 
493 			if (!error) {
494 				objset_t *os;
495 				uint64_t propval;
496 
497 				if (strval == NULL || strval[0] == '\0') {
498 					objnum = zpool_prop_default_numeric(
499 					    ZPOOL_PROP_BOOTFS);
500 					break;
501 				}
502 
503 				if (error = dmu_objset_hold(strval, FTAG, &os))
504 					break;
505 
506 				/*
507 				 * Must be ZPL, and its property settings
508 				 * must be supported by GRUB (compression
509 				 * is not gzip, and large blocks are not used).
510 				 */
511 
512 				if (dmu_objset_type(os) != DMU_OST_ZFS) {
513 					error = SET_ERROR(ENOTSUP);
514 				} else if ((error =
515 				    dsl_prop_get_int_ds(dmu_objset_ds(os),
516 				    zfs_prop_to_name(ZFS_PROP_COMPRESSION),
517 				    &propval)) == 0 &&
518 				    !BOOTFS_COMPRESS_VALID(propval)) {
519 					error = SET_ERROR(ENOTSUP);
520 				} else if ((error =
521 				    dsl_prop_get_int_ds(dmu_objset_ds(os),
522 				    zfs_prop_to_name(ZFS_PROP_RECORDSIZE),
523 				    &propval)) == 0 &&
524 				    propval > SPA_OLD_MAXBLOCKSIZE) {
525 					error = SET_ERROR(ENOTSUP);
526 				} else {
527 					objnum = dmu_objset_id(os);
528 				}
529 				dmu_objset_rele(os, FTAG);
530 			}
531 			break;
532 
533 		case ZPOOL_PROP_FAILUREMODE:
534 			error = nvpair_value_uint64(elem, &intval);
535 			if (!error && (intval < ZIO_FAILURE_MODE_WAIT ||
536 			    intval > ZIO_FAILURE_MODE_PANIC))
537 				error = SET_ERROR(EINVAL);
538 
539 			/*
540 			 * This is a special case which only occurs when
541 			 * the pool has completely failed. This allows
542 			 * the user to change the in-core failmode property
543 			 * without syncing it out to disk (I/Os might
544 			 * currently be blocked). We do this by returning
545 			 * EIO to the caller (spa_prop_set) to trick it
546 			 * into thinking we encountered a property validation
547 			 * error.
548 			 */
549 			if (!error && spa_suspended(spa)) {
550 				spa->spa_failmode = intval;
551 				error = SET_ERROR(EIO);
552 			}
553 			break;
554 
555 		case ZPOOL_PROP_CACHEFILE:
556 			if ((error = nvpair_value_string(elem, &strval)) != 0)
557 				break;
558 
559 			if (strval[0] == '\0')
560 				break;
561 
562 			if (strcmp(strval, "none") == 0)
563 				break;
564 
565 			if (strval[0] != '/') {
566 				error = SET_ERROR(EINVAL);
567 				break;
568 			}
569 
570 			slash = strrchr(strval, '/');
571 			ASSERT(slash != NULL);
572 
573 			if (slash[1] == '\0' || strcmp(slash, "/.") == 0 ||
574 			    strcmp(slash, "/..") == 0)
575 				error = SET_ERROR(EINVAL);
576 			break;
577 
578 		case ZPOOL_PROP_COMMENT:
579 			if ((error = nvpair_value_string(elem, &strval)) != 0)
580 				break;
581 			for (check = strval; *check != '\0'; check++) {
582 				/*
583 				 * The kernel doesn't have an easy isprint()
584 				 * check.  For this kernel check, we merely
585 				 * check ASCII apart from DEL.  Fix this if
586 				 * there is an easy-to-use kernel isprint().
587 				 */
588 				if (*check >= 0x7f) {
589 					error = SET_ERROR(EINVAL);
590 					break;
591 				}
592 				check++;
593 			}
594 			if (strlen(strval) > ZPROP_MAX_COMMENT)
595 				error = E2BIG;
596 			break;
597 
598 		case ZPOOL_PROP_DEDUPDITTO:
599 			if (spa_version(spa) < SPA_VERSION_DEDUP)
600 				error = SET_ERROR(ENOTSUP);
601 			else
602 				error = nvpair_value_uint64(elem, &intval);
603 			if (error == 0 &&
604 			    intval != 0 && intval < ZIO_DEDUPDITTO_MIN)
605 				error = SET_ERROR(EINVAL);
606 			break;
607 		}
608 
609 		if (error)
610 			break;
611 	}
612 
613 	if (!error && reset_bootfs) {
614 		error = nvlist_remove(props,
615 		    zpool_prop_to_name(ZPOOL_PROP_BOOTFS), DATA_TYPE_STRING);
616 
617 		if (!error) {
618 			error = nvlist_add_uint64(props,
619 			    zpool_prop_to_name(ZPOOL_PROP_BOOTFS), objnum);
620 		}
621 	}
622 
623 	return (error);
624 }
625 
626 void
627 spa_configfile_set(spa_t *spa, nvlist_t *nvp, boolean_t need_sync)
628 {
629 	char *cachefile;
630 	spa_config_dirent_t *dp;
631 
632 	if (nvlist_lookup_string(nvp, zpool_prop_to_name(ZPOOL_PROP_CACHEFILE),
633 	    &cachefile) != 0)
634 		return;
635 
636 	dp = kmem_alloc(sizeof (spa_config_dirent_t),
637 	    KM_SLEEP);
638 
639 	if (cachefile[0] == '\0')
640 		dp->scd_path = spa_strdup(spa_config_path);
641 	else if (strcmp(cachefile, "none") == 0)
642 		dp->scd_path = NULL;
643 	else
644 		dp->scd_path = spa_strdup(cachefile);
645 
646 	list_insert_head(&spa->spa_config_list, dp);
647 	if (need_sync)
648 		spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
649 }
650 
651 int
652 spa_prop_set(spa_t *spa, nvlist_t *nvp)
653 {
654 	int error;
655 	nvpair_t *elem = NULL;
656 	boolean_t need_sync = B_FALSE;
657 
658 	if ((error = spa_prop_validate(spa, nvp)) != 0)
659 		return (error);
660 
661 	while ((elem = nvlist_next_nvpair(nvp, elem)) != NULL) {
662 		zpool_prop_t prop = zpool_name_to_prop(nvpair_name(elem));
663 
664 		if (prop == ZPOOL_PROP_CACHEFILE ||
665 		    prop == ZPOOL_PROP_ALTROOT ||
666 		    prop == ZPOOL_PROP_READONLY)
667 			continue;
668 
669 		if (prop == ZPOOL_PROP_VERSION || prop == ZPROP_INVAL) {
670 			uint64_t ver;
671 
672 			if (prop == ZPOOL_PROP_VERSION) {
673 				VERIFY(nvpair_value_uint64(elem, &ver) == 0);
674 			} else {
675 				ASSERT(zpool_prop_feature(nvpair_name(elem)));
676 				ver = SPA_VERSION_FEATURES;
677 				need_sync = B_TRUE;
678 			}
679 
680 			/* Save time if the version is already set. */
681 			if (ver == spa_version(spa))
682 				continue;
683 
684 			/*
685 			 * In addition to the pool directory object, we might
686 			 * create the pool properties object, the features for
687 			 * read object, the features for write object, or the
688 			 * feature descriptions object.
689 			 */
690 			error = dsl_sync_task(spa->spa_name, NULL,
691 			    spa_sync_version, &ver,
692 			    6, ZFS_SPACE_CHECK_RESERVED);
693 			if (error)
694 				return (error);
695 			continue;
696 		}
697 
698 		need_sync = B_TRUE;
699 		break;
700 	}
701 
702 	if (need_sync) {
703 		return (dsl_sync_task(spa->spa_name, NULL, spa_sync_props,
704 		    nvp, 6, ZFS_SPACE_CHECK_RESERVED));
705 	}
706 
707 	return (0);
708 }
709 
710 /*
711  * If the bootfs property value is dsobj, clear it.
712  */
713 void
714 spa_prop_clear_bootfs(spa_t *spa, uint64_t dsobj, dmu_tx_t *tx)
715 {
716 	if (spa->spa_bootfs == dsobj && spa->spa_pool_props_object != 0) {
717 		VERIFY(zap_remove(spa->spa_meta_objset,
718 		    spa->spa_pool_props_object,
719 		    zpool_prop_to_name(ZPOOL_PROP_BOOTFS), tx) == 0);
720 		spa->spa_bootfs = 0;
721 	}
722 }
723 
724 /*ARGSUSED*/
725 static int
726 spa_change_guid_check(void *arg, dmu_tx_t *tx)
727 {
728 	uint64_t *newguid = arg;
729 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
730 	vdev_t *rvd = spa->spa_root_vdev;
731 	uint64_t vdev_state;
732 
733 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
734 	vdev_state = rvd->vdev_state;
735 	spa_config_exit(spa, SCL_STATE, FTAG);
736 
737 	if (vdev_state != VDEV_STATE_HEALTHY)
738 		return (SET_ERROR(ENXIO));
739 
740 	ASSERT3U(spa_guid(spa), !=, *newguid);
741 
742 	return (0);
743 }
744 
745 static void
746 spa_change_guid_sync(void *arg, dmu_tx_t *tx)
747 {
748 	uint64_t *newguid = arg;
749 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
750 	uint64_t oldguid;
751 	vdev_t *rvd = spa->spa_root_vdev;
752 
753 	oldguid = spa_guid(spa);
754 
755 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
756 	rvd->vdev_guid = *newguid;
757 	rvd->vdev_guid_sum += (*newguid - oldguid);
758 	vdev_config_dirty(rvd);
759 	spa_config_exit(spa, SCL_STATE, FTAG);
760 
761 	spa_history_log_internal(spa, "guid change", tx, "old=%llu new=%llu",
762 	    oldguid, *newguid);
763 }
764 
765 /*
766  * Change the GUID for the pool.  This is done so that we can later
767  * re-import a pool built from a clone of our own vdevs.  We will modify
768  * the root vdev's guid, our own pool guid, and then mark all of our
769  * vdevs dirty.  Note that we must make sure that all our vdevs are
770  * online when we do this, or else any vdevs that weren't present
771  * would be orphaned from our pool.  We are also going to issue a
772  * sysevent to update any watchers.
773  */
774 int
775 spa_change_guid(spa_t *spa)
776 {
777 	int error;
778 	uint64_t guid;
779 
780 	mutex_enter(&spa->spa_vdev_top_lock);
781 	mutex_enter(&spa_namespace_lock);
782 	guid = spa_generate_guid(NULL);
783 
784 	error = dsl_sync_task(spa->spa_name, spa_change_guid_check,
785 	    spa_change_guid_sync, &guid, 5, ZFS_SPACE_CHECK_RESERVED);
786 
787 	if (error == 0) {
788 		spa_config_sync(spa, B_FALSE, B_TRUE);
789 		spa_event_notify(spa, NULL, ESC_ZFS_POOL_REGUID);
790 	}
791 
792 	mutex_exit(&spa_namespace_lock);
793 	mutex_exit(&spa->spa_vdev_top_lock);
794 
795 	return (error);
796 }
797 
798 /*
799  * ==========================================================================
800  * SPA state manipulation (open/create/destroy/import/export)
801  * ==========================================================================
802  */
803 
804 static int
805 spa_error_entry_compare(const void *a, const void *b)
806 {
807 	spa_error_entry_t *sa = (spa_error_entry_t *)a;
808 	spa_error_entry_t *sb = (spa_error_entry_t *)b;
809 	int ret;
810 
811 	ret = bcmp(&sa->se_bookmark, &sb->se_bookmark,
812 	    sizeof (zbookmark_phys_t));
813 
814 	if (ret < 0)
815 		return (-1);
816 	else if (ret > 0)
817 		return (1);
818 	else
819 		return (0);
820 }
821 
822 /*
823  * Utility function which retrieves copies of the current logs and
824  * re-initializes them in the process.
825  */
826 void
827 spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub)
828 {
829 	ASSERT(MUTEX_HELD(&spa->spa_errlist_lock));
830 
831 	bcopy(&spa->spa_errlist_last, last, sizeof (avl_tree_t));
832 	bcopy(&spa->spa_errlist_scrub, scrub, sizeof (avl_tree_t));
833 
834 	avl_create(&spa->spa_errlist_scrub,
835 	    spa_error_entry_compare, sizeof (spa_error_entry_t),
836 	    offsetof(spa_error_entry_t, se_avl));
837 	avl_create(&spa->spa_errlist_last,
838 	    spa_error_entry_compare, sizeof (spa_error_entry_t),
839 	    offsetof(spa_error_entry_t, se_avl));
840 }
841 
842 static void
843 spa_taskqs_init(spa_t *spa, zio_type_t t, zio_taskq_type_t q)
844 {
845 	const zio_taskq_info_t *ztip = &zio_taskqs[t][q];
846 	enum zti_modes mode = ztip->zti_mode;
847 	uint_t value = ztip->zti_value;
848 	uint_t count = ztip->zti_count;
849 	spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
850 	char name[32];
851 	uint_t flags = 0;
852 	boolean_t batch = B_FALSE;
853 
854 	if (mode == ZTI_MODE_NULL) {
855 		tqs->stqs_count = 0;
856 		tqs->stqs_taskq = NULL;
857 		return;
858 	}
859 
860 	ASSERT3U(count, >, 0);
861 
862 	tqs->stqs_count = count;
863 	tqs->stqs_taskq = kmem_alloc(count * sizeof (taskq_t *), KM_SLEEP);
864 
865 	switch (mode) {
866 	case ZTI_MODE_FIXED:
867 		ASSERT3U(value, >=, 1);
868 		value = MAX(value, 1);
869 		break;
870 
871 	case ZTI_MODE_BATCH:
872 		batch = B_TRUE;
873 		flags |= TASKQ_THREADS_CPU_PCT;
874 		value = zio_taskq_batch_pct;
875 		break;
876 
877 	default:
878 		panic("unrecognized mode for %s_%s taskq (%u:%u) in "
879 		    "spa_activate()",
880 		    zio_type_name[t], zio_taskq_types[q], mode, value);
881 		break;
882 	}
883 
884 	for (uint_t i = 0; i < count; i++) {
885 		taskq_t *tq;
886 
887 		if (count > 1) {
888 			(void) snprintf(name, sizeof (name), "%s_%s_%u",
889 			    zio_type_name[t], zio_taskq_types[q], i);
890 		} else {
891 			(void) snprintf(name, sizeof (name), "%s_%s",
892 			    zio_type_name[t], zio_taskq_types[q]);
893 		}
894 
895 		if (zio_taskq_sysdc && spa->spa_proc != &p0) {
896 			if (batch)
897 				flags |= TASKQ_DC_BATCH;
898 
899 			tq = taskq_create_sysdc(name, value, 50, INT_MAX,
900 			    spa->spa_proc, zio_taskq_basedc, flags);
901 		} else {
902 			pri_t pri = maxclsyspri;
903 			/*
904 			 * The write issue taskq can be extremely CPU
905 			 * intensive.  Run it at slightly lower priority
906 			 * than the other taskqs.
907 			 */
908 			if (t == ZIO_TYPE_WRITE && q == ZIO_TASKQ_ISSUE)
909 				pri--;
910 
911 			tq = taskq_create_proc(name, value, pri, 50,
912 			    INT_MAX, spa->spa_proc, flags);
913 		}
914 
915 		tqs->stqs_taskq[i] = tq;
916 	}
917 }
918 
919 static void
920 spa_taskqs_fini(spa_t *spa, zio_type_t t, zio_taskq_type_t q)
921 {
922 	spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
923 
924 	if (tqs->stqs_taskq == NULL) {
925 		ASSERT0(tqs->stqs_count);
926 		return;
927 	}
928 
929 	for (uint_t i = 0; i < tqs->stqs_count; i++) {
930 		ASSERT3P(tqs->stqs_taskq[i], !=, NULL);
931 		taskq_destroy(tqs->stqs_taskq[i]);
932 	}
933 
934 	kmem_free(tqs->stqs_taskq, tqs->stqs_count * sizeof (taskq_t *));
935 	tqs->stqs_taskq = NULL;
936 }
937 
938 /*
939  * Dispatch a task to the appropriate taskq for the ZFS I/O type and priority.
940  * Note that a type may have multiple discrete taskqs to avoid lock contention
941  * on the taskq itself. In that case we choose which taskq at random by using
942  * the low bits of gethrtime().
943  */
944 void
945 spa_taskq_dispatch_ent(spa_t *spa, zio_type_t t, zio_taskq_type_t q,
946     task_func_t *func, void *arg, uint_t flags, taskq_ent_t *ent)
947 {
948 	spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
949 	taskq_t *tq;
950 
951 	ASSERT3P(tqs->stqs_taskq, !=, NULL);
952 	ASSERT3U(tqs->stqs_count, !=, 0);
953 
954 	if (tqs->stqs_count == 1) {
955 		tq = tqs->stqs_taskq[0];
956 	} else {
957 		tq = tqs->stqs_taskq[gethrtime() % tqs->stqs_count];
958 	}
959 
960 	taskq_dispatch_ent(tq, func, arg, flags, ent);
961 }
962 
963 static void
964 spa_create_zio_taskqs(spa_t *spa)
965 {
966 	for (int t = 0; t < ZIO_TYPES; t++) {
967 		for (int q = 0; q < ZIO_TASKQ_TYPES; q++) {
968 			spa_taskqs_init(spa, t, q);
969 		}
970 	}
971 }
972 
973 #ifdef _KERNEL
974 static void
975 spa_thread(void *arg)
976 {
977 	callb_cpr_t cprinfo;
978 
979 	spa_t *spa = arg;
980 	user_t *pu = PTOU(curproc);
981 
982 	CALLB_CPR_INIT(&cprinfo, &spa->spa_proc_lock, callb_generic_cpr,
983 	    spa->spa_name);
984 
985 	ASSERT(curproc != &p0);
986 	(void) snprintf(pu->u_psargs, sizeof (pu->u_psargs),
987 	    "zpool-%s", spa->spa_name);
988 	(void) strlcpy(pu->u_comm, pu->u_psargs, sizeof (pu->u_comm));
989 
990 	/* bind this thread to the requested psrset */
991 	if (zio_taskq_psrset_bind != PS_NONE) {
992 		pool_lock();
993 		mutex_enter(&cpu_lock);
994 		mutex_enter(&pidlock);
995 		mutex_enter(&curproc->p_lock);
996 
997 		if (cpupart_bind_thread(curthread, zio_taskq_psrset_bind,
998 		    0, NULL, NULL) == 0)  {
999 			curthread->t_bind_pset = zio_taskq_psrset_bind;
1000 		} else {
1001 			cmn_err(CE_WARN,
1002 			    "Couldn't bind process for zfs pool \"%s\" to "
1003 			    "pset %d\n", spa->spa_name, zio_taskq_psrset_bind);
1004 		}
1005 
1006 		mutex_exit(&curproc->p_lock);
1007 		mutex_exit(&pidlock);
1008 		mutex_exit(&cpu_lock);
1009 		pool_unlock();
1010 	}
1011 
1012 	if (zio_taskq_sysdc) {
1013 		sysdc_thread_enter(curthread, 100, 0);
1014 	}
1015 
1016 	spa->spa_proc = curproc;
1017 	spa->spa_did = curthread->t_did;
1018 
1019 	spa_create_zio_taskqs(spa);
1020 
1021 	mutex_enter(&spa->spa_proc_lock);
1022 	ASSERT(spa->spa_proc_state == SPA_PROC_CREATED);
1023 
1024 	spa->spa_proc_state = SPA_PROC_ACTIVE;
1025 	cv_broadcast(&spa->spa_proc_cv);
1026 
1027 	CALLB_CPR_SAFE_BEGIN(&cprinfo);
1028 	while (spa->spa_proc_state == SPA_PROC_ACTIVE)
1029 		cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock);
1030 	CALLB_CPR_SAFE_END(&cprinfo, &spa->spa_proc_lock);
1031 
1032 	ASSERT(spa->spa_proc_state == SPA_PROC_DEACTIVATE);
1033 	spa->spa_proc_state = SPA_PROC_GONE;
1034 	spa->spa_proc = &p0;
1035 	cv_broadcast(&spa->spa_proc_cv);
1036 	CALLB_CPR_EXIT(&cprinfo);	/* drops spa_proc_lock */
1037 
1038 	mutex_enter(&curproc->p_lock);
1039 	lwp_exit();
1040 }
1041 #endif
1042 
1043 /*
1044  * Activate an uninitialized pool.
1045  */
1046 static void
1047 spa_activate(spa_t *spa, int mode)
1048 {
1049 	ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED);
1050 
1051 	spa->spa_state = POOL_STATE_ACTIVE;
1052 	spa->spa_mode = mode;
1053 
1054 	spa->spa_normal_class = metaslab_class_create(spa, zfs_metaslab_ops);
1055 	spa->spa_log_class = metaslab_class_create(spa, zfs_metaslab_ops);
1056 
1057 	/* Try to create a covering process */
1058 	mutex_enter(&spa->spa_proc_lock);
1059 	ASSERT(spa->spa_proc_state == SPA_PROC_NONE);
1060 	ASSERT(spa->spa_proc == &p0);
1061 	spa->spa_did = 0;
1062 
1063 	/* Only create a process if we're going to be around a while. */
1064 	if (spa_create_process && strcmp(spa->spa_name, TRYIMPORT_NAME) != 0) {
1065 		if (newproc(spa_thread, (caddr_t)spa, syscid, maxclsyspri,
1066 		    NULL, 0) == 0) {
1067 			spa->spa_proc_state = SPA_PROC_CREATED;
1068 			while (spa->spa_proc_state == SPA_PROC_CREATED) {
1069 				cv_wait(&spa->spa_proc_cv,
1070 				    &spa->spa_proc_lock);
1071 			}
1072 			ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE);
1073 			ASSERT(spa->spa_proc != &p0);
1074 			ASSERT(spa->spa_did != 0);
1075 		} else {
1076 #ifdef _KERNEL
1077 			cmn_err(CE_WARN,
1078 			    "Couldn't create process for zfs pool \"%s\"\n",
1079 			    spa->spa_name);
1080 #endif
1081 		}
1082 	}
1083 	mutex_exit(&spa->spa_proc_lock);
1084 
1085 	/* If we didn't create a process, we need to create our taskqs. */
1086 	if (spa->spa_proc == &p0) {
1087 		spa_create_zio_taskqs(spa);
1088 	}
1089 
1090 	list_create(&spa->spa_config_dirty_list, sizeof (vdev_t),
1091 	    offsetof(vdev_t, vdev_config_dirty_node));
1092 	list_create(&spa->spa_evicting_os_list, sizeof (objset_t),
1093 	    offsetof(objset_t, os_evicting_node));
1094 	list_create(&spa->spa_state_dirty_list, sizeof (vdev_t),
1095 	    offsetof(vdev_t, vdev_state_dirty_node));
1096 
1097 	txg_list_create(&spa->spa_vdev_txg_list,
1098 	    offsetof(struct vdev, vdev_txg_node));
1099 
1100 	avl_create(&spa->spa_errlist_scrub,
1101 	    spa_error_entry_compare, sizeof (spa_error_entry_t),
1102 	    offsetof(spa_error_entry_t, se_avl));
1103 	avl_create(&spa->spa_errlist_last,
1104 	    spa_error_entry_compare, sizeof (spa_error_entry_t),
1105 	    offsetof(spa_error_entry_t, se_avl));
1106 }
1107 
1108 /*
1109  * Opposite of spa_activate().
1110  */
1111 static void
1112 spa_deactivate(spa_t *spa)
1113 {
1114 	ASSERT(spa->spa_sync_on == B_FALSE);
1115 	ASSERT(spa->spa_dsl_pool == NULL);
1116 	ASSERT(spa->spa_root_vdev == NULL);
1117 	ASSERT(spa->spa_async_zio_root == NULL);
1118 	ASSERT(spa->spa_state != POOL_STATE_UNINITIALIZED);
1119 
1120 	spa_evicting_os_wait(spa);
1121 
1122 	txg_list_destroy(&spa->spa_vdev_txg_list);
1123 
1124 	list_destroy(&spa->spa_config_dirty_list);
1125 	list_destroy(&spa->spa_evicting_os_list);
1126 	list_destroy(&spa->spa_state_dirty_list);
1127 
1128 	for (int t = 0; t < ZIO_TYPES; t++) {
1129 		for (int q = 0; q < ZIO_TASKQ_TYPES; q++) {
1130 			spa_taskqs_fini(spa, t, q);
1131 		}
1132 	}
1133 
1134 	metaslab_class_destroy(spa->spa_normal_class);
1135 	spa->spa_normal_class = NULL;
1136 
1137 	metaslab_class_destroy(spa->spa_log_class);
1138 	spa->spa_log_class = NULL;
1139 
1140 	/*
1141 	 * If this was part of an import or the open otherwise failed, we may
1142 	 * still have errors left in the queues.  Empty them just in case.
1143 	 */
1144 	spa_errlog_drain(spa);
1145 
1146 	avl_destroy(&spa->spa_errlist_scrub);
1147 	avl_destroy(&spa->spa_errlist_last);
1148 
1149 	spa->spa_state = POOL_STATE_UNINITIALIZED;
1150 
1151 	mutex_enter(&spa->spa_proc_lock);
1152 	if (spa->spa_proc_state != SPA_PROC_NONE) {
1153 		ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE);
1154 		spa->spa_proc_state = SPA_PROC_DEACTIVATE;
1155 		cv_broadcast(&spa->spa_proc_cv);
1156 		while (spa->spa_proc_state == SPA_PROC_DEACTIVATE) {
1157 			ASSERT(spa->spa_proc != &p0);
1158 			cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock);
1159 		}
1160 		ASSERT(spa->spa_proc_state == SPA_PROC_GONE);
1161 		spa->spa_proc_state = SPA_PROC_NONE;
1162 	}
1163 	ASSERT(spa->spa_proc == &p0);
1164 	mutex_exit(&spa->spa_proc_lock);
1165 
1166 	/*
1167 	 * We want to make sure spa_thread() has actually exited the ZFS
1168 	 * module, so that the module can't be unloaded out from underneath
1169 	 * it.
1170 	 */
1171 	if (spa->spa_did != 0) {
1172 		thread_join(spa->spa_did);
1173 		spa->spa_did = 0;
1174 	}
1175 }
1176 
1177 /*
1178  * Verify a pool configuration, and construct the vdev tree appropriately.  This
1179  * will create all the necessary vdevs in the appropriate layout, with each vdev
1180  * in the CLOSED state.  This will prep the pool before open/creation/import.
1181  * All vdev validation is done by the vdev_alloc() routine.
1182  */
1183 static int
1184 spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent,
1185     uint_t id, int atype)
1186 {
1187 	nvlist_t **child;
1188 	uint_t children;
1189 	int error;
1190 
1191 	if ((error = vdev_alloc(spa, vdp, nv, parent, id, atype)) != 0)
1192 		return (error);
1193 
1194 	if ((*vdp)->vdev_ops->vdev_op_leaf)
1195 		return (0);
1196 
1197 	error = nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
1198 	    &child, &children);
1199 
1200 	if (error == ENOENT)
1201 		return (0);
1202 
1203 	if (error) {
1204 		vdev_free(*vdp);
1205 		*vdp = NULL;
1206 		return (SET_ERROR(EINVAL));
1207 	}
1208 
1209 	for (int c = 0; c < children; c++) {
1210 		vdev_t *vd;
1211 		if ((error = spa_config_parse(spa, &vd, child[c], *vdp, c,
1212 		    atype)) != 0) {
1213 			vdev_free(*vdp);
1214 			*vdp = NULL;
1215 			return (error);
1216 		}
1217 	}
1218 
1219 	ASSERT(*vdp != NULL);
1220 
1221 	return (0);
1222 }
1223 
1224 /*
1225  * Opposite of spa_load().
1226  */
1227 static void
1228 spa_unload(spa_t *spa)
1229 {
1230 	int i;
1231 
1232 	ASSERT(MUTEX_HELD(&spa_namespace_lock));
1233 
1234 	/*
1235 	 * Stop async tasks.
1236 	 */
1237 	spa_async_suspend(spa);
1238 
1239 	/*
1240 	 * Stop syncing.
1241 	 */
1242 	if (spa->spa_sync_on) {
1243 		txg_sync_stop(spa->spa_dsl_pool);
1244 		spa->spa_sync_on = B_FALSE;
1245 	}
1246 
1247 	/*
1248 	 * Wait for any outstanding async I/O to complete.
1249 	 */
1250 	if (spa->spa_async_zio_root != NULL) {
1251 		for (int i = 0; i < max_ncpus; i++)
1252 			(void) zio_wait(spa->spa_async_zio_root[i]);
1253 		kmem_free(spa->spa_async_zio_root, max_ncpus * sizeof (void *));
1254 		spa->spa_async_zio_root = NULL;
1255 	}
1256 
1257 	bpobj_close(&spa->spa_deferred_bpobj);
1258 
1259 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1260 
1261 	/*
1262 	 * Close all vdevs.
1263 	 */
1264 	if (spa->spa_root_vdev)
1265 		vdev_free(spa->spa_root_vdev);
1266 	ASSERT(spa->spa_root_vdev == NULL);
1267 
1268 	/*
1269 	 * Close the dsl pool.
1270 	 */
1271 	if (spa->spa_dsl_pool) {
1272 		dsl_pool_close(spa->spa_dsl_pool);
1273 		spa->spa_dsl_pool = NULL;
1274 		spa->spa_meta_objset = NULL;
1275 	}
1276 
1277 	ddt_unload(spa);
1278 
1279 
1280 	/*
1281 	 * Drop and purge level 2 cache
1282 	 */
1283 	spa_l2cache_drop(spa);
1284 
1285 	for (i = 0; i < spa->spa_spares.sav_count; i++)
1286 		vdev_free(spa->spa_spares.sav_vdevs[i]);
1287 	if (spa->spa_spares.sav_vdevs) {
1288 		kmem_free(spa->spa_spares.sav_vdevs,
1289 		    spa->spa_spares.sav_count * sizeof (void *));
1290 		spa->spa_spares.sav_vdevs = NULL;
1291 	}
1292 	if (spa->spa_spares.sav_config) {
1293 		nvlist_free(spa->spa_spares.sav_config);
1294 		spa->spa_spares.sav_config = NULL;
1295 	}
1296 	spa->spa_spares.sav_count = 0;
1297 
1298 	for (i = 0; i < spa->spa_l2cache.sav_count; i++) {
1299 		vdev_clear_stats(spa->spa_l2cache.sav_vdevs[i]);
1300 		vdev_free(spa->spa_l2cache.sav_vdevs[i]);
1301 	}
1302 	if (spa->spa_l2cache.sav_vdevs) {
1303 		kmem_free(spa->spa_l2cache.sav_vdevs,
1304 		    spa->spa_l2cache.sav_count * sizeof (void *));
1305 		spa->spa_l2cache.sav_vdevs = NULL;
1306 	}
1307 	if (spa->spa_l2cache.sav_config) {
1308 		nvlist_free(spa->spa_l2cache.sav_config);
1309 		spa->spa_l2cache.sav_config = NULL;
1310 	}
1311 	spa->spa_l2cache.sav_count = 0;
1312 
1313 	spa->spa_async_suspended = 0;
1314 
1315 	if (spa->spa_comment != NULL) {
1316 		spa_strfree(spa->spa_comment);
1317 		spa->spa_comment = NULL;
1318 	}
1319 
1320 	spa_config_exit(spa, SCL_ALL, FTAG);
1321 }
1322 
1323 /*
1324  * Load (or re-load) the current list of vdevs describing the active spares for
1325  * this pool.  When this is called, we have some form of basic information in
1326  * 'spa_spares.sav_config'.  We parse this into vdevs, try to open them, and
1327  * then re-generate a more complete list including status information.
1328  */
1329 static void
1330 spa_load_spares(spa_t *spa)
1331 {
1332 	nvlist_t **spares;
1333 	uint_t nspares;
1334 	int i;
1335 	vdev_t *vd, *tvd;
1336 
1337 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
1338 
1339 	/*
1340 	 * First, close and free any existing spare vdevs.
1341 	 */
1342 	for (i = 0; i < spa->spa_spares.sav_count; i++) {
1343 		vd = spa->spa_spares.sav_vdevs[i];
1344 
1345 		/* Undo the call to spa_activate() below */
1346 		if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid,
1347 		    B_FALSE)) != NULL && tvd->vdev_isspare)
1348 			spa_spare_remove(tvd);
1349 		vdev_close(vd);
1350 		vdev_free(vd);
1351 	}
1352 
1353 	if (spa->spa_spares.sav_vdevs)
1354 		kmem_free(spa->spa_spares.sav_vdevs,
1355 		    spa->spa_spares.sav_count * sizeof (void *));
1356 
1357 	if (spa->spa_spares.sav_config == NULL)
1358 		nspares = 0;
1359 	else
1360 		VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
1361 		    ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);
1362 
1363 	spa->spa_spares.sav_count = (int)nspares;
1364 	spa->spa_spares.sav_vdevs = NULL;
1365 
1366 	if (nspares == 0)
1367 		return;
1368 
1369 	/*
1370 	 * Construct the array of vdevs, opening them to get status in the
1371 	 * process.   For each spare, there is potentially two different vdev_t
1372 	 * structures associated with it: one in the list of spares (used only
1373 	 * for basic validation purposes) and one in the active vdev
1374 	 * configuration (if it's spared in).  During this phase we open and
1375 	 * validate each vdev on the spare list.  If the vdev also exists in the
1376 	 * active configuration, then we also mark this vdev as an active spare.
1377 	 */
1378 	spa->spa_spares.sav_vdevs = kmem_alloc(nspares * sizeof (void *),
1379 	    KM_SLEEP);
1380 	for (i = 0; i < spa->spa_spares.sav_count; i++) {
1381 		VERIFY(spa_config_parse(spa, &vd, spares[i], NULL, 0,
1382 		    VDEV_ALLOC_SPARE) == 0);
1383 		ASSERT(vd != NULL);
1384 
1385 		spa->spa_spares.sav_vdevs[i] = vd;
1386 
1387 		if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid,
1388 		    B_FALSE)) != NULL) {
1389 			if (!tvd->vdev_isspare)
1390 				spa_spare_add(tvd);
1391 
1392 			/*
1393 			 * We only mark the spare active if we were successfully
1394 			 * able to load the vdev.  Otherwise, importing a pool
1395 			 * with a bad active spare would result in strange
1396 			 * behavior, because multiple pool would think the spare
1397 			 * is actively in use.
1398 			 *
1399 			 * There is a vulnerability here to an equally bizarre
1400 			 * circumstance, where a dead active spare is later
1401 			 * brought back to life (onlined or otherwise).  Given
1402 			 * the rarity of this scenario, and the extra complexity
1403 			 * it adds, we ignore the possibility.
1404 			 */
1405 			if (!vdev_is_dead(tvd))
1406 				spa_spare_activate(tvd);
1407 		}
1408 
1409 		vd->vdev_top = vd;
1410 		vd->vdev_aux = &spa->spa_spares;
1411 
1412 		if (vdev_open(vd) != 0)
1413 			continue;
1414 
1415 		if (vdev_validate_aux(vd) == 0)
1416 			spa_spare_add(vd);
1417 	}
1418 
1419 	/*
1420 	 * Recompute the stashed list of spares, with status information
1421 	 * this time.
1422 	 */
1423 	VERIFY(nvlist_remove(spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES,
1424 	    DATA_TYPE_NVLIST_ARRAY) == 0);
1425 
1426 	spares = kmem_alloc(spa->spa_spares.sav_count * sizeof (void *),
1427 	    KM_SLEEP);
1428 	for (i = 0; i < spa->spa_spares.sav_count; i++)
1429 		spares[i] = vdev_config_generate(spa,
1430 		    spa->spa_spares.sav_vdevs[i], B_TRUE, VDEV_CONFIG_SPARE);
1431 	VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
1432 	    ZPOOL_CONFIG_SPARES, spares, spa->spa_spares.sav_count) == 0);
1433 	for (i = 0; i < spa->spa_spares.sav_count; i++)
1434 		nvlist_free(spares[i]);
1435 	kmem_free(spares, spa->spa_spares.sav_count * sizeof (void *));
1436 }
1437 
1438 /*
1439  * Load (or re-load) the current list of vdevs describing the active l2cache for
1440  * this pool.  When this is called, we have some form of basic information in
1441  * 'spa_l2cache.sav_config'.  We parse this into vdevs, try to open them, and
1442  * then re-generate a more complete list including status information.
1443  * Devices which are already active have their details maintained, and are
1444  * not re-opened.
1445  */
1446 static void
1447 spa_load_l2cache(spa_t *spa)
1448 {
1449 	nvlist_t **l2cache;
1450 	uint_t nl2cache;
1451 	int i, j, oldnvdevs;
1452 	uint64_t guid;
1453 	vdev_t *vd, **oldvdevs, **newvdevs;
1454 	spa_aux_vdev_t *sav = &spa->spa_l2cache;
1455 
1456 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
1457 
1458 	if (sav->sav_config != NULL) {
1459 		VERIFY(nvlist_lookup_nvlist_array(sav->sav_config,
1460 		    ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0);
1461 		newvdevs = kmem_alloc(nl2cache * sizeof (void *), KM_SLEEP);
1462 	} else {
1463 		nl2cache = 0;
1464 		newvdevs = NULL;
1465 	}
1466 
1467 	oldvdevs = sav->sav_vdevs;
1468 	oldnvdevs = sav->sav_count;
1469 	sav->sav_vdevs = NULL;
1470 	sav->sav_count = 0;
1471 
1472 	/*
1473 	 * Process new nvlist of vdevs.
1474 	 */
1475 	for (i = 0; i < nl2cache; i++) {
1476 		VERIFY(nvlist_lookup_uint64(l2cache[i], ZPOOL_CONFIG_GUID,
1477 		    &guid) == 0);
1478 
1479 		newvdevs[i] = NULL;
1480 		for (j = 0; j < oldnvdevs; j++) {
1481 			vd = oldvdevs[j];
1482 			if (vd != NULL && guid == vd->vdev_guid) {
1483 				/*
1484 				 * Retain previous vdev for add/remove ops.
1485 				 */
1486 				newvdevs[i] = vd;
1487 				oldvdevs[j] = NULL;
1488 				break;
1489 			}
1490 		}
1491 
1492 		if (newvdevs[i] == NULL) {
1493 			/*
1494 			 * Create new vdev
1495 			 */
1496 			VERIFY(spa_config_parse(spa, &vd, l2cache[i], NULL, 0,
1497 			    VDEV_ALLOC_L2CACHE) == 0);
1498 			ASSERT(vd != NULL);
1499 			newvdevs[i] = vd;
1500 
1501 			/*
1502 			 * Commit this vdev as an l2cache device,
1503 			 * even if it fails to open.
1504 			 */
1505 			spa_l2cache_add(vd);
1506 
1507 			vd->vdev_top = vd;
1508 			vd->vdev_aux = sav;
1509 
1510 			spa_l2cache_activate(vd);
1511 
1512 			if (vdev_open(vd) != 0)
1513 				continue;
1514 
1515 			(void) vdev_validate_aux(vd);
1516 
1517 			if (!vdev_is_dead(vd))
1518 				l2arc_add_vdev(spa, vd);
1519 		}
1520 	}
1521 
1522 	/*
1523 	 * Purge vdevs that were dropped
1524 	 */
1525 	for (i = 0; i < oldnvdevs; i++) {
1526 		uint64_t pool;
1527 
1528 		vd = oldvdevs[i];
1529 		if (vd != NULL) {
1530 			ASSERT(vd->vdev_isl2cache);
1531 
1532 			if (spa_l2cache_exists(vd->vdev_guid, &pool) &&
1533 			    pool != 0ULL && l2arc_vdev_present(vd))
1534 				l2arc_remove_vdev(vd);
1535 			vdev_clear_stats(vd);
1536 			vdev_free(vd);
1537 		}
1538 	}
1539 
1540 	if (oldvdevs)
1541 		kmem_free(oldvdevs, oldnvdevs * sizeof (void *));
1542 
1543 	if (sav->sav_config == NULL)
1544 		goto out;
1545 
1546 	sav->sav_vdevs = newvdevs;
1547 	sav->sav_count = (int)nl2cache;
1548 
1549 	/*
1550 	 * Recompute the stashed list of l2cache devices, with status
1551 	 * information this time.
1552 	 */
1553 	VERIFY(nvlist_remove(sav->sav_config, ZPOOL_CONFIG_L2CACHE,
1554 	    DATA_TYPE_NVLIST_ARRAY) == 0);
1555 
1556 	l2cache = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP);
1557 	for (i = 0; i < sav->sav_count; i++)
1558 		l2cache[i] = vdev_config_generate(spa,
1559 		    sav->sav_vdevs[i], B_TRUE, VDEV_CONFIG_L2CACHE);
1560 	VERIFY(nvlist_add_nvlist_array(sav->sav_config,
1561 	    ZPOOL_CONFIG_L2CACHE, l2cache, sav->sav_count) == 0);
1562 out:
1563 	for (i = 0; i < sav->sav_count; i++)
1564 		nvlist_free(l2cache[i]);
1565 	if (sav->sav_count)
1566 		kmem_free(l2cache, sav->sav_count * sizeof (void *));
1567 }
1568 
1569 static int
1570 load_nvlist(spa_t *spa, uint64_t obj, nvlist_t **value)
1571 {
1572 	dmu_buf_t *db;
1573 	char *packed = NULL;
1574 	size_t nvsize = 0;
1575 	int error;
1576 	*value = NULL;
1577 
1578 	error = dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db);
1579 	if (error != 0)
1580 		return (error);
1581 
1582 	nvsize = *(uint64_t *)db->db_data;
1583 	dmu_buf_rele(db, FTAG);
1584 
1585 	packed = kmem_alloc(nvsize, KM_SLEEP);
1586 	error = dmu_read(spa->spa_meta_objset, obj, 0, nvsize, packed,
1587 	    DMU_READ_PREFETCH);
1588 	if (error == 0)
1589 		error = nvlist_unpack(packed, nvsize, value, 0);
1590 	kmem_free(packed, nvsize);
1591 
1592 	return (error);
1593 }
1594 
1595 /*
1596  * Checks to see if the given vdev could not be opened, in which case we post a
1597  * sysevent to notify the autoreplace code that the device has been removed.
1598  */
1599 static void
1600 spa_check_removed(vdev_t *vd)
1601 {
1602 	for (int c = 0; c < vd->vdev_children; c++)
1603 		spa_check_removed(vd->vdev_child[c]);
1604 
1605 	if (vd->vdev_ops->vdev_op_leaf && vdev_is_dead(vd) &&
1606 	    !vd->vdev_ishole) {
1607 		zfs_post_autoreplace(vd->vdev_spa, vd);
1608 		spa_event_notify(vd->vdev_spa, vd, ESC_ZFS_VDEV_CHECK);
1609 	}
1610 }
1611 
1612 /*
1613  * Validate the current config against the MOS config
1614  */
1615 static boolean_t
1616 spa_config_valid(spa_t *spa, nvlist_t *config)
1617 {
1618 	vdev_t *mrvd, *rvd = spa->spa_root_vdev;
1619 	nvlist_t *nv;
1620 
1621 	VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nv) == 0);
1622 
1623 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1624 	VERIFY(spa_config_parse(spa, &mrvd, nv, NULL, 0, VDEV_ALLOC_LOAD) == 0);
1625 
1626 	ASSERT3U(rvd->vdev_children, ==, mrvd->vdev_children);
1627 
1628 	/*
1629 	 * If we're doing a normal import, then build up any additional
1630 	 * diagnostic information about missing devices in this config.
1631 	 * We'll pass this up to the user for further processing.
1632 	 */
1633 	if (!(spa->spa_import_flags & ZFS_IMPORT_MISSING_LOG)) {
1634 		nvlist_t **child, *nv;
1635 		uint64_t idx = 0;
1636 
1637 		child = kmem_alloc(rvd->vdev_children * sizeof (nvlist_t **),
1638 		    KM_SLEEP);
1639 		VERIFY(nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) == 0);
1640 
1641 		for (int c = 0; c < rvd->vdev_children; c++) {
1642 			vdev_t *tvd = rvd->vdev_child[c];
1643 			vdev_t *mtvd  = mrvd->vdev_child[c];
1644 
1645 			if (tvd->vdev_ops == &vdev_missing_ops &&
1646 			    mtvd->vdev_ops != &vdev_missing_ops &&
1647 			    mtvd->vdev_islog)
1648 				child[idx++] = vdev_config_generate(spa, mtvd,
1649 				    B_FALSE, 0);
1650 		}
1651 
1652 		if (idx) {
1653 			VERIFY(nvlist_add_nvlist_array(nv,
1654 			    ZPOOL_CONFIG_CHILDREN, child, idx) == 0);
1655 			VERIFY(nvlist_add_nvlist(spa->spa_load_info,
1656 			    ZPOOL_CONFIG_MISSING_DEVICES, nv) == 0);
1657 
1658 			for (int i = 0; i < idx; i++)
1659 				nvlist_free(child[i]);
1660 		}
1661 		nvlist_free(nv);
1662 		kmem_free(child, rvd->vdev_children * sizeof (char **));
1663 	}
1664 
1665 	/*
1666 	 * Compare the root vdev tree with the information we have
1667 	 * from the MOS config (mrvd). Check each top-level vdev
1668 	 * with the corresponding MOS config top-level (mtvd).
1669 	 */
1670 	for (int c = 0; c < rvd->vdev_children; c++) {
1671 		vdev_t *tvd = rvd->vdev_child[c];
1672 		vdev_t *mtvd  = mrvd->vdev_child[c];
1673 
1674 		/*
1675 		 * Resolve any "missing" vdevs in the current configuration.
1676 		 * If we find that the MOS config has more accurate information
1677 		 * about the top-level vdev then use that vdev instead.
1678 		 */
1679 		if (tvd->vdev_ops == &vdev_missing_ops &&
1680 		    mtvd->vdev_ops != &vdev_missing_ops) {
1681 
1682 			if (!(spa->spa_import_flags & ZFS_IMPORT_MISSING_LOG))
1683 				continue;
1684 
1685 			/*
1686 			 * Device specific actions.
1687 			 */
1688 			if (mtvd->vdev_islog) {
1689 				spa_set_log_state(spa, SPA_LOG_CLEAR);
1690 			} else {
1691 				/*
1692 				 * XXX - once we have 'readonly' pool
1693 				 * support we should be able to handle
1694 				 * missing data devices by transitioning
1695 				 * the pool to readonly.
1696 				 */
1697 				continue;
1698 			}
1699 
1700 			/*
1701 			 * Swap the missing vdev with the data we were
1702 			 * able to obtain from the MOS config.
1703 			 */
1704 			vdev_remove_child(rvd, tvd);
1705 			vdev_remove_child(mrvd, mtvd);
1706 
1707 			vdev_add_child(rvd, mtvd);
1708 			vdev_add_child(mrvd, tvd);
1709 
1710 			spa_config_exit(spa, SCL_ALL, FTAG);
1711 			vdev_load(mtvd);
1712 			spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1713 
1714 			vdev_reopen(rvd);
1715 		} else if (mtvd->vdev_islog) {
1716 			/*
1717 			 * Load the slog device's state from the MOS config
1718 			 * since it's possible that the label does not
1719 			 * contain the most up-to-date information.
1720 			 */
1721 			vdev_load_log_state(tvd, mtvd);
1722 			vdev_reopen(tvd);
1723 		}
1724 	}
1725 	vdev_free(mrvd);
1726 	spa_config_exit(spa, SCL_ALL, FTAG);
1727 
1728 	/*
1729 	 * Ensure we were able to validate the config.
1730 	 */
1731 	return (rvd->vdev_guid_sum == spa->spa_uberblock.ub_guid_sum);
1732 }
1733 
1734 /*
1735  * Check for missing log devices
1736  */
1737 static boolean_t
1738 spa_check_logs(spa_t *spa)
1739 {
1740 	boolean_t rv = B_FALSE;
1741 	dsl_pool_t *dp = spa_get_dsl(spa);
1742 
1743 	switch (spa->spa_log_state) {
1744 	case SPA_LOG_MISSING:
1745 		/* need to recheck in case slog has been restored */
1746 	case SPA_LOG_UNKNOWN:
1747 		rv = (dmu_objset_find_dp(dp, dp->dp_root_dir_obj,
1748 		    zil_check_log_chain, NULL, DS_FIND_CHILDREN) != 0);
1749 		if (rv)
1750 			spa_set_log_state(spa, SPA_LOG_MISSING);
1751 		break;
1752 	}
1753 	return (rv);
1754 }
1755 
1756 static boolean_t
1757 spa_passivate_log(spa_t *spa)
1758 {
1759 	vdev_t *rvd = spa->spa_root_vdev;
1760 	boolean_t slog_found = B_FALSE;
1761 
1762 	ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER));
1763 
1764 	if (!spa_has_slogs(spa))
1765 		return (B_FALSE);
1766 
1767 	for (int c = 0; c < rvd->vdev_children; c++) {
1768 		vdev_t *tvd = rvd->vdev_child[c];
1769 		metaslab_group_t *mg = tvd->vdev_mg;
1770 
1771 		if (tvd->vdev_islog) {
1772 			metaslab_group_passivate(mg);
1773 			slog_found = B_TRUE;
1774 		}
1775 	}
1776 
1777 	return (slog_found);
1778 }
1779 
1780 static void
1781 spa_activate_log(spa_t *spa)
1782 {
1783 	vdev_t *rvd = spa->spa_root_vdev;
1784 
1785 	ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER));
1786 
1787 	for (int c = 0; c < rvd->vdev_children; c++) {
1788 		vdev_t *tvd = rvd->vdev_child[c];
1789 		metaslab_group_t *mg = tvd->vdev_mg;
1790 
1791 		if (tvd->vdev_islog)
1792 			metaslab_group_activate(mg);
1793 	}
1794 }
1795 
1796 int
1797 spa_offline_log(spa_t *spa)
1798 {
1799 	int error;
1800 
1801 	error = dmu_objset_find(spa_name(spa), zil_vdev_offline,
1802 	    NULL, DS_FIND_CHILDREN);
1803 	if (error == 0) {
1804 		/*
1805 		 * We successfully offlined the log device, sync out the
1806 		 * current txg so that the "stubby" block can be removed
1807 		 * by zil_sync().
1808 		 */
1809 		txg_wait_synced(spa->spa_dsl_pool, 0);
1810 	}
1811 	return (error);
1812 }
1813 
1814 static void
1815 spa_aux_check_removed(spa_aux_vdev_t *sav)
1816 {
1817 	for (int i = 0; i < sav->sav_count; i++)
1818 		spa_check_removed(sav->sav_vdevs[i]);
1819 }
1820 
1821 void
1822 spa_claim_notify(zio_t *zio)
1823 {
1824 	spa_t *spa = zio->io_spa;
1825 
1826 	if (zio->io_error)
1827 		return;
1828 
1829 	mutex_enter(&spa->spa_props_lock);	/* any mutex will do */
1830 	if (spa->spa_claim_max_txg < zio->io_bp->blk_birth)
1831 		spa->spa_claim_max_txg = zio->io_bp->blk_birth;
1832 	mutex_exit(&spa->spa_props_lock);
1833 }
1834 
1835 typedef struct spa_load_error {
1836 	uint64_t	sle_meta_count;
1837 	uint64_t	sle_data_count;
1838 } spa_load_error_t;
1839 
1840 static void
1841 spa_load_verify_done(zio_t *zio)
1842 {
1843 	blkptr_t *bp = zio->io_bp;
1844 	spa_load_error_t *sle = zio->io_private;
1845 	dmu_object_type_t type = BP_GET_TYPE(bp);
1846 	int error = zio->io_error;
1847 	spa_t *spa = zio->io_spa;
1848 
1849 	if (error) {
1850 		if ((BP_GET_LEVEL(bp) != 0 || DMU_OT_IS_METADATA(type)) &&
1851 		    type != DMU_OT_INTENT_LOG)
1852 			atomic_inc_64(&sle->sle_meta_count);
1853 		else
1854 			atomic_inc_64(&sle->sle_data_count);
1855 	}
1856 	zio_data_buf_free(zio->io_data, zio->io_size);
1857 
1858 	mutex_enter(&spa->spa_scrub_lock);
1859 	spa->spa_scrub_inflight--;
1860 	cv_broadcast(&spa->spa_scrub_io_cv);
1861 	mutex_exit(&spa->spa_scrub_lock);
1862 }
1863 
1864 /*
1865  * Maximum number of concurrent scrub i/os to create while verifying
1866  * a pool while importing it.
1867  */
1868 int spa_load_verify_maxinflight = 10000;
1869 boolean_t spa_load_verify_metadata = B_TRUE;
1870 boolean_t spa_load_verify_data = B_TRUE;
1871 
1872 /*ARGSUSED*/
1873 static int
1874 spa_load_verify_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
1875     const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
1876 {
1877 	if (bp == NULL || BP_IS_HOLE(bp) || BP_IS_EMBEDDED(bp))
1878 		return (0);
1879 	/*
1880 	 * Note: normally this routine will not be called if
1881 	 * spa_load_verify_metadata is not set.  However, it may be useful
1882 	 * to manually set the flag after the traversal has begun.
1883 	 */
1884 	if (!spa_load_verify_metadata)
1885 		return (0);
1886 	if (BP_GET_BUFC_TYPE(bp) == ARC_BUFC_DATA && !spa_load_verify_data)
1887 		return (0);
1888 
1889 	zio_t *rio = arg;
1890 	size_t size = BP_GET_PSIZE(bp);
1891 	void *data = zio_data_buf_alloc(size);
1892 
1893 	mutex_enter(&spa->spa_scrub_lock);
1894 	while (spa->spa_scrub_inflight >= spa_load_verify_maxinflight)
1895 		cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
1896 	spa->spa_scrub_inflight++;
1897 	mutex_exit(&spa->spa_scrub_lock);
1898 
1899 	zio_nowait(zio_read(rio, spa, bp, data, size,
1900 	    spa_load_verify_done, rio->io_private, ZIO_PRIORITY_SCRUB,
1901 	    ZIO_FLAG_SPECULATIVE | ZIO_FLAG_CANFAIL |
1902 	    ZIO_FLAG_SCRUB | ZIO_FLAG_RAW, zb));
1903 	return (0);
1904 }
1905 
1906 static int
1907 spa_load_verify(spa_t *spa)
1908 {
1909 	zio_t *rio;
1910 	spa_load_error_t sle = { 0 };
1911 	zpool_rewind_policy_t policy;
1912 	boolean_t verify_ok = B_FALSE;
1913 	int error = 0;
1914 
1915 	zpool_get_rewind_policy(spa->spa_config, &policy);
1916 
1917 	if (policy.zrp_request & ZPOOL_NEVER_REWIND)
1918 		return (0);
1919 
1920 	rio = zio_root(spa, NULL, &sle,
1921 	    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE);
1922 
1923 	if (spa_load_verify_metadata) {
1924 		error = traverse_pool(spa, spa->spa_verify_min_txg,
1925 		    TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA,
1926 		    spa_load_verify_cb, rio);
1927 	}
1928 
1929 	(void) zio_wait(rio);
1930 
1931 	spa->spa_load_meta_errors = sle.sle_meta_count;
1932 	spa->spa_load_data_errors = sle.sle_data_count;
1933 
1934 	if (!error && sle.sle_meta_count <= policy.zrp_maxmeta &&
1935 	    sle.sle_data_count <= policy.zrp_maxdata) {
1936 		int64_t loss = 0;
1937 
1938 		verify_ok = B_TRUE;
1939 		spa->spa_load_txg = spa->spa_uberblock.ub_txg;
1940 		spa->spa_load_txg_ts = spa->spa_uberblock.ub_timestamp;
1941 
1942 		loss = spa->spa_last_ubsync_txg_ts - spa->spa_load_txg_ts;
1943 		VERIFY(nvlist_add_uint64(spa->spa_load_info,
1944 		    ZPOOL_CONFIG_LOAD_TIME, spa->spa_load_txg_ts) == 0);
1945 		VERIFY(nvlist_add_int64(spa->spa_load_info,
1946 		    ZPOOL_CONFIG_REWIND_TIME, loss) == 0);
1947 		VERIFY(nvlist_add_uint64(spa->spa_load_info,
1948 		    ZPOOL_CONFIG_LOAD_DATA_ERRORS, sle.sle_data_count) == 0);
1949 	} else {
1950 		spa->spa_load_max_txg = spa->spa_uberblock.ub_txg;
1951 	}
1952 
1953 	if (error) {
1954 		if (error != ENXIO && error != EIO)
1955 			error = SET_ERROR(EIO);
1956 		return (error);
1957 	}
1958 
1959 	return (verify_ok ? 0 : EIO);
1960 }
1961 
1962 /*
1963  * Find a value in the pool props object.
1964  */
1965 static void
1966 spa_prop_find(spa_t *spa, zpool_prop_t prop, uint64_t *val)
1967 {
1968 	(void) zap_lookup(spa->spa_meta_objset, spa->spa_pool_props_object,
1969 	    zpool_prop_to_name(prop), sizeof (uint64_t), 1, val);
1970 }
1971 
1972 /*
1973  * Find a value in the pool directory object.
1974  */
1975 static int
1976 spa_dir_prop(spa_t *spa, const char *name, uint64_t *val)
1977 {
1978 	return (zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
1979 	    name, sizeof (uint64_t), 1, val));
1980 }
1981 
1982 static int
1983 spa_vdev_err(vdev_t *vdev, vdev_aux_t aux, int err)
1984 {
1985 	vdev_set_state(vdev, B_TRUE, VDEV_STATE_CANT_OPEN, aux);
1986 	return (err);
1987 }
1988 
1989 /*
1990  * Fix up config after a partly-completed split.  This is done with the
1991  * ZPOOL_CONFIG_SPLIT nvlist.  Both the splitting pool and the split-off
1992  * pool have that entry in their config, but only the splitting one contains
1993  * a list of all the guids of the vdevs that are being split off.
1994  *
1995  * This function determines what to do with that list: either rejoin
1996  * all the disks to the pool, or complete the splitting process.  To attempt
1997  * the rejoin, each disk that is offlined is marked online again, and
1998  * we do a reopen() call.  If the vdev label for every disk that was
1999  * marked online indicates it was successfully split off (VDEV_AUX_SPLIT_POOL)
2000  * then we call vdev_split() on each disk, and complete the split.
2001  *
2002  * Otherwise we leave the config alone, with all the vdevs in place in
2003  * the original pool.
2004  */
2005 static void
2006 spa_try_repair(spa_t *spa, nvlist_t *config)
2007 {
2008 	uint_t extracted;
2009 	uint64_t *glist;
2010 	uint_t i, gcount;
2011 	nvlist_t *nvl;
2012 	vdev_t **vd;
2013 	boolean_t attempt_reopen;
2014 
2015 	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_SPLIT, &nvl) != 0)
2016 		return;
2017 
2018 	/* check that the config is complete */
2019 	if (nvlist_lookup_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST,
2020 	    &glist, &gcount) != 0)
2021 		return;
2022 
2023 	vd = kmem_zalloc(gcount * sizeof (vdev_t *), KM_SLEEP);
2024 
2025 	/* attempt to online all the vdevs & validate */
2026 	attempt_reopen = B_TRUE;
2027 	for (i = 0; i < gcount; i++) {
2028 		if (glist[i] == 0)	/* vdev is hole */
2029 			continue;
2030 
2031 		vd[i] = spa_lookup_by_guid(spa, glist[i], B_FALSE);
2032 		if (vd[i] == NULL) {
2033 			/*
2034 			 * Don't bother attempting to reopen the disks;
2035 			 * just do the split.
2036 			 */
2037 			attempt_reopen = B_FALSE;
2038 		} else {
2039 			/* attempt to re-online it */
2040 			vd[i]->vdev_offline = B_FALSE;
2041 		}
2042 	}
2043 
2044 	if (attempt_reopen) {
2045 		vdev_reopen(spa->spa_root_vdev);
2046 
2047 		/* check each device to see what state it's in */
2048 		for (extracted = 0, i = 0; i < gcount; i++) {
2049 			if (vd[i] != NULL &&
2050 			    vd[i]->vdev_stat.vs_aux != VDEV_AUX_SPLIT_POOL)
2051 				break;
2052 			++extracted;
2053 		}
2054 	}
2055 
2056 	/*
2057 	 * If every disk has been moved to the new pool, or if we never
2058 	 * even attempted to look at them, then we split them off for
2059 	 * good.
2060 	 */
2061 	if (!attempt_reopen || gcount == extracted) {
2062 		for (i = 0; i < gcount; i++)
2063 			if (vd[i] != NULL)
2064 				vdev_split(vd[i]);
2065 		vdev_reopen(spa->spa_root_vdev);
2066 	}
2067 
2068 	kmem_free(vd, gcount * sizeof (vdev_t *));
2069 }
2070 
2071 static int
2072 spa_load(spa_t *spa, spa_load_state_t state, spa_import_type_t type,
2073     boolean_t mosconfig)
2074 {
2075 	nvlist_t *config = spa->spa_config;
2076 	char *ereport = FM_EREPORT_ZFS_POOL;
2077 	char *comment;
2078 	int error;
2079 	uint64_t pool_guid;
2080 	nvlist_t *nvl;
2081 
2082 	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid))
2083 		return (SET_ERROR(EINVAL));
2084 
2085 	ASSERT(spa->spa_comment == NULL);
2086 	if (nvlist_lookup_string(config, ZPOOL_CONFIG_COMMENT, &comment) == 0)
2087 		spa->spa_comment = spa_strdup(comment);
2088 
2089 	/*
2090 	 * Versioning wasn't explicitly added to the label until later, so if
2091 	 * it's not present treat it as the initial version.
2092 	 */
2093 	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
2094 	    &spa->spa_ubsync.ub_version) != 0)
2095 		spa->spa_ubsync.ub_version = SPA_VERSION_INITIAL;
2096 
2097 	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG,
2098 	    &spa->spa_config_txg);
2099 
2100 	if ((state == SPA_LOAD_IMPORT || state == SPA_LOAD_TRYIMPORT) &&
2101 	    spa_guid_exists(pool_guid, 0)) {
2102 		error = SET_ERROR(EEXIST);
2103 	} else {
2104 		spa->spa_config_guid = pool_guid;
2105 
2106 		if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_SPLIT,
2107 		    &nvl) == 0) {
2108 			VERIFY(nvlist_dup(nvl, &spa->spa_config_splitting,
2109 			    KM_SLEEP) == 0);
2110 		}
2111 
2112 		nvlist_free(spa->spa_load_info);
2113 		spa->spa_load_info = fnvlist_alloc();
2114 
2115 		gethrestime(&spa->spa_loaded_ts);
2116 		error = spa_load_impl(spa, pool_guid, config, state, type,
2117 		    mosconfig, &ereport);
2118 	}
2119 
2120 	/*
2121 	 * Don't count references from objsets that are already closed
2122 	 * and are making their way through the eviction process.
2123 	 */
2124 	spa_evicting_os_wait(spa);
2125 	spa->spa_minref = refcount_count(&spa->spa_refcount);
2126 	if (error) {
2127 		if (error != EEXIST) {
2128 			spa->spa_loaded_ts.tv_sec = 0;
2129 			spa->spa_loaded_ts.tv_nsec = 0;
2130 		}
2131 		if (error != EBADF) {
2132 			zfs_ereport_post(ereport, spa, NULL, NULL, 0, 0);
2133 		}
2134 	}
2135 	spa->spa_load_state = error ? SPA_LOAD_ERROR : SPA_LOAD_NONE;
2136 	spa->spa_ena = 0;
2137 
2138 	return (error);
2139 }
2140 
2141 /*
2142  * Load an existing storage pool, using the pool's builtin spa_config as a
2143  * source of configuration information.
2144  */
2145 static int
2146 spa_load_impl(spa_t *spa, uint64_t pool_guid, nvlist_t *config,
2147     spa_load_state_t state, spa_import_type_t type, boolean_t mosconfig,
2148     char **ereport)
2149 {
2150 	int error = 0;
2151 	nvlist_t *nvroot = NULL;
2152 	nvlist_t *label;
2153 	vdev_t *rvd;
2154 	uberblock_t *ub = &spa->spa_uberblock;
2155 	uint64_t children, config_cache_txg = spa->spa_config_txg;
2156 	int orig_mode = spa->spa_mode;
2157 	int parse;
2158 	uint64_t obj;
2159 	boolean_t missing_feat_write = B_FALSE;
2160 
2161 	/*
2162 	 * If this is an untrusted config, access the pool in read-only mode.
2163 	 * This prevents things like resilvering recently removed devices.
2164 	 */
2165 	if (!mosconfig)
2166 		spa->spa_mode = FREAD;
2167 
2168 	ASSERT(MUTEX_HELD(&spa_namespace_lock));
2169 
2170 	spa->spa_load_state = state;
2171 
2172 	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvroot))
2173 		return (SET_ERROR(EINVAL));
2174 
2175 	parse = (type == SPA_IMPORT_EXISTING ?
2176 	    VDEV_ALLOC_LOAD : VDEV_ALLOC_SPLIT);
2177 
2178 	/*
2179 	 * Create "The Godfather" zio to hold all async IOs
2180 	 */
2181 	spa->spa_async_zio_root = kmem_alloc(max_ncpus * sizeof (void *),
2182 	    KM_SLEEP);
2183 	for (int i = 0; i < max_ncpus; i++) {
2184 		spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL,
2185 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE |
2186 		    ZIO_FLAG_GODFATHER);
2187 	}
2188 
2189 	/*
2190 	 * Parse the configuration into a vdev tree.  We explicitly set the
2191 	 * value that will be returned by spa_version() since parsing the
2192 	 * configuration requires knowing the version number.
2193 	 */
2194 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2195 	error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, parse);
2196 	spa_config_exit(spa, SCL_ALL, FTAG);
2197 
2198 	if (error != 0)
2199 		return (error);
2200 
2201 	ASSERT(spa->spa_root_vdev == rvd);
2202 	ASSERT3U(spa->spa_min_ashift, >=, SPA_MINBLOCKSHIFT);
2203 	ASSERT3U(spa->spa_max_ashift, <=, SPA_MAXBLOCKSHIFT);
2204 
2205 	if (type != SPA_IMPORT_ASSEMBLE) {
2206 		ASSERT(spa_guid(spa) == pool_guid);
2207 	}
2208 
2209 	/*
2210 	 * Try to open all vdevs, loading each label in the process.
2211 	 */
2212 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2213 	error = vdev_open(rvd);
2214 	spa_config_exit(spa, SCL_ALL, FTAG);
2215 	if (error != 0)
2216 		return (error);
2217 
2218 	/*
2219 	 * We need to validate the vdev labels against the configuration that
2220 	 * we have in hand, which is dependent on the setting of mosconfig. If
2221 	 * mosconfig is true then we're validating the vdev labels based on
2222 	 * that config.  Otherwise, we're validating against the cached config
2223 	 * (zpool.cache) that was read when we loaded the zfs module, and then
2224 	 * later we will recursively call spa_load() and validate against
2225 	 * the vdev config.
2226 	 *
2227 	 * If we're assembling a new pool that's been split off from an
2228 	 * existing pool, the labels haven't yet been updated so we skip
2229 	 * validation for now.
2230 	 */
2231 	if (type != SPA_IMPORT_ASSEMBLE) {
2232 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2233 		error = vdev_validate(rvd, mosconfig);
2234 		spa_config_exit(spa, SCL_ALL, FTAG);
2235 
2236 		if (error != 0)
2237 			return (error);
2238 
2239 		if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN)
2240 			return (SET_ERROR(ENXIO));
2241 	}
2242 
2243 	/*
2244 	 * Find the best uberblock.
2245 	 */
2246 	vdev_uberblock_load(rvd, ub, &label);
2247 
2248 	/*
2249 	 * If we weren't able to find a single valid uberblock, return failure.
2250 	 */
2251 	if (ub->ub_txg == 0) {
2252 		nvlist_free(label);
2253 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, ENXIO));
2254 	}
2255 
2256 	/*
2257 	 * If the pool has an unsupported version we can't open it.
2258 	 */
2259 	if (!SPA_VERSION_IS_SUPPORTED(ub->ub_version)) {
2260 		nvlist_free(label);
2261 		return (spa_vdev_err(rvd, VDEV_AUX_VERSION_NEWER, ENOTSUP));
2262 	}
2263 
2264 	if (ub->ub_version >= SPA_VERSION_FEATURES) {
2265 		nvlist_t *features;
2266 
2267 		/*
2268 		 * If we weren't able to find what's necessary for reading the
2269 		 * MOS in the label, return failure.
2270 		 */
2271 		if (label == NULL || nvlist_lookup_nvlist(label,
2272 		    ZPOOL_CONFIG_FEATURES_FOR_READ, &features) != 0) {
2273 			nvlist_free(label);
2274 			return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA,
2275 			    ENXIO));
2276 		}
2277 
2278 		/*
2279 		 * Update our in-core representation with the definitive values
2280 		 * from the label.
2281 		 */
2282 		nvlist_free(spa->spa_label_features);
2283 		VERIFY(nvlist_dup(features, &spa->spa_label_features, 0) == 0);
2284 	}
2285 
2286 	nvlist_free(label);
2287 
2288 	/*
2289 	 * Look through entries in the label nvlist's features_for_read. If
2290 	 * there is a feature listed there which we don't understand then we
2291 	 * cannot open a pool.
2292 	 */
2293 	if (ub->ub_version >= SPA_VERSION_FEATURES) {
2294 		nvlist_t *unsup_feat;
2295 
2296 		VERIFY(nvlist_alloc(&unsup_feat, NV_UNIQUE_NAME, KM_SLEEP) ==
2297 		    0);
2298 
2299 		for (nvpair_t *nvp = nvlist_next_nvpair(spa->spa_label_features,
2300 		    NULL); nvp != NULL;
2301 		    nvp = nvlist_next_nvpair(spa->spa_label_features, nvp)) {
2302 			if (!zfeature_is_supported(nvpair_name(nvp))) {
2303 				VERIFY(nvlist_add_string(unsup_feat,
2304 				    nvpair_name(nvp), "") == 0);
2305 			}
2306 		}
2307 
2308 		if (!nvlist_empty(unsup_feat)) {
2309 			VERIFY(nvlist_add_nvlist(spa->spa_load_info,
2310 			    ZPOOL_CONFIG_UNSUP_FEAT, unsup_feat) == 0);
2311 			nvlist_free(unsup_feat);
2312 			return (spa_vdev_err(rvd, VDEV_AUX_UNSUP_FEAT,
2313 			    ENOTSUP));
2314 		}
2315 
2316 		nvlist_free(unsup_feat);
2317 	}
2318 
2319 	/*
2320 	 * If the vdev guid sum doesn't match the uberblock, we have an
2321 	 * incomplete configuration.  We first check to see if the pool
2322 	 * is aware of the complete config (i.e ZPOOL_CONFIG_VDEV_CHILDREN).
2323 	 * If it is, defer the vdev_guid_sum check till later so we
2324 	 * can handle missing vdevs.
2325 	 */
2326 	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_VDEV_CHILDREN,
2327 	    &children) != 0 && mosconfig && type != SPA_IMPORT_ASSEMBLE &&
2328 	    rvd->vdev_guid_sum != ub->ub_guid_sum)
2329 		return (spa_vdev_err(rvd, VDEV_AUX_BAD_GUID_SUM, ENXIO));
2330 
2331 	if (type != SPA_IMPORT_ASSEMBLE && spa->spa_config_splitting) {
2332 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2333 		spa_try_repair(spa, config);
2334 		spa_config_exit(spa, SCL_ALL, FTAG);
2335 		nvlist_free(spa->spa_config_splitting);
2336 		spa->spa_config_splitting = NULL;
2337 	}
2338 
2339 	/*
2340 	 * Initialize internal SPA structures.
2341 	 */
2342 	spa->spa_state = POOL_STATE_ACTIVE;
2343 	spa->spa_ubsync = spa->spa_uberblock;
2344 	spa->spa_verify_min_txg = spa->spa_extreme_rewind ?
2345 	    TXG_INITIAL - 1 : spa_last_synced_txg(spa) - TXG_DEFER_SIZE - 1;
2346 	spa->spa_first_txg = spa->spa_last_ubsync_txg ?
2347 	    spa->spa_last_ubsync_txg : spa_last_synced_txg(spa) + 1;
2348 	spa->spa_claim_max_txg = spa->spa_first_txg;
2349 	spa->spa_prev_software_version = ub->ub_software_version;
2350 
2351 	error = dsl_pool_init(spa, spa->spa_first_txg, &spa->spa_dsl_pool);
2352 	if (error)
2353 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2354 	spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset;
2355 
2356 	if (spa_dir_prop(spa, DMU_POOL_CONFIG, &spa->spa_config_object) != 0)
2357 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2358 
2359 	if (spa_version(spa) >= SPA_VERSION_FEATURES) {
2360 		boolean_t missing_feat_read = B_FALSE;
2361 		nvlist_t *unsup_feat, *enabled_feat;
2362 
2363 		if (spa_dir_prop(spa, DMU_POOL_FEATURES_FOR_READ,
2364 		    &spa->spa_feat_for_read_obj) != 0) {
2365 			return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2366 		}
2367 
2368 		if (spa_dir_prop(spa, DMU_POOL_FEATURES_FOR_WRITE,
2369 		    &spa->spa_feat_for_write_obj) != 0) {
2370 			return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2371 		}
2372 
2373 		if (spa_dir_prop(spa, DMU_POOL_FEATURE_DESCRIPTIONS,
2374 		    &spa->spa_feat_desc_obj) != 0) {
2375 			return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2376 		}
2377 
2378 		enabled_feat = fnvlist_alloc();
2379 		unsup_feat = fnvlist_alloc();
2380 
2381 		if (!spa_features_check(spa, B_FALSE,
2382 		    unsup_feat, enabled_feat))
2383 			missing_feat_read = B_TRUE;
2384 
2385 		if (spa_writeable(spa) || state == SPA_LOAD_TRYIMPORT) {
2386 			if (!spa_features_check(spa, B_TRUE,
2387 			    unsup_feat, enabled_feat)) {
2388 				missing_feat_write = B_TRUE;
2389 			}
2390 		}
2391 
2392 		fnvlist_add_nvlist(spa->spa_load_info,
2393 		    ZPOOL_CONFIG_ENABLED_FEAT, enabled_feat);
2394 
2395 		if (!nvlist_empty(unsup_feat)) {
2396 			fnvlist_add_nvlist(spa->spa_load_info,
2397 			    ZPOOL_CONFIG_UNSUP_FEAT, unsup_feat);
2398 		}
2399 
2400 		fnvlist_free(enabled_feat);
2401 		fnvlist_free(unsup_feat);
2402 
2403 		if (!missing_feat_read) {
2404 			fnvlist_add_boolean(spa->spa_load_info,
2405 			    ZPOOL_CONFIG_CAN_RDONLY);
2406 		}
2407 
2408 		/*
2409 		 * If the state is SPA_LOAD_TRYIMPORT, our objective is
2410 		 * twofold: to determine whether the pool is available for
2411 		 * import in read-write mode and (if it is not) whether the
2412 		 * pool is available for import in read-only mode. If the pool
2413 		 * is available for import in read-write mode, it is displayed
2414 		 * as available in userland; if it is not available for import
2415 		 * in read-only mode, it is displayed as unavailable in
2416 		 * userland. If the pool is available for import in read-only
2417 		 * mode but not read-write mode, it is displayed as unavailable
2418 		 * in userland with a special note that the pool is actually
2419 		 * available for open in read-only mode.
2420 		 *
2421 		 * As a result, if the state is SPA_LOAD_TRYIMPORT and we are
2422 		 * missing a feature for write, we must first determine whether
2423 		 * the pool can be opened read-only before returning to
2424 		 * userland in order to know whether to display the
2425 		 * abovementioned note.
2426 		 */
2427 		if (missing_feat_read || (missing_feat_write &&
2428 		    spa_writeable(spa))) {
2429 			return (spa_vdev_err(rvd, VDEV_AUX_UNSUP_FEAT,
2430 			    ENOTSUP));
2431 		}
2432 
2433 		/*
2434 		 * Load refcounts for ZFS features from disk into an in-memory
2435 		 * cache during SPA initialization.
2436 		 */
2437 		for (spa_feature_t i = 0; i < SPA_FEATURES; i++) {
2438 			uint64_t refcount;
2439 
2440 			error = feature_get_refcount_from_disk(spa,
2441 			    &spa_feature_table[i], &refcount);
2442 			if (error == 0) {
2443 				spa->spa_feat_refcount_cache[i] = refcount;
2444 			} else if (error == ENOTSUP) {
2445 				spa->spa_feat_refcount_cache[i] =
2446 				    SPA_FEATURE_DISABLED;
2447 			} else {
2448 				return (spa_vdev_err(rvd,
2449 				    VDEV_AUX_CORRUPT_DATA, EIO));
2450 			}
2451 		}
2452 	}
2453 
2454 	if (spa_feature_is_active(spa, SPA_FEATURE_ENABLED_TXG)) {
2455 		if (spa_dir_prop(spa, DMU_POOL_FEATURE_ENABLED_TXG,
2456 		    &spa->spa_feat_enabled_txg_obj) != 0)
2457 			return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2458 	}
2459 
2460 	spa->spa_is_initializing = B_TRUE;
2461 	error = dsl_pool_open(spa->spa_dsl_pool);
2462 	spa->spa_is_initializing = B_FALSE;
2463 	if (error != 0)
2464 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2465 
2466 	if (!mosconfig) {
2467 		uint64_t hostid;
2468 		nvlist_t *policy = NULL, *nvconfig;
2469 
2470 		if (load_nvlist(spa, spa->spa_config_object, &nvconfig) != 0)
2471 			return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2472 
2473 		if (!spa_is_root(spa) && nvlist_lookup_uint64(nvconfig,
2474 		    ZPOOL_CONFIG_HOSTID, &hostid) == 0) {
2475 			char *hostname;
2476 			unsigned long myhostid = 0;
2477 
2478 			VERIFY(nvlist_lookup_string(nvconfig,
2479 			    ZPOOL_CONFIG_HOSTNAME, &hostname) == 0);
2480 
2481 #ifdef	_KERNEL
2482 			myhostid = zone_get_hostid(NULL);
2483 #else	/* _KERNEL */
2484 			/*
2485 			 * We're emulating the system's hostid in userland, so
2486 			 * we can't use zone_get_hostid().
2487 			 */
2488 			(void) ddi_strtoul(hw_serial, NULL, 10, &myhostid);
2489 #endif	/* _KERNEL */
2490 			if (hostid != 0 && myhostid != 0 &&
2491 			    hostid != myhostid) {
2492 				nvlist_free(nvconfig);
2493 				cmn_err(CE_WARN, "pool '%s' could not be "
2494 				    "loaded as it was last accessed by "
2495 				    "another system (host: %s hostid: 0x%lx). "
2496 				    "See: http://illumos.org/msg/ZFS-8000-EY",
2497 				    spa_name(spa), hostname,
2498 				    (unsigned long)hostid);
2499 				return (SET_ERROR(EBADF));
2500 			}
2501 		}
2502 		if (nvlist_lookup_nvlist(spa->spa_config,
2503 		    ZPOOL_REWIND_POLICY, &policy) == 0)
2504 			VERIFY(nvlist_add_nvlist(nvconfig,
2505 			    ZPOOL_REWIND_POLICY, policy) == 0);
2506 
2507 		spa_config_set(spa, nvconfig);
2508 		spa_unload(spa);
2509 		spa_deactivate(spa);
2510 		spa_activate(spa, orig_mode);
2511 
2512 		return (spa_load(spa, state, SPA_IMPORT_EXISTING, B_TRUE));
2513 	}
2514 
2515 	if (spa_dir_prop(spa, DMU_POOL_SYNC_BPOBJ, &obj) != 0)
2516 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2517 	error = bpobj_open(&spa->spa_deferred_bpobj, spa->spa_meta_objset, obj);
2518 	if (error != 0)
2519 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2520 
2521 	/*
2522 	 * Load the bit that tells us to use the new accounting function
2523 	 * (raid-z deflation).  If we have an older pool, this will not
2524 	 * be present.
2525 	 */
2526 	error = spa_dir_prop(spa, DMU_POOL_DEFLATE, &spa->spa_deflate);
2527 	if (error != 0 && error != ENOENT)
2528 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2529 
2530 	error = spa_dir_prop(spa, DMU_POOL_CREATION_VERSION,
2531 	    &spa->spa_creation_version);
2532 	if (error != 0 && error != ENOENT)
2533 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2534 
2535 	/*
2536 	 * Load the persistent error log.  If we have an older pool, this will
2537 	 * not be present.
2538 	 */
2539 	error = spa_dir_prop(spa, DMU_POOL_ERRLOG_LAST, &spa->spa_errlog_last);
2540 	if (error != 0 && error != ENOENT)
2541 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2542 
2543 	error = spa_dir_prop(spa, DMU_POOL_ERRLOG_SCRUB,
2544 	    &spa->spa_errlog_scrub);
2545 	if (error != 0 && error != ENOENT)
2546 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2547 
2548 	/*
2549 	 * Load the history object.  If we have an older pool, this
2550 	 * will not be present.
2551 	 */
2552 	error = spa_dir_prop(spa, DMU_POOL_HISTORY, &spa->spa_history);
2553 	if (error != 0 && error != ENOENT)
2554 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2555 
2556 	/*
2557 	 * If we're assembling the pool from the split-off vdevs of
2558 	 * an existing pool, we don't want to attach the spares & cache
2559 	 * devices.
2560 	 */
2561 
2562 	/*
2563 	 * Load any hot spares for this pool.
2564 	 */
2565 	error = spa_dir_prop(spa, DMU_POOL_SPARES, &spa->spa_spares.sav_object);
2566 	if (error != 0 && error != ENOENT)
2567 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2568 	if (error == 0 && type != SPA_IMPORT_ASSEMBLE) {
2569 		ASSERT(spa_version(spa) >= SPA_VERSION_SPARES);
2570 		if (load_nvlist(spa, spa->spa_spares.sav_object,
2571 		    &spa->spa_spares.sav_config) != 0)
2572 			return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2573 
2574 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2575 		spa_load_spares(spa);
2576 		spa_config_exit(spa, SCL_ALL, FTAG);
2577 	} else if (error == 0) {
2578 		spa->spa_spares.sav_sync = B_TRUE;
2579 	}
2580 
2581 	/*
2582 	 * Load any level 2 ARC devices for this pool.
2583 	 */
2584 	error = spa_dir_prop(spa, DMU_POOL_L2CACHE,
2585 	    &spa->spa_l2cache.sav_object);
2586 	if (error != 0 && error != ENOENT)
2587 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2588 	if (error == 0 && type != SPA_IMPORT_ASSEMBLE) {
2589 		ASSERT(spa_version(spa) >= SPA_VERSION_L2CACHE);
2590 		if (load_nvlist(spa, spa->spa_l2cache.sav_object,
2591 		    &spa->spa_l2cache.sav_config) != 0)
2592 			return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2593 
2594 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2595 		spa_load_l2cache(spa);
2596 		spa_config_exit(spa, SCL_ALL, FTAG);
2597 	} else if (error == 0) {
2598 		spa->spa_l2cache.sav_sync = B_TRUE;
2599 	}
2600 
2601 	spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION);
2602 
2603 	error = spa_dir_prop(spa, DMU_POOL_PROPS, &spa->spa_pool_props_object);
2604 	if (error && error != ENOENT)
2605 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2606 
2607 	if (error == 0) {
2608 		uint64_t autoreplace;
2609 
2610 		spa_prop_find(spa, ZPOOL_PROP_BOOTFS, &spa->spa_bootfs);
2611 		spa_prop_find(spa, ZPOOL_PROP_AUTOREPLACE, &autoreplace);
2612 		spa_prop_find(spa, ZPOOL_PROP_DELEGATION, &spa->spa_delegation);
2613 		spa_prop_find(spa, ZPOOL_PROP_FAILUREMODE, &spa->spa_failmode);
2614 		spa_prop_find(spa, ZPOOL_PROP_AUTOEXPAND, &spa->spa_autoexpand);
2615 		spa_prop_find(spa, ZPOOL_PROP_DEDUPDITTO,
2616 		    &spa->spa_dedup_ditto);
2617 
2618 		spa->spa_autoreplace = (autoreplace != 0);
2619 	}
2620 
2621 	/*
2622 	 * If the 'autoreplace' property is set, then post a resource notifying
2623 	 * the ZFS DE that it should not issue any faults for unopenable
2624 	 * devices.  We also iterate over the vdevs, and post a sysevent for any
2625 	 * unopenable vdevs so that the normal autoreplace handler can take
2626 	 * over.
2627 	 */
2628 	if (spa->spa_autoreplace && state != SPA_LOAD_TRYIMPORT) {
2629 		spa_check_removed(spa->spa_root_vdev);
2630 		/*
2631 		 * For the import case, this is done in spa_import(), because
2632 		 * at this point we're using the spare definitions from
2633 		 * the MOS config, not necessarily from the userland config.
2634 		 */
2635 		if (state != SPA_LOAD_IMPORT) {
2636 			spa_aux_check_removed(&spa->spa_spares);
2637 			spa_aux_check_removed(&spa->spa_l2cache);
2638 		}
2639 	}
2640 
2641 	/*
2642 	 * Load the vdev state for all toplevel vdevs.
2643 	 */
2644 	vdev_load(rvd);
2645 
2646 	/*
2647 	 * Propagate the leaf DTLs we just loaded all the way up the tree.
2648 	 */
2649 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
2650 	vdev_dtl_reassess(rvd, 0, 0, B_FALSE);
2651 	spa_config_exit(spa, SCL_ALL, FTAG);
2652 
2653 	/*
2654 	 * Load the DDTs (dedup tables).
2655 	 */
2656 	error = ddt_load(spa);
2657 	if (error != 0)
2658 		return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2659 
2660 	spa_update_dspace(spa);
2661 
2662 	/*
2663 	 * Validate the config, using the MOS config to fill in any
2664 	 * information which might be missing.  If we fail to validate
2665 	 * the config then declare the pool unfit for use. If we're
2666 	 * assembling a pool from a split, the log is not transferred
2667 	 * over.
2668 	 */
2669 	if (type != SPA_IMPORT_ASSEMBLE) {
2670 		nvlist_t *nvconfig;
2671 
2672 		if (load_nvlist(spa, spa->spa_config_object, &nvconfig) != 0)
2673 			return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
2674 
2675 		if (!spa_config_valid(spa, nvconfig)) {
2676 			nvlist_free(nvconfig);
2677 			return (spa_vdev_err(rvd, VDEV_AUX_BAD_GUID_SUM,
2678 			    ENXIO));
2679 		}
2680 		nvlist_free(nvconfig);
2681 
2682 		/*
2683 		 * Now that we've validated the config, check the state of the
2684 		 * root vdev.  If it can't be opened, it indicates one or
2685 		 * more toplevel vdevs are faulted.
2686 		 */
2687 		if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN)
2688 			return (SET_ERROR(ENXIO));
2689 
2690 		if (spa_writeable(spa) && spa_check_logs(spa)) {
2691 			*ereport = FM_EREPORT_ZFS_LOG_REPLAY;
2692 			return (spa_vdev_err(rvd, VDEV_AUX_BAD_LOG, ENXIO));
2693 		}
2694 	}
2695 
2696 	if (missing_feat_write) {
2697 		ASSERT(state == SPA_LOAD_TRYIMPORT);
2698 
2699 		/*
2700 		 * At this point, we know that we can open the pool in
2701 		 * read-only mode but not read-write mode. We now have enough
2702 		 * information and can return to userland.
2703 		 */
2704 		return (spa_vdev_err(rvd, VDEV_AUX_UNSUP_FEAT, ENOTSUP));
2705 	}
2706 
2707 	/*
2708 	 * We've successfully opened the pool, verify that we're ready
2709 	 * to start pushing transactions.
2710 	 */
2711 	if (state != SPA_LOAD_TRYIMPORT) {
2712 		if (error = spa_load_verify(spa))
2713 			return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA,
2714 			    error));
2715 	}
2716 
2717 	if (spa_writeable(spa) && (state == SPA_LOAD_RECOVER ||
2718 	    spa->spa_load_max_txg == UINT64_MAX)) {
2719 		dmu_tx_t *tx;
2720 		int need_update = B_FALSE;
2721 		dsl_pool_t *dp = spa_get_dsl(spa);
2722 
2723 		ASSERT(state != SPA_LOAD_TRYIMPORT);
2724 
2725 		/*
2726 		 * Claim log blocks that haven't been committed yet.
2727 		 * This must all happen in a single txg.
2728 		 * Note: spa_claim_max_txg is updated by spa_claim_notify(),
2729 		 * invoked from zil_claim_log_block()'s i/o done callback.
2730 		 * Price of rollback is that we abandon the log.
2731 		 */
2732 		spa->spa_claiming = B_TRUE;
2733 
2734 		tx = dmu_tx_create_assigned(dp, spa_first_txg(spa));
2735 		(void) dmu_objset_find_dp(dp, dp->dp_root_dir_obj,
2736 		    zil_claim, tx, DS_FIND_CHILDREN);
2737 		dmu_tx_commit(tx);
2738 
2739 		spa->spa_claiming = B_FALSE;
2740 
2741 		spa_set_log_state(spa, SPA_LOG_GOOD);
2742 		spa->spa_sync_on = B_TRUE;
2743 		txg_sync_start(spa->spa_dsl_pool);
2744 
2745 		/*
2746 		 * Wait for all claims to sync.  We sync up to the highest
2747 		 * claimed log block birth time so that claimed log blocks
2748 		 * don't appear to be from the future.  spa_claim_max_txg
2749 		 * will have been set for us by either zil_check_log_chain()
2750 		 * (invoked from spa_check_logs()) or zil_claim() above.
2751 		 */
2752 		txg_wait_synced(spa->spa_dsl_pool, spa->spa_claim_max_txg);
2753 
2754 		/*
2755 		 * If the config cache is stale, or we have uninitialized
2756 		 * metaslabs (see spa_vdev_add()), then update the config.
2757 		 *
2758 		 * If this is a verbatim import, trust the current
2759 		 * in-core spa_config and update the disk labels.
2760 		 */
2761 		if (config_cache_txg != spa->spa_config_txg ||
2762 		    state == SPA_LOAD_IMPORT ||
2763 		    state == SPA_LOAD_RECOVER ||
2764 		    (spa->spa_import_flags & ZFS_IMPORT_VERBATIM))
2765 			need_update = B_TRUE;
2766 
2767 		for (int c = 0; c < rvd->vdev_children; c++)
2768 			if (rvd->vdev_child[c]->vdev_ms_array == 0)
2769 				need_update = B_TRUE;
2770 
2771 		/*
2772 		 * Update the config cache asychronously in case we're the
2773 		 * root pool, in which case the config cache isn't writable yet.
2774 		 */
2775 		if (need_update)
2776 			spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
2777 
2778 		/*
2779 		 * Check all DTLs to see if anything needs resilvering.
2780 		 */
2781 		if (!dsl_scan_resilvering(spa->spa_dsl_pool) &&
2782 		    vdev_resilver_needed(rvd, NULL, NULL))
2783 			spa_async_request(spa, SPA_ASYNC_RESILVER);
2784 
2785 		/*
2786 		 * Log the fact that we booted up (so that we can detect if
2787 		 * we rebooted in the middle of an operation).
2788 		 */
2789 		spa_history_log_version(spa, "open");
2790 
2791 		/*
2792 		 * Delete any inconsistent datasets.
2793 		 */
2794 		(void) dmu_objset_find(spa_name(spa),
2795 		    dsl_destroy_inconsistent, NULL, DS_FIND_CHILDREN);
2796 
2797 		/*
2798 		 * Clean up any stale temporary dataset userrefs.
2799 		 */
2800 		dsl_pool_clean_tmp_userrefs(spa->spa_dsl_pool);
2801 	}
2802 
2803 	return (0);
2804 }
2805 
2806 static int
2807 spa_load_retry(spa_t *spa, spa_load_state_t state, int mosconfig)
2808 {
2809 	int mode = spa->spa_mode;
2810 
2811 	spa_unload(spa);
2812 	spa_deactivate(spa);
2813 
2814 	spa->spa_load_max_txg = spa->spa_uberblock.ub_txg - 1;
2815 
2816 	spa_activate(spa, mode);
2817 	spa_async_suspend(spa);
2818 
2819 	return (spa_load(spa, state, SPA_IMPORT_EXISTING, mosconfig));
2820 }
2821 
2822 /*
2823  * If spa_load() fails this function will try loading prior txg's. If
2824  * 'state' is SPA_LOAD_RECOVER and one of these loads succeeds the pool
2825  * will be rewound to that txg. If 'state' is not SPA_LOAD_RECOVER this
2826  * function will not rewind the pool and will return the same error as
2827  * spa_load().
2828  */
2829 static int
2830 spa_load_best(spa_t *spa, spa_load_state_t state, int mosconfig,
2831     uint64_t max_request, int rewind_flags)
2832 {
2833 	nvlist_t *loadinfo = NULL;
2834 	nvlist_t *config = NULL;
2835 	int load_error, rewind_error;
2836 	uint64_t safe_rewind_txg;
2837 	uint64_t min_txg;
2838 
2839 	if (spa->spa_load_txg && state == SPA_LOAD_RECOVER) {
2840 		spa->spa_load_max_txg = spa->spa_load_txg;
2841 		spa_set_log_state(spa, SPA_LOG_CLEAR);
2842 	} else {
2843 		spa->spa_load_max_txg = max_request;
2844 		if (max_request != UINT64_MAX)
2845 			spa->spa_extreme_rewind = B_TRUE;
2846 	}
2847 
2848 	load_error = rewind_error = spa_load(spa, state, SPA_IMPORT_EXISTING,
2849 	    mosconfig);
2850 	if (load_error == 0)
2851 		return (0);
2852 
2853 	if (spa->spa_root_vdev != NULL)
2854 		config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
2855 
2856 	spa->spa_last_ubsync_txg = spa->spa_uberblock.ub_txg;
2857 	spa->spa_last_ubsync_txg_ts = spa->spa_uberblock.ub_timestamp;
2858 
2859 	if (rewind_flags & ZPOOL_NEVER_REWIND) {
2860 		nvlist_free(config);
2861 		return (load_error);
2862 	}
2863 
2864 	if (state == SPA_LOAD_RECOVER) {
2865 		/* Price of rolling back is discarding txgs, including log */
2866 		spa_set_log_state(spa, SPA_LOG_CLEAR);
2867 	} else {
2868 		/*
2869 		 * If we aren't rolling back save the load info from our first
2870 		 * import attempt so that we can restore it after attempting
2871 		 * to rewind.
2872 		 */
2873 		loadinfo = spa->spa_load_info;
2874 		spa->spa_load_info = fnvlist_alloc();
2875 	}
2876 
2877 	spa->spa_load_max_txg = spa->spa_last_ubsync_txg;
2878 	safe_rewind_txg = spa->spa_last_ubsync_txg - TXG_DEFER_SIZE;
2879 	min_txg = (rewind_flags & ZPOOL_EXTREME_REWIND) ?
2880 	    TXG_INITIAL : safe_rewind_txg;
2881 
2882 	/*
2883 	 * Continue as long as we're finding errors, we're still within
2884 	 * the acceptable rewind range, and we're still finding uberblocks
2885 	 */
2886 	while (rewind_error && spa->spa_uberblock.ub_txg >= min_txg &&
2887 	    spa->spa_uberblock.ub_txg <= spa->spa_load_max_txg) {
2888 		if (spa->spa_load_max_txg < safe_rewind_txg)
2889 			spa->spa_extreme_rewind = B_TRUE;
2890 		rewind_error = spa_load_retry(spa, state, mosconfig);
2891 	}
2892 
2893 	spa->spa_extreme_rewind = B_FALSE;
2894 	spa->spa_load_max_txg = UINT64_MAX;
2895 
2896 	if (config && (rewind_error || state != SPA_LOAD_RECOVER))
2897 		spa_config_set(spa, config);
2898 
2899 	if (state == SPA_LOAD_RECOVER) {
2900 		ASSERT3P(loadinfo, ==, NULL);
2901 		return (rewind_error);
2902 	} else {
2903 		/* Store the rewind info as part of the initial load info */
2904 		fnvlist_add_nvlist(loadinfo, ZPOOL_CONFIG_REWIND_INFO,
2905 		    spa->spa_load_info);
2906 
2907 		/* Restore the initial load info */
2908 		fnvlist_free(spa->spa_load_info);
2909 		spa->spa_load_info = loadinfo;
2910 
2911 		return (load_error);
2912 	}
2913 }
2914 
2915 /*
2916  * Pool Open/Import
2917  *
2918  * The import case is identical to an open except that the configuration is sent
2919  * down from userland, instead of grabbed from the configuration cache.  For the
2920  * case of an open, the pool configuration will exist in the
2921  * POOL_STATE_UNINITIALIZED state.
2922  *
2923  * The stats information (gen/count/ustats) is used to gather vdev statistics at
2924  * the same time open the pool, without having to keep around the spa_t in some
2925  * ambiguous state.
2926  */
2927 static int
2928 spa_open_common(const char *pool, spa_t **spapp, void *tag, nvlist_t *nvpolicy,
2929     nvlist_t **config)
2930 {
2931 	spa_t *spa;
2932 	spa_load_state_t state = SPA_LOAD_OPEN;
2933 	int error;
2934 	int locked = B_FALSE;
2935 
2936 	*spapp = NULL;
2937 
2938 	/*
2939 	 * As disgusting as this is, we need to support recursive calls to this
2940 	 * function because dsl_dir_open() is called during spa_load(), and ends
2941 	 * up calling spa_open() again.  The real fix is to figure out how to
2942 	 * avoid dsl_dir_open() calling this in the first place.
2943 	 */
2944 	if (mutex_owner(&spa_namespace_lock) != curthread) {
2945 		mutex_enter(&spa_namespace_lock);
2946 		locked = B_TRUE;
2947 	}
2948 
2949 	if ((spa = spa_lookup(pool)) == NULL) {
2950 		if (locked)
2951 			mutex_exit(&spa_namespace_lock);
2952 		return (SET_ERROR(ENOENT));
2953 	}
2954 
2955 	if (spa->spa_state == POOL_STATE_UNINITIALIZED) {
2956 		zpool_rewind_policy_t policy;
2957 
2958 		zpool_get_rewind_policy(nvpolicy ? nvpolicy : spa->spa_config,
2959 		    &policy);
2960 		if (policy.zrp_request & ZPOOL_DO_REWIND)
2961 			state = SPA_LOAD_RECOVER;
2962 
2963 		spa_activate(spa, spa_mode_global);
2964 
2965 		if (state != SPA_LOAD_RECOVER)
2966 			spa->spa_last_ubsync_txg = spa->spa_load_txg = 0;
2967 
2968 		error = spa_load_best(spa, state, B_FALSE, policy.zrp_txg,
2969 		    policy.zrp_request);
2970 
2971 		if (error == EBADF) {
2972 			/*
2973 			 * If vdev_validate() returns failure (indicated by
2974 			 * EBADF), it indicates that one of the vdevs indicates
2975 			 * that the pool has been exported or destroyed.  If
2976 			 * this is the case, the config cache is out of sync and
2977 			 * we should remove the pool from the namespace.
2978 			 */
2979 			spa_unload(spa);
2980 			spa_deactivate(spa);
2981 			spa_config_sync(spa, B_TRUE, B_TRUE);
2982 			spa_remove(spa);
2983 			if (locked)
2984 				mutex_exit(&spa_namespace_lock);
2985 			return (SET_ERROR(ENOENT));
2986 		}
2987 
2988 		if (error) {
2989 			/*
2990 			 * We can't open the pool, but we still have useful
2991 			 * information: the state of each vdev after the
2992 			 * attempted vdev_open().  Return this to the user.
2993 			 */
2994 			if (config != NULL && spa->spa_config) {
2995 				VERIFY(nvlist_dup(spa->spa_config, config,
2996 				    KM_SLEEP) == 0);
2997 				VERIFY(nvlist_add_nvlist(*config,
2998 				    ZPOOL_CONFIG_LOAD_INFO,
2999 				    spa->spa_load_info) == 0);
3000 			}
3001 			spa_unload(spa);
3002 			spa_deactivate(spa);
3003 			spa->spa_last_open_failed = error;
3004 			if (locked)
3005 				mutex_exit(&spa_namespace_lock);
3006 			*spapp = NULL;
3007 			return (error);
3008 		}
3009 	}
3010 
3011 	spa_open_ref(spa, tag);
3012 
3013 	if (config != NULL)
3014 		*config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
3015 
3016 	/*
3017 	 * If we've recovered the pool, pass back any information we
3018 	 * gathered while doing the load.
3019 	 */
3020 	if (state == SPA_LOAD_RECOVER) {
3021 		VERIFY(nvlist_add_nvlist(*config, ZPOOL_CONFIG_LOAD_INFO,
3022 		    spa->spa_load_info) == 0);
3023 	}
3024 
3025 	if (locked) {
3026 		spa->spa_last_open_failed = 0;
3027 		spa->spa_last_ubsync_txg = 0;
3028 		spa->spa_load_txg = 0;
3029 		mutex_exit(&spa_namespace_lock);
3030 	}
3031 
3032 	*spapp = spa;
3033 
3034 	return (0);
3035 }
3036 
3037 int
3038 spa_open_rewind(const char *name, spa_t **spapp, void *tag, nvlist_t *policy,
3039     nvlist_t **config)
3040 {
3041 	return (spa_open_common(name, spapp, tag, policy, config));
3042 }
3043 
3044 int
3045 spa_open(const char *name, spa_t **spapp, void *tag)
3046 {
3047 	return (spa_open_common(name, spapp, tag, NULL, NULL));
3048 }
3049 
3050 /*
3051  * Lookup the given spa_t, incrementing the inject count in the process,
3052  * preventing it from being exported or destroyed.
3053  */
3054 spa_t *
3055 spa_inject_addref(char *name)
3056 {
3057 	spa_t *spa;
3058 
3059 	mutex_enter(&spa_namespace_lock);
3060 	if ((spa = spa_lookup(name)) == NULL) {
3061 		mutex_exit(&spa_namespace_lock);
3062 		return (NULL);
3063 	}
3064 	spa->spa_inject_ref++;
3065 	mutex_exit(&spa_namespace_lock);
3066 
3067 	return (spa);
3068 }
3069 
3070 void
3071 spa_inject_delref(spa_t *spa)
3072 {
3073 	mutex_enter(&spa_namespace_lock);
3074 	spa->spa_inject_ref--;
3075 	mutex_exit(&spa_namespace_lock);
3076 }
3077 
3078 /*
3079  * Add spares device information to the nvlist.
3080  */
3081 static void
3082 spa_add_spares(spa_t *spa, nvlist_t *config)
3083 {
3084 	nvlist_t **spares;
3085 	uint_t i, nspares;
3086 	nvlist_t *nvroot;
3087 	uint64_t guid;
3088 	vdev_stat_t *vs;
3089 	uint_t vsc;
3090 	uint64_t pool;
3091 
3092 	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));
3093 
3094 	if (spa->spa_spares.sav_count == 0)
3095 		return;
3096 
3097 	VERIFY(nvlist_lookup_nvlist(config,
3098 	    ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
3099 	VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
3100 	    ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);
3101 	if (nspares != 0) {
3102 		VERIFY(nvlist_add_nvlist_array(nvroot,
3103 		    ZPOOL_CONFIG_SPARES, spares, nspares) == 0);
3104 		VERIFY(nvlist_lookup_nvlist_array(nvroot,
3105 		    ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);
3106 
3107 		/*
3108 		 * Go through and find any spares which have since been
3109 		 * repurposed as an active spare.  If this is the case, update
3110 		 * their status appropriately.
3111 		 */
3112 		for (i = 0; i < nspares; i++) {
3113 			VERIFY(nvlist_lookup_uint64(spares[i],
3114 			    ZPOOL_CONFIG_GUID, &guid) == 0);
3115 			if (spa_spare_exists(guid, &pool, NULL) &&
3116 			    pool != 0ULL) {
3117 				VERIFY(nvlist_lookup_uint64_array(
3118 				    spares[i], ZPOOL_CONFIG_VDEV_STATS,
3119 				    (uint64_t **)&vs, &vsc) == 0);
3120 				vs->vs_state = VDEV_STATE_CANT_OPEN;
3121 				vs->vs_aux = VDEV_AUX_SPARED;
3122 			}
3123 		}
3124 	}
3125 }
3126 
3127 /*
3128  * Add l2cache device information to the nvlist, including vdev stats.
3129  */
3130 static void
3131 spa_add_l2cache(spa_t *spa, nvlist_t *config)
3132 {
3133 	nvlist_t **l2cache;
3134 	uint_t i, j, nl2cache;
3135 	nvlist_t *nvroot;
3136 	uint64_t guid;
3137 	vdev_t *vd;
3138 	vdev_stat_t *vs;
3139 	uint_t vsc;
3140 
3141 	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));
3142 
3143 	if (spa->spa_l2cache.sav_count == 0)
3144 		return;
3145 
3146 	VERIFY(nvlist_lookup_nvlist(config,
3147 	    ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
3148 	VERIFY(nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config,
3149 	    ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0);
3150 	if (nl2cache != 0) {
3151 		VERIFY(nvlist_add_nvlist_array(nvroot,
3152 		    ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0);
3153 		VERIFY(nvlist_lookup_nvlist_array(nvroot,
3154 		    ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0);
3155 
3156 		/*
3157 		 * Update level 2 cache device stats.
3158 		 */
3159 
3160 		for (i = 0; i < nl2cache; i++) {
3161 			VERIFY(nvlist_lookup_uint64(l2cache[i],
3162 			    ZPOOL_CONFIG_GUID, &guid) == 0);
3163 
3164 			vd = NULL;
3165 			for (j = 0; j < spa->spa_l2cache.sav_count; j++) {
3166 				if (guid ==
3167 				    spa->spa_l2cache.sav_vdevs[j]->vdev_guid) {
3168 					vd = spa->spa_l2cache.sav_vdevs[j];
3169 					break;
3170 				}
3171 			}
3172 			ASSERT(vd != NULL);
3173 
3174 			VERIFY(nvlist_lookup_uint64_array(l2cache[i],
3175 			    ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&vs, &vsc)
3176 			    == 0);
3177 			vdev_get_stats(vd, vs);
3178 		}
3179 	}
3180 }
3181 
3182 static void
3183 spa_add_feature_stats(spa_t *spa, nvlist_t *config)
3184 {
3185 	nvlist_t *features;
3186 	zap_cursor_t zc;
3187 	zap_attribute_t za;
3188 
3189 	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));
3190 	VERIFY(nvlist_alloc(&features, NV_UNIQUE_NAME, KM_SLEEP) == 0);
3191 
3192 	if (spa->spa_feat_for_read_obj != 0) {
3193 		for (zap_cursor_init(&zc, spa->spa_meta_objset,
3194 		    spa->spa_feat_for_read_obj);
3195 		    zap_cursor_retrieve(&zc, &za) == 0;
3196 		    zap_cursor_advance(&zc)) {
3197 			ASSERT(za.za_integer_length == sizeof (uint64_t) &&
3198 			    za.za_num_integers == 1);
3199 			VERIFY3U(0, ==, nvlist_add_uint64(features, za.za_name,
3200 			    za.za_first_integer));
3201 		}
3202 		zap_cursor_fini(&zc);
3203 	}
3204 
3205 	if (spa->spa_feat_for_write_obj != 0) {
3206 		for (zap_cursor_init(&zc, spa->spa_meta_objset,
3207 		    spa->spa_feat_for_write_obj);
3208 		    zap_cursor_retrieve(&zc, &za) == 0;
3209 		    zap_cursor_advance(&zc)) {
3210 			ASSERT(za.za_integer_length == sizeof (uint64_t) &&
3211 			    za.za_num_integers == 1);
3212 			VERIFY3U(0, ==, nvlist_add_uint64(features, za.za_name,
3213 			    za.za_first_integer));
3214 		}
3215 		zap_cursor_fini(&zc);
3216 	}
3217 
3218 	VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_FEATURE_STATS,
3219 	    features) == 0);
3220 	nvlist_free(features);
3221 }
3222 
3223 int
3224 spa_get_stats(const char *name, nvlist_t **config,
3225     char *altroot, size_t buflen)
3226 {
3227 	int error;
3228 	spa_t *spa;
3229 
3230 	*config = NULL;
3231 	error = spa_open_common(name, &spa, FTAG, NULL, config);
3232 
3233 	if (spa != NULL) {
3234 		/*
3235 		 * This still leaves a window of inconsistency where the spares
3236 		 * or l2cache devices could change and the config would be
3237 		 * self-inconsistent.
3238 		 */
3239 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
3240 
3241 		if (*config != NULL) {
3242 			uint64_t loadtimes[2];
3243 
3244 			loadtimes[0] = spa->spa_loaded_ts.tv_sec;
3245 			loadtimes[1] = spa->spa_loaded_ts.tv_nsec;
3246 			VERIFY(nvlist_add_uint64_array(*config,
3247 			    ZPOOL_CONFIG_LOADED_TIME, loadtimes, 2) == 0);
3248 
3249 			VERIFY(nvlist_add_uint64(*config,
3250 			    ZPOOL_CONFIG_ERRCOUNT,
3251 			    spa_get_errlog_size(spa)) == 0);
3252 
3253 			if (spa_suspended(spa))
3254 				VERIFY(nvlist_add_uint64(*config,
3255 				    ZPOOL_CONFIG_SUSPENDED,
3256 				    spa->spa_failmode) == 0);
3257 
3258 			spa_add_spares(spa, *config);
3259 			spa_add_l2cache(spa, *config);
3260 			spa_add_feature_stats(spa, *config);
3261 		}
3262 	}
3263 
3264 	/*
3265 	 * We want to get the alternate root even for faulted pools, so we cheat
3266 	 * and call spa_lookup() directly.
3267 	 */
3268 	if (altroot) {
3269 		if (spa == NULL) {
3270 			mutex_enter(&spa_namespace_lock);
3271 			spa = spa_lookup(name);
3272 			if (spa)
3273 				spa_altroot(spa, altroot, buflen);
3274 			else
3275 				altroot[0] = '\0';
3276 			spa = NULL;
3277 			mutex_exit(&spa_namespace_lock);
3278 		} else {
3279 			spa_altroot(spa, altroot, buflen);
3280 		}
3281 	}
3282 
3283 	if (spa != NULL) {
3284 		spa_config_exit(spa, SCL_CONFIG, FTAG);
3285 		spa_close(spa, FTAG);
3286 	}
3287 
3288 	return (error);
3289 }
3290 
3291 /*
3292  * Validate that the auxiliary device array is well formed.  We must have an
3293  * array of nvlists, each which describes a valid leaf vdev.  If this is an
3294  * import (mode is VDEV_ALLOC_SPARE), then we allow corrupted spares to be
3295  * specified, as long as they are well-formed.
3296  */
3297 static int
3298 spa_validate_aux_devs(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode,
3299     spa_aux_vdev_t *sav, const char *config, uint64_t version,
3300     vdev_labeltype_t label)
3301 {
3302 	nvlist_t **dev;
3303 	uint_t i, ndev;
3304 	vdev_t *vd;
3305 	int error;
3306 
3307 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
3308 
3309 	/*
3310 	 * It's acceptable to have no devs specified.
3311 	 */
3312 	if (nvlist_lookup_nvlist_array(nvroot, config, &dev, &ndev) != 0)
3313 		return (0);
3314 
3315 	if (ndev == 0)
3316 		return (SET_ERROR(EINVAL));
3317 
3318 	/*
3319 	 * Make sure the pool is formatted with a version that supports this
3320 	 * device type.
3321 	 */
3322 	if (spa_version(spa) < version)
3323 		return (SET_ERROR(ENOTSUP));
3324 
3325 	/*
3326 	 * Set the pending device list so we correctly handle device in-use
3327 	 * checking.
3328 	 */
3329 	sav->sav_pending = dev;
3330 	sav->sav_npending = ndev;
3331 
3332 	for (i = 0; i < ndev; i++) {
3333 		if ((error = spa_config_parse(spa, &vd, dev[i], NULL, 0,
3334 		    mode)) != 0)
3335 			goto out;
3336 
3337 		if (!vd->vdev_ops->vdev_op_leaf) {
3338 			vdev_free(vd);
3339 			error = SET_ERROR(EINVAL);
3340 			goto out;
3341 		}
3342 
3343 		/*
3344 		 * The L2ARC currently only supports disk devices in
3345 		 * kernel context.  For user-level testing, we allow it.
3346 		 */
3347 #ifdef _KERNEL
3348 		if ((strcmp(config, ZPOOL_CONFIG_L2CACHE) == 0) &&
3349 		    strcmp(vd->vdev_ops->vdev_op_type, VDEV_TYPE_DISK) != 0) {
3350 			error = SET_ERROR(ENOTBLK);
3351 			vdev_free(vd);
3352 			goto out;
3353 		}
3354 #endif
3355 		vd->vdev_top = vd;
3356 
3357 		if ((error = vdev_open(vd)) == 0 &&
3358 		    (error = vdev_label_init(vd, crtxg, label)) == 0) {
3359 			VERIFY(nvlist_add_uint64(dev[i], ZPOOL_CONFIG_GUID,
3360 			    vd->vdev_guid) == 0);
3361 		}
3362 
3363 		vdev_free(vd);
3364 
3365 		if (error &&
3366 		    (mode != VDEV_ALLOC_SPARE && mode != VDEV_ALLOC_L2CACHE))
3367 			goto out;
3368 		else
3369 			error = 0;
3370 	}
3371 
3372 out:
3373 	sav->sav_pending = NULL;
3374 	sav->sav_npending = 0;
3375 	return (error);
3376 }
3377 
3378 static int
3379 spa_validate_aux(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode)
3380 {
3381 	int error;
3382 
3383 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
3384 
3385 	if ((error = spa_validate_aux_devs(spa, nvroot, crtxg, mode,
3386 	    &spa->spa_spares, ZPOOL_CONFIG_SPARES, SPA_VERSION_SPARES,
3387 	    VDEV_LABEL_SPARE)) != 0) {
3388 		return (error);
3389 	}
3390 
3391 	return (spa_validate_aux_devs(spa, nvroot, crtxg, mode,
3392 	    &spa->spa_l2cache, ZPOOL_CONFIG_L2CACHE, SPA_VERSION_L2CACHE,
3393 	    VDEV_LABEL_L2CACHE));
3394 }
3395 
3396 static void
3397 spa_set_aux_vdevs(spa_aux_vdev_t *sav, nvlist_t **devs, int ndevs,
3398     const char *config)
3399 {
3400 	int i;
3401 
3402 	if (sav->sav_config != NULL) {
3403 		nvlist_t **olddevs;
3404 		uint_t oldndevs;
3405 		nvlist_t **newdevs;
3406 
3407 		/*
3408 		 * Generate new dev list by concatentating with the
3409 		 * current dev list.
3410 		 */
3411 		VERIFY(nvlist_lookup_nvlist_array(sav->sav_config, config,
3412 		    &olddevs, &oldndevs) == 0);
3413 
3414 		newdevs = kmem_alloc(sizeof (void *) *
3415 		    (ndevs + oldndevs), KM_SLEEP);
3416 		for (i = 0; i < oldndevs; i++)
3417 			VERIFY(nvlist_dup(olddevs[i], &newdevs[i],
3418 			    KM_SLEEP) == 0);
3419 		for (i = 0; i < ndevs; i++)
3420 			VERIFY(nvlist_dup(devs[i], &newdevs[i + oldndevs],
3421 			    KM_SLEEP) == 0);
3422 
3423 		VERIFY(nvlist_remove(sav->sav_config, config,
3424 		    DATA_TYPE_NVLIST_ARRAY) == 0);
3425 
3426 		VERIFY(nvlist_add_nvlist_array(sav->sav_config,
3427 		    config, newdevs, ndevs + oldndevs) == 0);
3428 		for (i = 0; i < oldndevs + ndevs; i++)
3429 			nvlist_free(newdevs[i]);
3430 		kmem_free(newdevs, (oldndevs + ndevs) * sizeof (void *));
3431 	} else {
3432 		/*
3433 		 * Generate a new dev list.
3434 		 */
3435 		VERIFY(nvlist_alloc(&sav->sav_config, NV_UNIQUE_NAME,
3436 		    KM_SLEEP) == 0);
3437 		VERIFY(nvlist_add_nvlist_array(sav->sav_config, config,
3438 		    devs, ndevs) == 0);
3439 	}
3440 }
3441 
3442 /*
3443  * Stop and drop level 2 ARC devices
3444  */
3445 void
3446 spa_l2cache_drop(spa_t *spa)
3447 {
3448 	vdev_t *vd;
3449 	int i;
3450 	spa_aux_vdev_t *sav = &spa->spa_l2cache;
3451 
3452 	for (i = 0; i < sav->sav_count; i++) {
3453 		uint64_t pool;
3454 
3455 		vd = sav->sav_vdevs[i];
3456 		ASSERT(vd != NULL);
3457 
3458 		if (spa_l2cache_exists(vd->vdev_guid, &pool) &&
3459 		    pool != 0ULL && l2arc_vdev_present(vd))
3460 			l2arc_remove_vdev(vd);
3461 	}
3462 }
3463 
3464 /*
3465  * Pool Creation
3466  */
3467 int
3468 spa_create(const char *pool, nvlist_t *nvroot, nvlist_t *props,
3469     nvlist_t *zplprops)
3470 {
3471 	spa_t *spa;
3472 	char *altroot = NULL;
3473 	vdev_t *rvd;
3474 	dsl_pool_t *dp;
3475 	dmu_tx_t *tx;
3476 	int error = 0;
3477 	uint64_t txg = TXG_INITIAL;
3478 	nvlist_t **spares, **l2cache;
3479 	uint_t nspares, nl2cache;
3480 	uint64_t version, obj;
3481 	boolean_t has_features;
3482 
3483 	/*
3484 	 * If this pool already exists, return failure.
3485 	 */
3486 	mutex_enter(&spa_namespace_lock);
3487 	if (spa_lookup(pool) != NULL) {
3488 		mutex_exit(&spa_namespace_lock);
3489 		return (SET_ERROR(EEXIST));
3490 	}
3491 
3492 	/*
3493 	 * Allocate a new spa_t structure.
3494 	 */
3495 	(void) nvlist_lookup_string(props,
3496 	    zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot);
3497 	spa = spa_add(pool, NULL, altroot);
3498 	spa_activate(spa, spa_mode_global);
3499 
3500 	if (props && (error = spa_prop_validate(spa, props))) {
3501 		spa_deactivate(spa);
3502 		spa_remove(spa);
3503 		mutex_exit(&spa_namespace_lock);
3504 		return (error);
3505 	}
3506 
3507 	has_features = B_FALSE;
3508 	for (nvpair_t *elem = nvlist_next_nvpair(props, NULL);
3509 	    elem != NULL; elem = nvlist_next_nvpair(props, elem)) {
3510 		if (zpool_prop_feature(nvpair_name(elem)))
3511 			has_features = B_TRUE;
3512 	}
3513 
3514 	if (has_features || nvlist_lookup_uint64(props,
3515 	    zpool_prop_to_name(ZPOOL_PROP_VERSION), &version) != 0) {
3516 		version = SPA_VERSION;
3517 	}
3518 	ASSERT(SPA_VERSION_IS_SUPPORTED(version));
3519 
3520 	spa->spa_first_txg = txg;
3521 	spa->spa_uberblock.ub_txg = txg - 1;
3522 	spa->spa_uberblock.ub_version = version;
3523 	spa->spa_ubsync = spa->spa_uberblock;
3524 
3525 	/*
3526 	 * Create "The Godfather" zio to hold all async IOs
3527 	 */
3528 	spa->spa_async_zio_root = kmem_alloc(max_ncpus * sizeof (void *),
3529 	    KM_SLEEP);
3530 	for (int i = 0; i < max_ncpus; i++) {
3531 		spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL,
3532 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE |
3533 		    ZIO_FLAG_GODFATHER);
3534 	}
3535 
3536 	/*
3537 	 * Create the root vdev.
3538 	 */
3539 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
3540 
3541 	error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_ADD);
3542 
3543 	ASSERT(error != 0 || rvd != NULL);
3544 	ASSERT(error != 0 || spa->spa_root_vdev == rvd);
3545 
3546 	if (error == 0 && !zfs_allocatable_devs(nvroot))
3547 		error = SET_ERROR(EINVAL);
3548 
3549 	if (error == 0 &&
3550 	    (error = vdev_create(rvd, txg, B_FALSE)) == 0 &&
3551 	    (error = spa_validate_aux(spa, nvroot, txg,
3552 	    VDEV_ALLOC_ADD)) == 0) {
3553 		for (int c = 0; c < rvd->vdev_children; c++) {
3554 			vdev_metaslab_set_size(rvd->vdev_child[c]);
3555 			vdev_expand(rvd->vdev_child[c], txg);
3556 		}
3557 	}
3558 
3559 	spa_config_exit(spa, SCL_ALL, FTAG);
3560 
3561 	if (error != 0) {
3562 		spa_unload(spa);
3563 		spa_deactivate(spa);
3564 		spa_remove(spa);
3565 		mutex_exit(&spa_namespace_lock);
3566 		return (error);
3567 	}
3568 
3569 	/*
3570 	 * Get the list of spares, if specified.
3571 	 */
3572 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
3573 	    &spares, &nspares) == 0) {
3574 		VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, NV_UNIQUE_NAME,
3575 		    KM_SLEEP) == 0);
3576 		VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
3577 		    ZPOOL_CONFIG_SPARES, spares, nspares) == 0);
3578 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
3579 		spa_load_spares(spa);
3580 		spa_config_exit(spa, SCL_ALL, FTAG);
3581 		spa->spa_spares.sav_sync = B_TRUE;
3582 	}
3583 
3584 	/*
3585 	 * Get the list of level 2 cache devices, if specified.
3586 	 */
3587 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
3588 	    &l2cache, &nl2cache) == 0) {
3589 		VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config,
3590 		    NV_UNIQUE_NAME, KM_SLEEP) == 0);
3591 		VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config,
3592 		    ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0);
3593 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
3594 		spa_load_l2cache(spa);
3595 		spa_config_exit(spa, SCL_ALL, FTAG);
3596 		spa->spa_l2cache.sav_sync = B_TRUE;
3597 	}
3598 
3599 	spa->spa_is_initializing = B_TRUE;
3600 	spa->spa_dsl_pool = dp = dsl_pool_create(spa, zplprops, txg);
3601 	spa->spa_meta_objset = dp->dp_meta_objset;
3602 	spa->spa_is_initializing = B_FALSE;
3603 
3604 	/*
3605 	 * Create DDTs (dedup tables).
3606 	 */
3607 	ddt_create(spa);
3608 
3609 	spa_update_dspace(spa);
3610 
3611 	tx = dmu_tx_create_assigned(dp, txg);
3612 
3613 	/*
3614 	 * Create the pool config object.
3615 	 */
3616 	spa->spa_config_object = dmu_object_alloc(spa->spa_meta_objset,
3617 	    DMU_OT_PACKED_NVLIST, SPA_CONFIG_BLOCKSIZE,
3618 	    DMU_OT_PACKED_NVLIST_SIZE, sizeof (uint64_t), tx);
3619 
3620 	if (zap_add(spa->spa_meta_objset,
3621 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG,
3622 	    sizeof (uint64_t), 1, &spa->spa_config_object, tx) != 0) {
3623 		cmn_err(CE_PANIC, "failed to add pool config");
3624 	}
3625 
3626 	if (spa_version(spa) >= SPA_VERSION_FEATURES)
3627 		spa_feature_create_zap_objects(spa, tx);
3628 
3629 	if (zap_add(spa->spa_meta_objset,
3630 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CREATION_VERSION,
3631 	    sizeof (uint64_t), 1, &version, tx) != 0) {
3632 		cmn_err(CE_PANIC, "failed to add pool version");
3633 	}
3634 
3635 	/* Newly created pools with the right version are always deflated. */
3636 	if (version >= SPA_VERSION_RAIDZ_DEFLATE) {
3637 		spa->spa_deflate = TRUE;
3638 		if (zap_add(spa->spa_meta_objset,
3639 		    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE,
3640 		    sizeof (uint64_t), 1, &spa->spa_deflate, tx) != 0) {
3641 			cmn_err(CE_PANIC, "failed to add deflate");
3642 		}
3643 	}
3644 
3645 	/*
3646 	 * Create the deferred-free bpobj.  Turn off compression
3647 	 * because sync-to-convergence takes longer if the blocksize
3648 	 * keeps changing.
3649 	 */
3650 	obj = bpobj_alloc(spa->spa_meta_objset, 1 << 14, tx);
3651 	dmu_object_set_compress(spa->spa_meta_objset, obj,
3652 	    ZIO_COMPRESS_OFF, tx);
3653 	if (zap_add(spa->spa_meta_objset,
3654 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPOBJ,
3655 	    sizeof (uint64_t), 1, &obj, tx) != 0) {
3656 		cmn_err(CE_PANIC, "failed to add bpobj");
3657 	}
3658 	VERIFY3U(0, ==, bpobj_open(&spa->spa_deferred_bpobj,
3659 	    spa->spa_meta_objset, obj));
3660 
3661 	/*
3662 	 * Create the pool's history object.
3663 	 */
3664 	if (version >= SPA_VERSION_ZPOOL_HISTORY)
3665 		spa_history_create_obj(spa, tx);
3666 
3667 	/*
3668 	 * Set pool properties.
3669 	 */
3670 	spa->spa_bootfs = zpool_prop_default_numeric(ZPOOL_PROP_BOOTFS);
3671 	spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION);
3672 	spa->spa_failmode = zpool_prop_default_numeric(ZPOOL_PROP_FAILUREMODE);
3673 	spa->spa_autoexpand = zpool_prop_default_numeric(ZPOOL_PROP_AUTOEXPAND);
3674 
3675 	if (props != NULL) {
3676 		spa_configfile_set(spa, props, B_FALSE);
3677 		spa_sync_props(props, tx);
3678 	}
3679 
3680 	dmu_tx_commit(tx);
3681 
3682 	spa->spa_sync_on = B_TRUE;
3683 	txg_sync_start(spa->spa_dsl_pool);
3684 
3685 	/*
3686 	 * We explicitly wait for the first transaction to complete so that our
3687 	 * bean counters are appropriately updated.
3688 	 */
3689 	txg_wait_synced(spa->spa_dsl_pool, txg);
3690 
3691 	spa_config_sync(spa, B_FALSE, B_TRUE);
3692 
3693 	spa_history_log_version(spa, "create");
3694 
3695 	/*
3696 	 * Don't count references from objsets that are already closed
3697 	 * and are making their way through the eviction process.
3698 	 */
3699 	spa_evicting_os_wait(spa);
3700 	spa->spa_minref = refcount_count(&spa->spa_refcount);
3701 
3702 	mutex_exit(&spa_namespace_lock);
3703 
3704 	return (0);
3705 }
3706 
3707 #ifdef _KERNEL
3708 /*
3709  * Get the root pool information from the root disk, then import the root pool
3710  * during the system boot up time.
3711  */
3712 extern int vdev_disk_read_rootlabel(char *, char *, nvlist_t **);
3713 
3714 static nvlist_t *
3715 spa_generate_rootconf(char *devpath, char *devid, uint64_t *guid)
3716 {
3717 	nvlist_t *config;
3718 	nvlist_t *nvtop, *nvroot;
3719 	uint64_t pgid;
3720 
3721 	if (vdev_disk_read_rootlabel(devpath, devid, &config) != 0)
3722 		return (NULL);
3723 
3724 	/*
3725 	 * Add this top-level vdev to the child array.
3726 	 */
3727 	VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
3728 	    &nvtop) == 0);
3729 	VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
3730 	    &pgid) == 0);
3731 	VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID, guid) == 0);
3732 
3733 	/*
3734 	 * Put this pool's top-level vdevs into a root vdev.
3735 	 */
3736 	VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0);
3737 	VERIFY(nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE,
3738 	    VDEV_TYPE_ROOT) == 0);
3739 	VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_ID, 0ULL) == 0);
3740 	VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_GUID, pgid) == 0);
3741 	VERIFY(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
3742 	    &nvtop, 1) == 0);
3743 
3744 	/*
3745 	 * Replace the existing vdev_tree with the new root vdev in
3746 	 * this pool's configuration (remove the old, add the new).
3747 	 */
3748 	VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, nvroot) == 0);
3749 	nvlist_free(nvroot);
3750 	return (config);
3751 }
3752 
3753 /*
3754  * Walk the vdev tree and see if we can find a device with "better"
3755  * configuration. A configuration is "better" if the label on that
3756  * device has a more recent txg.
3757  */
3758 static void
3759 spa_alt_rootvdev(vdev_t *vd, vdev_t **avd, uint64_t *txg)
3760 {
3761 	for (int c = 0; c < vd->vdev_children; c++)
3762 		spa_alt_rootvdev(vd->vdev_child[c], avd, txg);
3763 
3764 	if (vd->vdev_ops->vdev_op_leaf) {
3765 		nvlist_t *label;
3766 		uint64_t label_txg;
3767 
3768 		if (vdev_disk_read_rootlabel(vd->vdev_physpath, vd->vdev_devid,
3769 		    &label) != 0)
3770 			return;
3771 
3772 		VERIFY(nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_TXG,
3773 		    &label_txg) == 0);
3774 
3775 		/*
3776 		 * Do we have a better boot device?
3777 		 */
3778 		if (label_txg > *txg) {
3779 			*txg = label_txg;
3780 			*avd = vd;
3781 		}
3782 		nvlist_free(label);
3783 	}
3784 }
3785 
3786 /*
3787  * Import a root pool.
3788  *
3789  * For x86. devpath_list will consist of devid and/or physpath name of
3790  * the vdev (e.g. "id1,sd@SSEAGATE..." or "/pci@1f,0/ide@d/disk@0,0:a").
3791  * The GRUB "findroot" command will return the vdev we should boot.
3792  *
3793  * For Sparc, devpath_list consists the physpath name of the booting device
3794  * no matter the rootpool is a single device pool or a mirrored pool.
3795  * e.g.
3796  *	"/pci@1f,0/ide@d/disk@0,0:a"
3797  */
3798 int
3799 spa_import_rootpool(char *devpath, char *devid)
3800 {
3801 	spa_t *spa;
3802 	vdev_t *rvd, *bvd, *avd = NULL;
3803 	nvlist_t *config, *nvtop;
3804 	uint64_t guid, txg;
3805 	char *pname;
3806 	int error;
3807 
3808 	/*
3809 	 * Read the label from the boot device and generate a configuration.
3810 	 */
3811 	config = spa_generate_rootconf(devpath, devid, &guid);
3812 #if defined(_OBP) && defined(_KERNEL)
3813 	if (config == NULL) {
3814 		if (strstr(devpath, "/iscsi/ssd") != NULL) {
3815 			/* iscsi boot */
3816 			get_iscsi_bootpath_phy(devpath);
3817 			config = spa_generate_rootconf(devpath, devid, &guid);
3818 		}
3819 	}
3820 #endif
3821 	if (config == NULL) {
3822 		cmn_err(CE_NOTE, "Cannot read the pool label from '%s'",
3823 		    devpath);
3824 		return (SET_ERROR(EIO));
3825 	}
3826 
3827 	VERIFY(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
3828 	    &pname) == 0);
3829 	VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, &txg) == 0);
3830 
3831 	mutex_enter(&spa_namespace_lock);
3832 	if ((spa = spa_lookup(pname)) != NULL) {
3833 		/*
3834 		 * Remove the existing root pool from the namespace so that we
3835 		 * can replace it with the correct config we just read in.
3836 		 */
3837 		spa_remove(spa);
3838 	}
3839 
3840 	spa = spa_add(pname, config, NULL);
3841 	spa->spa_is_root = B_TRUE;
3842 	spa->spa_import_flags = ZFS_IMPORT_VERBATIM;
3843 
3844 	/*
3845 	 * Build up a vdev tree based on the boot device's label config.
3846 	 */
3847 	VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
3848 	    &nvtop) == 0);
3849 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
3850 	error = spa_config_parse(spa, &rvd, nvtop, NULL, 0,
3851 	    VDEV_ALLOC_ROOTPOOL);
3852 	spa_config_exit(spa, SCL_ALL, FTAG);
3853 	if (error) {
3854 		mutex_exit(&spa_namespace_lock);
3855 		nvlist_free(config);
3856 		cmn_err(CE_NOTE, "Can not parse the config for pool '%s'",
3857 		    pname);
3858 		return (error);
3859 	}
3860 
3861 	/*
3862 	 * Get the boot vdev.
3863 	 */
3864 	if ((bvd = vdev_lookup_by_guid(rvd, guid)) == NULL) {
3865 		cmn_err(CE_NOTE, "Can not find the boot vdev for guid %llu",
3866 		    (u_longlong_t)guid);
3867 		error = SET_ERROR(ENOENT);
3868 		goto out;
3869 	}
3870 
3871 	/*
3872 	 * Determine if there is a better boot device.
3873 	 */
3874 	avd = bvd;
3875 	spa_alt_rootvdev(rvd, &avd, &txg);
3876 	if (avd != bvd) {
3877 		cmn_err(CE_NOTE, "The boot device is 'degraded'. Please "
3878 		    "try booting from '%s'", avd->vdev_path);
3879 		error = SET_ERROR(EINVAL);
3880 		goto out;
3881 	}
3882 
3883 	/*
3884 	 * If the boot device is part of a spare vdev then ensure that
3885 	 * we're booting off the active spare.
3886 	 */
3887 	if (bvd->vdev_parent->vdev_ops == &vdev_spare_ops &&
3888 	    !bvd->vdev_isspare) {
3889 		cmn_err(CE_NOTE, "The boot device is currently spared. Please "
3890 		    "try booting from '%s'",
3891 		    bvd->vdev_parent->
3892 		    vdev_child[bvd->vdev_parent->vdev_children - 1]->vdev_path);
3893 		error = SET_ERROR(EINVAL);
3894 		goto out;
3895 	}
3896 
3897 	error = 0;
3898 out:
3899 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
3900 	vdev_free(rvd);
3901 	spa_config_exit(spa, SCL_ALL, FTAG);
3902 	mutex_exit(&spa_namespace_lock);
3903 
3904 	nvlist_free(config);
3905 	return (error);
3906 }
3907 
3908 #endif
3909 
3910 /*
3911  * Import a non-root pool into the system.
3912  */
3913 int
3914 spa_import(const char *pool, nvlist_t *config, nvlist_t *props, uint64_t flags)
3915 {
3916 	spa_t *spa;
3917 	char *altroot = NULL;
3918 	spa_load_state_t state = SPA_LOAD_IMPORT;
3919 	zpool_rewind_policy_t policy;
3920 	uint64_t mode = spa_mode_global;
3921 	uint64_t readonly = B_FALSE;
3922 	int error;
3923 	nvlist_t *nvroot;
3924 	nvlist_t **spares, **l2cache;
3925 	uint_t nspares, nl2cache;
3926 
3927 	/*
3928 	 * If a pool with this name exists, return failure.
3929 	 */
3930 	mutex_enter(&spa_namespace_lock);
3931 	if (spa_lookup(pool) != NULL) {
3932 		mutex_exit(&spa_namespace_lock);
3933 		return (SET_ERROR(EEXIST));
3934 	}
3935 
3936 	/*
3937 	 * Create and initialize the spa structure.
3938 	 */
3939 	(void) nvlist_lookup_string(props,
3940 	    zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot);
3941 	(void) nvlist_lookup_uint64(props,
3942 	    zpool_prop_to_name(ZPOOL_PROP_READONLY), &readonly);
3943 	if (readonly)
3944 		mode = FREAD;
3945 	spa = spa_add(pool, config, altroot);
3946 	spa->spa_import_flags = flags;
3947 
3948 	/*
3949 	 * Verbatim import - Take a pool and insert it into the namespace
3950 	 * as if it had been loaded at boot.
3951 	 */
3952 	if (spa->spa_import_flags & ZFS_IMPORT_VERBATIM) {
3953 		if (props != NULL)
3954 			spa_configfile_set(spa, props, B_FALSE);
3955 
3956 		spa_config_sync(spa, B_FALSE, B_TRUE);
3957 
3958 		mutex_exit(&spa_namespace_lock);
3959 		return (0);
3960 	}
3961 
3962 	spa_activate(spa, mode);
3963 
3964 	/*
3965 	 * Don't start async tasks until we know everything is healthy.
3966 	 */
3967 	spa_async_suspend(spa);
3968 
3969 	zpool_get_rewind_policy(config, &policy);
3970 	if (policy.zrp_request & ZPOOL_DO_REWIND)
3971 		state = SPA_LOAD_RECOVER;
3972 
3973 	/*
3974 	 * Pass off the heavy lifting to spa_load().  Pass TRUE for mosconfig
3975 	 * because the user-supplied config is actually the one to trust when
3976 	 * doing an import.
3977 	 */
3978 	if (state != SPA_LOAD_RECOVER)
3979 		spa->spa_last_ubsync_txg = spa->spa_load_txg = 0;
3980 
3981 	error = spa_load_best(spa, state, B_TRUE, policy.zrp_txg,
3982 	    policy.zrp_request);
3983 
3984 	/*
3985 	 * Propagate anything learned while loading the pool and pass it
3986 	 * back to caller (i.e. rewind info, missing devices, etc).
3987 	 */
3988 	VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_LOAD_INFO,
3989 	    spa->spa_load_info) == 0);
3990 
3991 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
3992 	/*
3993 	 * Toss any existing sparelist, as it doesn't have any validity
3994 	 * anymore, and conflicts with spa_has_spare().
3995 	 */
3996 	if (spa->spa_spares.sav_config) {
3997 		nvlist_free(spa->spa_spares.sav_config);
3998 		spa->spa_spares.sav_config = NULL;
3999 		spa_load_spares(spa);
4000 	}
4001 	if (spa->spa_l2cache.sav_config) {
4002 		nvlist_free(spa->spa_l2cache.sav_config);
4003 		spa->spa_l2cache.sav_config = NULL;
4004 		spa_load_l2cache(spa);
4005 	}
4006 
4007 	VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
4008 	    &nvroot) == 0);
4009 	if (error == 0)
4010 		error = spa_validate_aux(spa, nvroot, -1ULL,
4011 		    VDEV_ALLOC_SPARE);
4012 	if (error == 0)
4013 		error = spa_validate_aux(spa, nvroot, -1ULL,
4014 		    VDEV_ALLOC_L2CACHE);
4015 	spa_config_exit(spa, SCL_ALL, FTAG);
4016 
4017 	if (props != NULL)
4018 		spa_configfile_set(spa, props, B_FALSE);
4019 
4020 	if (error != 0 || (props && spa_writeable(spa) &&
4021 	    (error = spa_prop_set(spa, props)))) {
4022 		spa_unload(spa);
4023 		spa_deactivate(spa);
4024 		spa_remove(spa);
4025 		mutex_exit(&spa_namespace_lock);
4026 		return (error);
4027 	}
4028 
4029 	spa_async_resume(spa);
4030 
4031 	/*
4032 	 * Override any spares and level 2 cache devices as specified by
4033 	 * the user, as these may have correct device names/devids, etc.
4034 	 */
4035 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
4036 	    &spares, &nspares) == 0) {
4037 		if (spa->spa_spares.sav_config)
4038 			VERIFY(nvlist_remove(spa->spa_spares.sav_config,
4039 			    ZPOOL_CONFIG_SPARES, DATA_TYPE_NVLIST_ARRAY) == 0);
4040 		else
4041 			VERIFY(nvlist_alloc(&spa->spa_spares.sav_config,
4042 			    NV_UNIQUE_NAME, KM_SLEEP) == 0);
4043 		VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
4044 		    ZPOOL_CONFIG_SPARES, spares, nspares) == 0);
4045 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4046 		spa_load_spares(spa);
4047 		spa_config_exit(spa, SCL_ALL, FTAG);
4048 		spa->spa_spares.sav_sync = B_TRUE;
4049 	}
4050 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
4051 	    &l2cache, &nl2cache) == 0) {
4052 		if (spa->spa_l2cache.sav_config)
4053 			VERIFY(nvlist_remove(spa->spa_l2cache.sav_config,
4054 			    ZPOOL_CONFIG_L2CACHE, DATA_TYPE_NVLIST_ARRAY) == 0);
4055 		else
4056 			VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config,
4057 			    NV_UNIQUE_NAME, KM_SLEEP) == 0);
4058 		VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config,
4059 		    ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0);
4060 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4061 		spa_load_l2cache(spa);
4062 		spa_config_exit(spa, SCL_ALL, FTAG);
4063 		spa->spa_l2cache.sav_sync = B_TRUE;
4064 	}
4065 
4066 	/*
4067 	 * Check for any removed devices.
4068 	 */
4069 	if (spa->spa_autoreplace) {
4070 		spa_aux_check_removed(&spa->spa_spares);
4071 		spa_aux_check_removed(&spa->spa_l2cache);
4072 	}
4073 
4074 	if (spa_writeable(spa)) {
4075 		/*
4076 		 * Update the config cache to include the newly-imported pool.
4077 		 */
4078 		spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
4079 	}
4080 
4081 	/*
4082 	 * It's possible that the pool was expanded while it was exported.
4083 	 * We kick off an async task to handle this for us.
4084 	 */
4085 	spa_async_request(spa, SPA_ASYNC_AUTOEXPAND);
4086 
4087 	mutex_exit(&spa_namespace_lock);
4088 	spa_history_log_version(spa, "import");
4089 
4090 	return (0);
4091 }
4092 
4093 nvlist_t *
4094 spa_tryimport(nvlist_t *tryconfig)
4095 {
4096 	nvlist_t *config = NULL;
4097 	char *poolname;
4098 	spa_t *spa;
4099 	uint64_t state;
4100 	int error;
4101 
4102 	if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname))
4103 		return (NULL);
4104 
4105 	if (nvlist_lookup_uint64(tryconfig, ZPOOL_CONFIG_POOL_STATE, &state))
4106 		return (NULL);
4107 
4108 	/*
4109 	 * Create and initialize the spa structure.
4110 	 */
4111 	mutex_enter(&spa_namespace_lock);
4112 	spa = spa_add(TRYIMPORT_NAME, tryconfig, NULL);
4113 	spa_activate(spa, FREAD);
4114 
4115 	/*
4116 	 * Pass off the heavy lifting to spa_load().
4117 	 * Pass TRUE for mosconfig because the user-supplied config
4118 	 * is actually the one to trust when doing an import.
4119 	 */
4120 	error = spa_load(spa, SPA_LOAD_TRYIMPORT, SPA_IMPORT_EXISTING, B_TRUE);
4121 
4122 	/*
4123 	 * If 'tryconfig' was at least parsable, return the current config.
4124 	 */
4125 	if (spa->spa_root_vdev != NULL) {
4126 		config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
4127 		VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME,
4128 		    poolname) == 0);
4129 		VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE,
4130 		    state) == 0);
4131 		VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_TIMESTAMP,
4132 		    spa->spa_uberblock.ub_timestamp) == 0);
4133 		VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_LOAD_INFO,
4134 		    spa->spa_load_info) == 0);
4135 
4136 		/*
4137 		 * If the bootfs property exists on this pool then we
4138 		 * copy it out so that external consumers can tell which
4139 		 * pools are bootable.
4140 		 */
4141 		if ((!error || error == EEXIST) && spa->spa_bootfs) {
4142 			char *tmpname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
4143 
4144 			/*
4145 			 * We have to play games with the name since the
4146 			 * pool was opened as TRYIMPORT_NAME.
4147 			 */
4148 			if (dsl_dsobj_to_dsname(spa_name(spa),
4149 			    spa->spa_bootfs, tmpname) == 0) {
4150 				char *cp;
4151 				char *dsname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
4152 
4153 				cp = strchr(tmpname, '/');
4154 				if (cp == NULL) {
4155 					(void) strlcpy(dsname, tmpname,
4156 					    MAXPATHLEN);
4157 				} else {
4158 					(void) snprintf(dsname, MAXPATHLEN,
4159 					    "%s/%s", poolname, ++cp);
4160 				}
4161 				VERIFY(nvlist_add_string(config,
4162 				    ZPOOL_CONFIG_BOOTFS, dsname) == 0);
4163 				kmem_free(dsname, MAXPATHLEN);
4164 			}
4165 			kmem_free(tmpname, MAXPATHLEN);
4166 		}
4167 
4168 		/*
4169 		 * Add the list of hot spares and level 2 cache devices.
4170 		 */
4171 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
4172 		spa_add_spares(spa, config);
4173 		spa_add_l2cache(spa, config);
4174 		spa_config_exit(spa, SCL_CONFIG, FTAG);
4175 	}
4176 
4177 	spa_unload(spa);
4178 	spa_deactivate(spa);
4179 	spa_remove(spa);
4180 	mutex_exit(&spa_namespace_lock);
4181 
4182 	return (config);
4183 }
4184 
4185 /*
4186  * Pool export/destroy
4187  *
4188  * The act of destroying or exporting a pool is very simple.  We make sure there
4189  * is no more pending I/O and any references to the pool are gone.  Then, we
4190  * update the pool state and sync all the labels to disk, removing the
4191  * configuration from the cache afterwards. If the 'hardforce' flag is set, then
4192  * we don't sync the labels or remove the configuration cache.
4193  */
4194 static int
4195 spa_export_common(char *pool, int new_state, nvlist_t **oldconfig,
4196     boolean_t force, boolean_t hardforce)
4197 {
4198 	spa_t *spa;
4199 
4200 	if (oldconfig)
4201 		*oldconfig = NULL;
4202 
4203 	if (!(spa_mode_global & FWRITE))
4204 		return (SET_ERROR(EROFS));
4205 
4206 	mutex_enter(&spa_namespace_lock);
4207 	if ((spa = spa_lookup(pool)) == NULL) {
4208 		mutex_exit(&spa_namespace_lock);
4209 		return (SET_ERROR(ENOENT));
4210 	}
4211 
4212 	/*
4213 	 * Put a hold on the pool, drop the namespace lock, stop async tasks,
4214 	 * reacquire the namespace lock, and see if we can export.
4215 	 */
4216 	spa_open_ref(spa, FTAG);
4217 	mutex_exit(&spa_namespace_lock);
4218 	spa_async_suspend(spa);
4219 	mutex_enter(&spa_namespace_lock);
4220 	spa_close(spa, FTAG);
4221 
4222 	/*
4223 	 * The pool will be in core if it's openable,
4224 	 * in which case we can modify its state.
4225 	 */
4226 	if (spa->spa_state != POOL_STATE_UNINITIALIZED && spa->spa_sync_on) {
4227 		/*
4228 		 * Objsets may be open only because they're dirty, so we
4229 		 * have to force it to sync before checking spa_refcnt.
4230 		 */
4231 		txg_wait_synced(spa->spa_dsl_pool, 0);
4232 		spa_evicting_os_wait(spa);
4233 
4234 		/*
4235 		 * A pool cannot be exported or destroyed if there are active
4236 		 * references.  If we are resetting a pool, allow references by
4237 		 * fault injection handlers.
4238 		 */
4239 		if (!spa_refcount_zero(spa) ||
4240 		    (spa->spa_inject_ref != 0 &&
4241 		    new_state != POOL_STATE_UNINITIALIZED)) {
4242 			spa_async_resume(spa);
4243 			mutex_exit(&spa_namespace_lock);
4244 			return (SET_ERROR(EBUSY));
4245 		}
4246 
4247 		/*
4248 		 * A pool cannot be exported if it has an active shared spare.
4249 		 * This is to prevent other pools stealing the active spare
4250 		 * from an exported pool. At user's own will, such pool can
4251 		 * be forcedly exported.
4252 		 */
4253 		if (!force && new_state == POOL_STATE_EXPORTED &&
4254 		    spa_has_active_shared_spare(spa)) {
4255 			spa_async_resume(spa);
4256 			mutex_exit(&spa_namespace_lock);
4257 			return (SET_ERROR(EXDEV));
4258 		}
4259 
4260 		/*
4261 		 * We want this to be reflected on every label,
4262 		 * so mark them all dirty.  spa_unload() will do the
4263 		 * final sync that pushes these changes out.
4264 		 */
4265 		if (new_state != POOL_STATE_UNINITIALIZED && !hardforce) {
4266 			spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
4267 			spa->spa_state = new_state;
4268 			spa->spa_final_txg = spa_last_synced_txg(spa) +
4269 			    TXG_DEFER_SIZE + 1;
4270 			vdev_config_dirty(spa->spa_root_vdev);
4271 			spa_config_exit(spa, SCL_ALL, FTAG);
4272 		}
4273 	}
4274 
4275 	spa_event_notify(spa, NULL, ESC_ZFS_POOL_DESTROY);
4276 
4277 	if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
4278 		spa_unload(spa);
4279 		spa_deactivate(spa);
4280 	}
4281 
4282 	if (oldconfig && spa->spa_config)
4283 		VERIFY(nvlist_dup(spa->spa_config, oldconfig, 0) == 0);
4284 
4285 	if (new_state != POOL_STATE_UNINITIALIZED) {
4286 		if (!hardforce)
4287 			spa_config_sync(spa, B_TRUE, B_TRUE);
4288 		spa_remove(spa);
4289 	}
4290 	mutex_exit(&spa_namespace_lock);
4291 
4292 	return (0);
4293 }
4294 
4295 /*
4296  * Destroy a storage pool.
4297  */
4298 int
4299 spa_destroy(char *pool)
4300 {
4301 	return (spa_export_common(pool, POOL_STATE_DESTROYED, NULL,
4302 	    B_FALSE, B_FALSE));
4303 }
4304 
4305 /*
4306  * Export a storage pool.
4307  */
4308 int
4309 spa_export(char *pool, nvlist_t **oldconfig, boolean_t force,
4310     boolean_t hardforce)
4311 {
4312 	return (spa_export_common(pool, POOL_STATE_EXPORTED, oldconfig,
4313 	    force, hardforce));
4314 }
4315 
4316 /*
4317  * Similar to spa_export(), this unloads the spa_t without actually removing it
4318  * from the namespace in any way.
4319  */
4320 int
4321 spa_reset(char *pool)
4322 {
4323 	return (spa_export_common(pool, POOL_STATE_UNINITIALIZED, NULL,
4324 	    B_FALSE, B_FALSE));
4325 }
4326 
4327 /*
4328  * ==========================================================================
4329  * Device manipulation
4330  * ==========================================================================
4331  */
4332 
4333 /*
4334  * Add a device to a storage pool.
4335  */
4336 int
4337 spa_vdev_add(spa_t *spa, nvlist_t *nvroot)
4338 {
4339 	uint64_t txg, id;
4340 	int error;
4341 	vdev_t *rvd = spa->spa_root_vdev;
4342 	vdev_t *vd, *tvd;
4343 	nvlist_t **spares, **l2cache;
4344 	uint_t nspares, nl2cache;
4345 
4346 	ASSERT(spa_writeable(spa));
4347 
4348 	txg = spa_vdev_enter(spa);
4349 
4350 	if ((error = spa_config_parse(spa, &vd, nvroot, NULL, 0,
4351 	    VDEV_ALLOC_ADD)) != 0)
4352 		return (spa_vdev_exit(spa, NULL, txg, error));
4353 
4354 	spa->spa_pending_vdev = vd;	/* spa_vdev_exit() will clear this */
4355 
4356 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, &spares,
4357 	    &nspares) != 0)
4358 		nspares = 0;
4359 
4360 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, &l2cache,
4361 	    &nl2cache) != 0)
4362 		nl2cache = 0;
4363 
4364 	if (vd->vdev_children == 0 && nspares == 0 && nl2cache == 0)
4365 		return (spa_vdev_exit(spa, vd, txg, EINVAL));
4366 
4367 	if (vd->vdev_children != 0 &&
4368 	    (error = vdev_create(vd, txg, B_FALSE)) != 0)
4369 		return (spa_vdev_exit(spa, vd, txg, error));
4370 
4371 	/*
4372 	 * We must validate the spares and l2cache devices after checking the
4373 	 * children.  Otherwise, vdev_inuse() will blindly overwrite the spare.
4374 	 */
4375 	if ((error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) != 0)
4376 		return (spa_vdev_exit(spa, vd, txg, error));
4377 
4378 	/*
4379 	 * Transfer each new top-level vdev from vd to rvd.
4380 	 */
4381 	for (int c = 0; c < vd->vdev_children; c++) {
4382 
4383 		/*
4384 		 * Set the vdev id to the first hole, if one exists.
4385 		 */
4386 		for (id = 0; id < rvd->vdev_children; id++) {
4387 			if (rvd->vdev_child[id]->vdev_ishole) {
4388 				vdev_free(rvd->vdev_child[id]);
4389 				break;
4390 			}
4391 		}
4392 		tvd = vd->vdev_child[c];
4393 		vdev_remove_child(vd, tvd);
4394 		tvd->vdev_id = id;
4395 		vdev_add_child(rvd, tvd);
4396 		vdev_config_dirty(tvd);
4397 	}
4398 
4399 	if (nspares != 0) {
4400 		spa_set_aux_vdevs(&spa->spa_spares, spares, nspares,
4401 		    ZPOOL_CONFIG_SPARES);
4402 		spa_load_spares(spa);
4403 		spa->spa_spares.sav_sync = B_TRUE;
4404 	}
4405 
4406 	if (nl2cache != 0) {
4407 		spa_set_aux_vdevs(&spa->spa_l2cache, l2cache, nl2cache,
4408 		    ZPOOL_CONFIG_L2CACHE);
4409 		spa_load_l2cache(spa);
4410 		spa->spa_l2cache.sav_sync = B_TRUE;
4411 	}
4412 
4413 	/*
4414 	 * We have to be careful when adding new vdevs to an existing pool.
4415 	 * If other threads start allocating from these vdevs before we
4416 	 * sync the config cache, and we lose power, then upon reboot we may
4417 	 * fail to open the pool because there are DVAs that the config cache
4418 	 * can't translate.  Therefore, we first add the vdevs without
4419 	 * initializing metaslabs; sync the config cache (via spa_vdev_exit());
4420 	 * and then let spa_config_update() initialize the new metaslabs.
4421 	 *
4422 	 * spa_load() checks for added-but-not-initialized vdevs, so that
4423 	 * if we lose power at any point in this sequence, the remaining
4424 	 * steps will be completed the next time we load the pool.
4425 	 */
4426 	(void) spa_vdev_exit(spa, vd, txg, 0);
4427 
4428 	mutex_enter(&spa_namespace_lock);
4429 	spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
4430 	mutex_exit(&spa_namespace_lock);
4431 
4432 	return (0);
4433 }
4434 
4435 /*
4436  * Attach a device to a mirror.  The arguments are the path to any device
4437  * in the mirror, and the nvroot for the new device.  If the path specifies
4438  * a device that is not mirrored, we automatically insert the mirror vdev.
4439  *
4440  * If 'replacing' is specified, the new device is intended to replace the
4441  * existing device; in this case the two devices are made into their own
4442  * mirror using the 'replacing' vdev, which is functionally identical to
4443  * the mirror vdev (it actually reuses all the same ops) but has a few
4444  * extra rules: you can't attach to it after it's been created, and upon
4445  * completion of resilvering, the first disk (the one being replaced)
4446  * is automatically detached.
4447  */
4448 int
4449 spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot, int replacing)
4450 {
4451 	uint64_t txg, dtl_max_txg;
4452 	vdev_t *rvd = spa->spa_root_vdev;
4453 	vdev_t *oldvd, *newvd, *newrootvd, *pvd, *tvd;
4454 	vdev_ops_t *pvops;
4455 	char *oldvdpath, *newvdpath;
4456 	int newvd_isspare;
4457 	int error;
4458 
4459 	ASSERT(spa_writeable(spa));
4460 
4461 	txg = spa_vdev_enter(spa);
4462 
4463 	oldvd = spa_lookup_by_guid(spa, guid, B_FALSE);
4464 
4465 	if (oldvd == NULL)
4466 		return (spa_vdev_exit(spa, NULL, txg, ENODEV));
4467 
4468 	if (!oldvd->vdev_ops->vdev_op_leaf)
4469 		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
4470 
4471 	pvd = oldvd->vdev_parent;
4472 
4473 	if ((error = spa_config_parse(spa, &newrootvd, nvroot, NULL, 0,
4474 	    VDEV_ALLOC_ATTACH)) != 0)
4475 		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
4476 
4477 	if (newrootvd->vdev_children != 1)
4478 		return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));
4479 
4480 	newvd = newrootvd->vdev_child[0];
4481 
4482 	if (!newvd->vdev_ops->vdev_op_leaf)
4483 		return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));
4484 
4485 	if ((error = vdev_create(newrootvd, txg, replacing)) != 0)
4486 		return (spa_vdev_exit(spa, newrootvd, txg, error));
4487 
4488 	/*
4489 	 * Spares can't replace logs
4490 	 */
4491 	if (oldvd->vdev_top->vdev_islog && newvd->vdev_isspare)
4492 		return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
4493 
4494 	if (!replacing) {
4495 		/*
4496 		 * For attach, the only allowable parent is a mirror or the root
4497 		 * vdev.
4498 		 */
4499 		if (pvd->vdev_ops != &vdev_mirror_ops &&
4500 		    pvd->vdev_ops != &vdev_root_ops)
4501 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
4502 
4503 		pvops = &vdev_mirror_ops;
4504 	} else {
4505 		/*
4506 		 * Active hot spares can only be replaced by inactive hot
4507 		 * spares.
4508 		 */
4509 		if (pvd->vdev_ops == &vdev_spare_ops &&
4510 		    oldvd->vdev_isspare &&
4511 		    !spa_has_spare(spa, newvd->vdev_guid))
4512 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
4513 
4514 		/*
4515 		 * If the source is a hot spare, and the parent isn't already a
4516 		 * spare, then we want to create a new hot spare.  Otherwise, we
4517 		 * want to create a replacing vdev.  The user is not allowed to
4518 		 * attach to a spared vdev child unless the 'isspare' state is
4519 		 * the same (spare replaces spare, non-spare replaces
4520 		 * non-spare).
4521 		 */
4522 		if (pvd->vdev_ops == &vdev_replacing_ops &&
4523 		    spa_version(spa) < SPA_VERSION_MULTI_REPLACE) {
4524 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
4525 		} else if (pvd->vdev_ops == &vdev_spare_ops &&
4526 		    newvd->vdev_isspare != oldvd->vdev_isspare) {
4527 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
4528 		}
4529 
4530 		if (newvd->vdev_isspare)
4531 			pvops = &vdev_spare_ops;
4532 		else
4533 			pvops = &vdev_replacing_ops;
4534 	}
4535 
4536 	/*
4537 	 * Make sure the new device is big enough.
4538 	 */
4539 	if (newvd->vdev_asize < vdev_get_min_asize(oldvd))
4540 		return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW));
4541 
4542 	/*
4543 	 * The new device cannot have a higher alignment requirement
4544 	 * than the top-level vdev.
4545 	 */
4546 	if (newvd->vdev_ashift > oldvd->vdev_top->vdev_ashift)
4547 		return (spa_vdev_exit(spa, newrootvd, txg, EDOM));
4548 
4549 	/*
4550 	 * If this is an in-place replacement, update oldvd's path and devid
4551 	 * to make it distinguishable from newvd, and unopenable from now on.
4552 	 */
4553 	if (strcmp(oldvd->vdev_path, newvd->vdev_path) == 0) {
4554 		spa_strfree(oldvd->vdev_path);
4555 		oldvd->vdev_path = kmem_alloc(strlen(newvd->vdev_path) + 5,
4556 		    KM_SLEEP);
4557 		(void) sprintf(oldvd->vdev_path, "%s/%s",
4558 		    newvd->vdev_path, "old");
4559 		if (oldvd->vdev_devid != NULL) {
4560 			spa_strfree(oldvd->vdev_devid);
4561 			oldvd->vdev_devid = NULL;
4562 		}
4563 	}
4564 
4565 	/* mark the device being resilvered */
4566 	newvd->vdev_resilver_txg = txg;
4567 
4568 	/*
4569 	 * If the parent is not a mirror, or if we're replacing, insert the new
4570 	 * mirror/replacing/spare vdev above oldvd.
4571 	 */
4572 	if (pvd->vdev_ops != pvops)
4573 		pvd = vdev_add_parent(oldvd, pvops);
4574 
4575 	ASSERT(pvd->vdev_top->vdev_parent == rvd);
4576 	ASSERT(pvd->vdev_ops == pvops);
4577 	ASSERT(oldvd->vdev_parent == pvd);
4578 
4579 	/*
4580 	 * Extract the new device from its root and add it to pvd.
4581 	 */
4582 	vdev_remove_child(newrootvd, newvd);
4583 	newvd->vdev_id = pvd->vdev_children;
4584 	newvd->vdev_crtxg = oldvd->vdev_crtxg;
4585 	vdev_add_child(pvd, newvd);
4586 
4587 	tvd = newvd->vdev_top;
4588 	ASSERT(pvd->vdev_top == tvd);
4589 	ASSERT(tvd->vdev_parent == rvd);
4590 
4591 	vdev_config_dirty(tvd);
4592 
4593 	/*
4594 	 * Set newvd's DTL to [TXG_INITIAL, dtl_max_txg) so that we account
4595 	 * for any dmu_sync-ed blocks.  It will propagate upward when
4596 	 * spa_vdev_exit() calls vdev_dtl_reassess().
4597 	 */
4598 	dtl_max_txg = txg + TXG_CONCURRENT_STATES;
4599 
4600 	vdev_dtl_dirty(newvd, DTL_MISSING, TXG_INITIAL,
4601 	    dtl_max_txg - TXG_INITIAL);
4602 
4603 	if (newvd->vdev_isspare) {
4604 		spa_spare_activate(newvd);
4605 		spa_event_notify(spa, newvd, ESC_ZFS_VDEV_SPARE);
4606 	}
4607 
4608 	oldvdpath = spa_strdup(oldvd->vdev_path);
4609 	newvdpath = spa_strdup(newvd->vdev_path);
4610 	newvd_isspare = newvd->vdev_isspare;
4611 
4612 	/*
4613 	 * Mark newvd's DTL dirty in this txg.
4614 	 */
4615 	vdev_dirty(tvd, VDD_DTL, newvd, txg);
4616 
4617 	/*
4618 	 * Schedule the resilver to restart in the future. We do this to
4619 	 * ensure that dmu_sync-ed blocks have been stitched into the
4620 	 * respective datasets.
4621 	 */
4622 	dsl_resilver_restart(spa->spa_dsl_pool, dtl_max_txg);
4623 
4624 	/*
4625 	 * Commit the config
4626 	 */
4627 	(void) spa_vdev_exit(spa, newrootvd, dtl_max_txg, 0);
4628 
4629 	spa_history_log_internal(spa, "vdev attach", NULL,
4630 	    "%s vdev=%s %s vdev=%s",
4631 	    replacing && newvd_isspare ? "spare in" :
4632 	    replacing ? "replace" : "attach", newvdpath,
4633 	    replacing ? "for" : "to", oldvdpath);
4634 
4635 	spa_strfree(oldvdpath);
4636 	spa_strfree(newvdpath);
4637 
4638 	if (spa->spa_bootfs)
4639 		spa_event_notify(spa, newvd, ESC_ZFS_BOOTFS_VDEV_ATTACH);
4640 
4641 	return (0);
4642 }
4643 
4644 /*
4645  * Detach a device from a mirror or replacing vdev.
4646  *
4647  * If 'replace_done' is specified, only detach if the parent
4648  * is a replacing vdev.
4649  */
4650 int
4651 spa_vdev_detach(spa_t *spa, uint64_t guid, uint64_t pguid, int replace_done)
4652 {
4653 	uint64_t txg;
4654 	int error;
4655 	vdev_t *rvd = spa->spa_root_vdev;
4656 	vdev_t *vd, *pvd, *cvd, *tvd;
4657 	boolean_t unspare = B_FALSE;
4658 	uint64_t unspare_guid = 0;
4659 	char *vdpath;
4660 
4661 	ASSERT(spa_writeable(spa));
4662 
4663 	txg = spa_vdev_enter(spa);
4664 
4665 	vd = spa_lookup_by_guid(spa, guid, B_FALSE);
4666 
4667 	if (vd == NULL)
4668 		return (spa_vdev_exit(spa, NULL, txg, ENODEV));
4669 
4670 	if (!vd->vdev_ops->vdev_op_leaf)
4671 		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
4672 
4673 	pvd = vd->vdev_parent;
4674 
4675 	/*
4676 	 * If the parent/child relationship is not as expected, don't do it.
4677 	 * Consider M(A,R(B,C)) -- that is, a mirror of A with a replacing
4678 	 * vdev that's replacing B with C.  The user's intent in replacing
4679 	 * is to go from M(A,B) to M(A,C).  If the user decides to cancel
4680 	 * the replace by detaching C, the expected behavior is to end up
4681 	 * M(A,B).  But suppose that right after deciding to detach C,
4682 	 * the replacement of B completes.  We would have M(A,C), and then
4683 	 * ask to detach C, which would leave us with just A -- not what
4684 	 * the user wanted.  To prevent this, we make sure that the
4685 	 * parent/child relationship hasn't changed -- in this example,
4686 	 * that C's parent is still the replacing vdev R.
4687 	 */
4688 	if (pvd->vdev_guid != pguid && pguid != 0)
4689 		return (spa_vdev_exit(spa, NULL, txg, EBUSY));
4690 
4691 	/*
4692 	 * Only 'replacing' or 'spare' vdevs can be replaced.
4693 	 */
4694 	if (replace_done && pvd->vdev_ops != &vdev_replacing_ops &&
4695 	    pvd->vdev_ops != &vdev_spare_ops)
4696 		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
4697 
4698 	ASSERT(pvd->vdev_ops != &vdev_spare_ops ||
4699 	    spa_version(spa) >= SPA_VERSION_SPARES);
4700 
4701 	/*
4702 	 * Only mirror, replacing, and spare vdevs support detach.
4703 	 */
4704 	if (pvd->vdev_ops != &vdev_replacing_ops &&
4705 	    pvd->vdev_ops != &vdev_mirror_ops &&
4706 	    pvd->vdev_ops != &vdev_spare_ops)
4707 		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
4708 
4709 	/*
4710 	 * If this device has the only valid copy of some data,
4711 	 * we cannot safely detach it.
4712 	 */
4713 	if (vdev_dtl_required(vd))
4714 		return (spa_vdev_exit(spa, NULL, txg, EBUSY));
4715 
4716 	ASSERT(pvd->vdev_children >= 2);
4717 
4718 	/*
4719 	 * If we are detaching the second disk from a replacing vdev, then
4720 	 * check to see if we changed the original vdev's path to have "/old"
4721 	 * at the end in spa_vdev_attach().  If so, undo that change now.
4722 	 */
4723 	if (pvd->vdev_ops == &vdev_replacing_ops && vd->vdev_id > 0 &&
4724 	    vd->vdev_path != NULL) {
4725 		size_t len = strlen(vd->vdev_path);
4726 
4727 		for (int c = 0; c < pvd->vdev_children; c++) {
4728 			cvd = pvd->vdev_child[c];
4729 
4730 			if (cvd == vd || cvd->vdev_path == NULL)
4731 				continue;
4732 
4733 			if (strncmp(cvd->vdev_path, vd->vdev_path, len) == 0 &&
4734 			    strcmp(cvd->vdev_path + len, "/old") == 0) {
4735 				spa_strfree(cvd->vdev_path);
4736 				cvd->vdev_path = spa_strdup(vd->vdev_path);
4737 				break;
4738 			}
4739 		}
4740 	}
4741 
4742 	/*
4743 	 * If we are detaching the original disk from a spare, then it implies
4744 	 * that the spare should become a real disk, and be removed from the
4745 	 * active spare list for the pool.
4746 	 */
4747 	if (pvd->vdev_ops == &vdev_spare_ops &&
4748 	    vd->vdev_id == 0 &&
4749 	    pvd->vdev_child[pvd->vdev_children - 1]->vdev_isspare)
4750 		unspare = B_TRUE;
4751 
4752 	/*
4753 	 * Erase the disk labels so the disk can be used for other things.
4754 	 * This must be done after all other error cases are handled,
4755 	 * but before we disembowel vd (so we can still do I/O to it).
4756 	 * But if we can't do it, don't treat the error as fatal --
4757 	 * it may be that the unwritability of the disk is the reason
4758 	 * it's being detached!
4759 	 */
4760 	error = vdev_label_init(vd, 0, VDEV_LABEL_REMOVE);
4761 
4762 	/*
4763 	 * Remove vd from its parent and compact the parent's children.
4764 	 */
4765 	vdev_remove_child(pvd, vd);
4766 	vdev_compact_children(pvd);
4767 
4768 	/*
4769 	 * Remember one of the remaining children so we can get tvd below.
4770 	 */
4771 	cvd = pvd->vdev_child[pvd->vdev_children - 1];
4772 
4773 	/*
4774 	 * If we need to remove the remaining child from the list of hot spares,
4775 	 * do it now, marking the vdev as no longer a spare in the process.
4776 	 * We must do this before vdev_remove_parent(), because that can
4777 	 * change the GUID if it creates a new toplevel GUID.  For a similar
4778 	 * reason, we must remove the spare now, in the same txg as the detach;
4779 	 * otherwise someone could attach a new sibling, change the GUID, and
4780 	 * the subsequent attempt to spa_vdev_remove(unspare_guid) would fail.
4781 	 */
4782 	if (unspare) {
4783 		ASSERT(cvd->vdev_isspare);
4784 		spa_spare_remove(cvd);
4785 		unspare_guid = cvd->vdev_guid;
4786 		(void) spa_vdev_remove(spa, unspare_guid, B_TRUE);
4787 		cvd->vdev_unspare = B_TRUE;
4788 	}
4789 
4790 	/*
4791 	 * If the parent mirror/replacing vdev only has one child,
4792 	 * the parent is no longer needed.  Remove it from the tree.
4793 	 */
4794 	if (pvd->vdev_children == 1) {
4795 		if (pvd->vdev_ops == &vdev_spare_ops)
4796 			cvd->vdev_unspare = B_FALSE;
4797 		vdev_remove_parent(cvd);
4798 	}
4799 
4800 
4801 	/*
4802 	 * We don't set tvd until now because the parent we just removed
4803 	 * may have been the previous top-level vdev.
4804 	 */
4805 	tvd = cvd->vdev_top;
4806 	ASSERT(tvd->vdev_parent == rvd);
4807 
4808 	/*
4809 	 * Reevaluate the parent vdev state.
4810 	 */
4811 	vdev_propagate_state(cvd);
4812 
4813 	/*
4814 	 * If the 'autoexpand' property is set on the pool then automatically
4815 	 * try to expand the size of the pool. For example if the device we
4816 	 * just detached was smaller than the others, it may be possible to
4817 	 * add metaslabs (i.e. grow the pool). We need to reopen the vdev
4818 	 * first so that we can obtain the updated sizes of the leaf vdevs.
4819 	 */
4820 	if (spa->spa_autoexpand) {
4821 		vdev_reopen(tvd);
4822 		vdev_expand(tvd, txg);
4823 	}
4824 
4825 	vdev_config_dirty(tvd);
4826 
4827 	/*
4828 	 * Mark vd's DTL as dirty in this txg.  vdev_dtl_sync() will see that
4829 	 * vd->vdev_detached is set and free vd's DTL object in syncing context.
4830 	 * But first make sure we're not on any *other* txg's DTL list, to
4831 	 * prevent vd from being accessed after it's freed.
4832 	 */
4833 	vdpath = spa_strdup(vd->vdev_path);
4834 	for (int t = 0; t < TXG_SIZE; t++)
4835 		(void) txg_list_remove_this(&tvd->vdev_dtl_list, vd, t);
4836 	vd->vdev_detached = B_TRUE;
4837 	vdev_dirty(tvd, VDD_DTL, vd, txg);
4838 
4839 	spa_event_notify(spa, vd, ESC_ZFS_VDEV_REMOVE);
4840 
4841 	/* hang on to the spa before we release the lock */
4842 	spa_open_ref(spa, FTAG);
4843 
4844 	error = spa_vdev_exit(spa, vd, txg, 0);
4845 
4846 	spa_history_log_internal(spa, "detach", NULL,
4847 	    "vdev=%s", vdpath);
4848 	spa_strfree(vdpath);
4849 
4850 	/*
4851 	 * If this was the removal of the original device in a hot spare vdev,
4852 	 * then we want to go through and remove the device from the hot spare
4853 	 * list of every other pool.
4854 	 */
4855 	if (unspare) {
4856 		spa_t *altspa = NULL;
4857 
4858 		mutex_enter(&spa_namespace_lock);
4859 		while ((altspa = spa_next(altspa)) != NULL) {
4860 			if (altspa->spa_state != POOL_STATE_ACTIVE ||
4861 			    altspa == spa)
4862 				continue;
4863 
4864 			spa_open_ref(altspa, FTAG);
4865 			mutex_exit(&spa_namespace_lock);
4866 			(void) spa_vdev_remove(altspa, unspare_guid, B_TRUE);
4867 			mutex_enter(&spa_namespace_lock);
4868 			spa_close(altspa, FTAG);
4869 		}
4870 		mutex_exit(&spa_namespace_lock);
4871 
4872 		/* search the rest of the vdevs for spares to remove */
4873 		spa_vdev_resilver_done(spa);
4874 	}
4875 
4876 	/* all done with the spa; OK to release */
4877 	mutex_enter(&spa_namespace_lock);
4878 	spa_close(spa, FTAG);
4879 	mutex_exit(&spa_namespace_lock);
4880 
4881 	return (error);
4882 }
4883 
4884 /*
4885  * Split a set of devices from their mirrors, and create a new pool from them.
4886  */
4887 int
4888 spa_vdev_split_mirror(spa_t *spa, char *newname, nvlist_t *config,
4889     nvlist_t *props, boolean_t exp)
4890 {
4891 	int error = 0;
4892 	uint64_t txg, *glist;
4893 	spa_t *newspa;
4894 	uint_t c, children, lastlog;
4895 	nvlist_t **child, *nvl, *tmp;
4896 	dmu_tx_t *tx;
4897 	char *altroot = NULL;
4898 	vdev_t *rvd, **vml = NULL;			/* vdev modify list */
4899 	boolean_t activate_slog;
4900 
4901 	ASSERT(spa_writeable(spa));
4902 
4903 	txg = spa_vdev_enter(spa);
4904 
4905 	/* clear the log and flush everything up to now */
4906 	activate_slog = spa_passivate_log(spa);
4907 	(void) spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);
4908 	error = spa_offline_log(spa);
4909 	txg = spa_vdev_config_enter(spa);
4910 
4911 	if (activate_slog)
4912 		spa_activate_log(spa);
4913 
4914 	if (error != 0)
4915 		return (spa_vdev_exit(spa, NULL, txg, error));
4916 
4917 	/* check new spa name before going any further */
4918 	if (spa_lookup(newname) != NULL)
4919 		return (spa_vdev_exit(spa, NULL, txg, EEXIST));
4920 
4921 	/*
4922 	 * scan through all the children to ensure they're all mirrors
4923 	 */
4924 	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvl) != 0 ||
4925 	    nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_CHILDREN, &child,
4926 	    &children) != 0)
4927 		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
4928 
4929 	/* first, check to ensure we've got the right child count */
4930 	rvd = spa->spa_root_vdev;
4931 	lastlog = 0;
4932 	for (c = 0; c < rvd->vdev_children; c++) {
4933 		vdev_t *vd = rvd->vdev_child[c];
4934 
4935 		/* don't count the holes & logs as children */
4936 		if (vd->vdev_islog || vd->vdev_ishole) {
4937 			if (lastlog == 0)
4938 				lastlog = c;
4939 			continue;
4940 		}
4941 
4942 		lastlog = 0;
4943 	}
4944 	if (children != (lastlog != 0 ? lastlog : rvd->vdev_children))
4945 		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
4946 
4947 	/* next, ensure no spare or cache devices are part of the split */
4948 	if (nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_SPARES, &tmp) == 0 ||
4949 	    nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_L2CACHE, &tmp) == 0)
4950 		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
4951 
4952 	vml = kmem_zalloc(children * sizeof (vdev_t *), KM_SLEEP);
4953 	glist = kmem_zalloc(children * sizeof (uint64_t), KM_SLEEP);
4954 
4955 	/* then, loop over each vdev and validate it */
4956 	for (c = 0; c < children; c++) {
4957 		uint64_t is_hole = 0;
4958 
4959 		(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE,
4960 		    &is_hole);
4961 
4962 		if (is_hole != 0) {
4963 			if (spa->spa_root_vdev->vdev_child[c]->vdev_ishole ||
4964 			    spa->spa_root_vdev->vdev_child[c]->vdev_islog) {
4965 				continue;
4966 			} else {
4967 				error = SET_ERROR(EINVAL);
4968 				break;
4969 			}
4970 		}
4971 
4972 		/* which disk is going to be split? */
4973 		if (nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_GUID,
4974 		    &glist[c]) != 0) {
4975 			error = SET_ERROR(EINVAL);
4976 			break;
4977 		}
4978 
4979 		/* look it up in the spa */
4980 		vml[c] = spa_lookup_by_guid(spa, glist[c], B_FALSE);
4981 		if (vml[c] == NULL) {
4982 			error = SET_ERROR(ENODEV);
4983 			break;
4984 		}
4985 
4986 		/* make sure there's nothing stopping the split */
4987 		if (vml[c]->vdev_parent->vdev_ops != &vdev_mirror_ops ||
4988 		    vml[c]->vdev_islog ||
4989 		    vml[c]->vdev_ishole ||
4990 		    vml[c]->vdev_isspare ||
4991 		    vml[c]->vdev_isl2cache ||
4992 		    !vdev_writeable(vml[c]) ||
4993 		    vml[c]->vdev_children != 0 ||
4994 		    vml[c]->vdev_state != VDEV_STATE_HEALTHY ||
4995 		    c != spa->spa_root_vdev->vdev_child[c]->vdev_id) {
4996 			error = SET_ERROR(EINVAL);
4997 			break;
4998 		}
4999 
5000 		if (vdev_dtl_required(vml[c])) {
5001 			error = SET_ERROR(EBUSY);
5002 			break;
5003 		}
5004 
5005 		/* we need certain info from the top level */
5006 		VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_ARRAY,
5007 		    vml[c]->vdev_top->vdev_ms_array) == 0);
5008 		VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_SHIFT,
5009 		    vml[c]->vdev_top->vdev_ms_shift) == 0);
5010 		VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_ASIZE,
5011 		    vml[c]->vdev_top->vdev_asize) == 0);
5012 		VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_ASHIFT,
5013 		    vml[c]->vdev_top->vdev_ashift) == 0);
5014 	}
5015 
5016 	if (error != 0) {
5017 		kmem_free(vml, children * sizeof (vdev_t *));
5018 		kmem_free(glist, children * sizeof (uint64_t));
5019 		return (spa_vdev_exit(spa, NULL, txg, error));
5020 	}
5021 
5022 	/* stop writers from using the disks */
5023 	for (c = 0; c < children; c++) {
5024 		if (vml[c] != NULL)
5025 			vml[c]->vdev_offline = B_TRUE;
5026 	}
5027 	vdev_reopen(spa->spa_root_vdev);
5028 
5029 	/*
5030 	 * Temporarily record the splitting vdevs in the spa config.  This
5031 	 * will disappear once the config is regenerated.
5032 	 */
5033 	VERIFY(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP) == 0);
5034 	VERIFY(nvlist_add_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST,
5035 	    glist, children) == 0);
5036 	kmem_free(glist, children * sizeof (uint64_t));
5037 
5038 	mutex_enter(&spa->spa_props_lock);
5039 	VERIFY(nvlist_add_nvlist(spa->spa_config, ZPOOL_CONFIG_SPLIT,
5040 	    nvl) == 0);
5041 	mutex_exit(&spa->spa_props_lock);
5042 	spa->spa_config_splitting = nvl;
5043 	vdev_config_dirty(spa->spa_root_vdev);
5044 
5045 	/* configure and create the new pool */
5046 	VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, newname) == 0);
5047 	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE,
5048 	    exp ? POOL_STATE_EXPORTED : POOL_STATE_ACTIVE) == 0);
5049 	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_VERSION,
5050 	    spa_version(spa)) == 0);
5051 	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_TXG,
5052 	    spa->spa_config_txg) == 0);
5053 	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_GUID,
5054 	    spa_generate_guid(NULL)) == 0);
5055 	(void) nvlist_lookup_string(props,
5056 	    zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot);
5057 
5058 	/* add the new pool to the namespace */
5059 	newspa = spa_add(newname, config, altroot);
5060 	newspa->spa_config_txg = spa->spa_config_txg;
5061 	spa_set_log_state(newspa, SPA_LOG_CLEAR);
5062 
5063 	/* release the spa config lock, retaining the namespace lock */
5064 	spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);
5065 
5066 	if (zio_injection_enabled)
5067 		zio_handle_panic_injection(spa, FTAG, 1);
5068 
5069 	spa_activate(newspa, spa_mode_global);
5070 	spa_async_suspend(newspa);
5071 
5072 	/* create the new pool from the disks of the original pool */
5073 	error = spa_load(newspa, SPA_LOAD_IMPORT, SPA_IMPORT_ASSEMBLE, B_TRUE);
5074 	if (error)
5075 		goto out;
5076 
5077 	/* if that worked, generate a real config for the new pool */
5078 	if (newspa->spa_root_vdev != NULL) {
5079 		VERIFY(nvlist_alloc(&newspa->spa_config_splitting,
5080 		    NV_UNIQUE_NAME, KM_SLEEP) == 0);
5081 		VERIFY(nvlist_add_uint64(newspa->spa_config_splitting,
5082 		    ZPOOL_CONFIG_SPLIT_GUID, spa_guid(spa)) == 0);
5083 		spa_config_set(newspa, spa_config_generate(newspa, NULL, -1ULL,
5084 		    B_TRUE));
5085 	}
5086 
5087 	/* set the props */
5088 	if (props != NULL) {
5089 		spa_configfile_set(newspa, props, B_FALSE);
5090 		error = spa_prop_set(newspa, props);
5091 		if (error)
5092 			goto out;
5093 	}
5094 
5095 	/* flush everything */
5096 	txg = spa_vdev_config_enter(newspa);
5097 	vdev_config_dirty(newspa->spa_root_vdev);
5098 	(void) spa_vdev_config_exit(newspa, NULL, txg, 0, FTAG);
5099 
5100 	if (zio_injection_enabled)
5101 		zio_handle_panic_injection(spa, FTAG, 2);
5102 
5103 	spa_async_resume(newspa);
5104 
5105 	/* finally, update the original pool's config */
5106 	txg = spa_vdev_config_enter(spa);
5107 	tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
5108 	error = dmu_tx_assign(tx, TXG_WAIT);
5109 	if (error != 0)
5110 		dmu_tx_abort(tx);
5111 	for (c = 0; c < children; c++) {
5112 		if (vml[c] != NULL) {
5113 			vdev_split(vml[c]);
5114 			if (error == 0)
5115 				spa_history_log_internal(spa, "detach", tx,
5116 				    "vdev=%s", vml[c]->vdev_path);
5117 			vdev_free(vml[c]);
5118 		}
5119 	}
5120 	vdev_config_dirty(spa->spa_root_vdev);
5121 	spa->spa_config_splitting = NULL;
5122 	nvlist_free(nvl);
5123 	if (error == 0)
5124 		dmu_tx_commit(tx);
5125 	(void) spa_vdev_exit(spa, NULL, txg, 0);
5126 
5127 	if (zio_injection_enabled)
5128 		zio_handle_panic_injection(spa, FTAG, 3);
5129 
5130 	/* split is complete; log a history record */
5131 	spa_history_log_internal(newspa, "split", NULL,
5132 	    "from pool %s", spa_name(spa));
5133 
5134 	kmem_free(vml, children * sizeof (vdev_t *));
5135 
5136 	/* if we're not going to mount the filesystems in userland, export */
5137 	if (exp)
5138 		error = spa_export_common(newname, POOL_STATE_EXPORTED, NULL,
5139 		    B_FALSE, B_FALSE);
5140 
5141 	return (error);
5142 
5143 out:
5144 	spa_unload(newspa);
5145 	spa_deactivate(newspa);
5146 	spa_remove(newspa);
5147 
5148 	txg = spa_vdev_config_enter(spa);
5149 
5150 	/* re-online all offlined disks */
5151 	for (c = 0; c < children; c++) {
5152 		if (vml[c] != NULL)
5153 			vml[c]->vdev_offline = B_FALSE;
5154 	}
5155 	vdev_reopen(spa->spa_root_vdev);
5156 
5157 	nvlist_free(spa->spa_config_splitting);
5158 	spa->spa_config_splitting = NULL;
5159 	(void) spa_vdev_exit(spa, NULL, txg, error);
5160 
5161 	kmem_free(vml, children * sizeof (vdev_t *));
5162 	return (error);
5163 }
5164 
5165 static nvlist_t *
5166 spa_nvlist_lookup_by_guid(nvlist_t **nvpp, int count, uint64_t target_guid)
5167 {
5168 	for (int i = 0; i < count; i++) {
5169 		uint64_t guid;
5170 
5171 		VERIFY(nvlist_lookup_uint64(nvpp[i], ZPOOL_CONFIG_GUID,
5172 		    &guid) == 0);
5173 
5174 		if (guid == target_guid)
5175 			return (nvpp[i]);
5176 	}
5177 
5178 	return (NULL);
5179 }
5180 
5181 static void
5182 spa_vdev_remove_aux(nvlist_t *config, char *name, nvlist_t **dev, int count,
5183 	nvlist_t *dev_to_remove)
5184 {
5185 	nvlist_t **newdev = NULL;
5186 
5187 	if (count > 1)
5188 		newdev = kmem_alloc((count - 1) * sizeof (void *), KM_SLEEP);
5189 
5190 	for (int i = 0, j = 0; i < count; i++) {
5191 		if (dev[i] == dev_to_remove)
5192 			continue;
5193 		VERIFY(nvlist_dup(dev[i], &newdev[j++], KM_SLEEP) == 0);
5194 	}
5195 
5196 	VERIFY(nvlist_remove(config, name, DATA_TYPE_NVLIST_ARRAY) == 0);
5197 	VERIFY(nvlist_add_nvlist_array(config, name, newdev, count - 1) == 0);
5198 
5199 	for (int i = 0; i < count - 1; i++)
5200 		nvlist_free(newdev[i]);
5201 
5202 	if (count > 1)
5203 		kmem_free(newdev, (count - 1) * sizeof (void *));
5204 }
5205 
5206 /*
5207  * Evacuate the device.
5208  */
5209 static int
5210 spa_vdev_remove_evacuate(spa_t *spa, vdev_t *vd)
5211 {
5212 	uint64_t txg;
5213 	int error = 0;
5214 
5215 	ASSERT(MUTEX_HELD(&spa_namespace_lock));
5216 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
5217 	ASSERT(vd == vd->vdev_top);
5218 
5219 	/*
5220 	 * Evacuate the device.  We don't hold the config lock as writer
5221 	 * since we need to do I/O but we do keep the
5222 	 * spa_namespace_lock held.  Once this completes the device
5223 	 * should no longer have any blocks allocated on it.
5224 	 */
5225 	if (vd->vdev_islog) {
5226 		if (vd->vdev_stat.vs_alloc != 0)
5227 			error = spa_offline_log(spa);
5228 	} else {
5229 		error = SET_ERROR(ENOTSUP);
5230 	}
5231 
5232 	if (error)
5233 		return (error);
5234 
5235 	/*
5236 	 * The evacuation succeeded.  Remove any remaining MOS metadata
5237 	 * associated with this vdev, and wait for these changes to sync.
5238 	 */
5239 	ASSERT0(vd->vdev_stat.vs_alloc);
5240 	txg = spa_vdev_config_enter(spa);
5241 	vd->vdev_removing = B_TRUE;
5242 	vdev_dirty_leaves(vd, VDD_DTL, txg);
5243 	vdev_config_dirty(vd);
5244 	spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);
5245 
5246 	return (0);
5247 }
5248 
5249 /*
5250  * Complete the removal by cleaning up the namespace.
5251  */
5252 static void
5253 spa_vdev_remove_from_namespace(spa_t *spa, vdev_t *vd)
5254 {
5255 	vdev_t *rvd = spa->spa_root_vdev;
5256 	uint64_t id = vd->vdev_id;
5257 	boolean_t last_vdev = (id == (rvd->vdev_children - 1));
5258 
5259 	ASSERT(MUTEX_HELD(&spa_namespace_lock));
5260 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
5261 	ASSERT(vd == vd->vdev_top);
5262 
5263 	/*
5264 	 * Only remove any devices which are empty.
5265 	 */
5266 	if (vd->vdev_stat.vs_alloc != 0)
5267 		return;
5268 
5269 	(void) vdev_label_init(vd, 0, VDEV_LABEL_REMOVE);
5270 
5271 	if (list_link_active(&vd->vdev_state_dirty_node))
5272 		vdev_state_clean(vd);
5273 	if (list_link_active(&vd->vdev_config_dirty_node))
5274 		vdev_config_clean(vd);
5275 
5276 	vdev_free(vd);
5277 
5278 	if (last_vdev) {
5279 		vdev_compact_children(rvd);
5280 	} else {
5281 		vd = vdev_alloc_common(spa, id, 0, &vdev_hole_ops);
5282 		vdev_add_child(rvd, vd);
5283 	}
5284 	vdev_config_dirty(rvd);
5285 
5286 	/*
5287 	 * Reassess the health of our root vdev.
5288 	 */
5289 	vdev_reopen(rvd);
5290 }
5291 
5292 /*
5293  * Remove a device from the pool -
5294  *
5295  * Removing a device from the vdev namespace requires several steps
5296  * and can take a significant amount of time.  As a result we use
5297  * the spa_vdev_config_[enter/exit] functions which allow us to
5298  * grab and release the spa_config_lock while still holding the namespace
5299  * lock.  During each step the configuration is synced out.
5300  *
5301  * Currently, this supports removing only hot spares, slogs, and level 2 ARC
5302  * devices.
5303  */
5304 int
5305 spa_vdev_remove(spa_t *spa, uint64_t guid, boolean_t unspare)
5306 {
5307 	vdev_t *vd;
5308 	metaslab_group_t *mg;
5309 	nvlist_t **spares, **l2cache, *nv;
5310 	uint64_t txg = 0;
5311 	uint_t nspares, nl2cache;
5312 	int error = 0;
5313 	boolean_t locked = MUTEX_HELD(&spa_namespace_lock);
5314 
5315 	ASSERT(spa_writeable(spa));
5316 
5317 	if (!locked)
5318 		txg = spa_vdev_enter(spa);
5319 
5320 	vd = spa_lookup_by_guid(spa, guid, B_FALSE);
5321 
5322 	if (spa->spa_spares.sav_vdevs != NULL &&
5323 	    nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
5324 	    ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0 &&
5325 	    (nv = spa_nvlist_lookup_by_guid(spares, nspares, guid)) != NULL) {
5326 		/*
5327 		 * Only remove the hot spare if it's not currently in use
5328 		 * in this pool.
5329 		 */
5330 		if (vd == NULL || unspare) {
5331 			spa_vdev_remove_aux(spa->spa_spares.sav_config,
5332 			    ZPOOL_CONFIG_SPARES, spares, nspares, nv);
5333 			spa_load_spares(spa);
5334 			spa->spa_spares.sav_sync = B_TRUE;
5335 		} else {
5336 			error = SET_ERROR(EBUSY);
5337 		}
5338 	} else if (spa->spa_l2cache.sav_vdevs != NULL &&
5339 	    nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config,
5340 	    ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0 &&
5341 	    (nv = spa_nvlist_lookup_by_guid(l2cache, nl2cache, guid)) != NULL) {
5342 		/*
5343 		 * Cache devices can always be removed.
5344 		 */
5345 		spa_vdev_remove_aux(spa->spa_l2cache.sav_config,
5346 		    ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache, nv);
5347 		spa_load_l2cache(spa);
5348 		spa->spa_l2cache.sav_sync = B_TRUE;
5349 	} else if (vd != NULL && vd->vdev_islog) {
5350 		ASSERT(!locked);
5351 		ASSERT(vd == vd->vdev_top);
5352 
5353 		mg = vd->vdev_mg;
5354 
5355 		/*
5356 		 * Stop allocating from this vdev.
5357 		 */
5358 		metaslab_group_passivate(mg);
5359 
5360 		/*
5361 		 * Wait for the youngest allocations and frees to sync,
5362 		 * and then wait for the deferral of those frees to finish.
5363 		 */
5364 		spa_vdev_config_exit(spa, NULL,
5365 		    txg + TXG_CONCURRENT_STATES + TXG_DEFER_SIZE, 0, FTAG);
5366 
5367 		/*
5368 		 * Attempt to evacuate the vdev.
5369 		 */
5370 		error = spa_vdev_remove_evacuate(spa, vd);
5371 
5372 		txg = spa_vdev_config_enter(spa);
5373 
5374 		/*
5375 		 * If we couldn't evacuate the vdev, unwind.
5376 		 */
5377 		if (error) {
5378 			metaslab_group_activate(mg);
5379 			return (spa_vdev_exit(spa, NULL, txg, error));
5380 		}
5381 
5382 		/*
5383 		 * Clean up the vdev namespace.
5384 		 */
5385 		spa_vdev_remove_from_namespace(spa, vd);
5386 
5387 	} else if (vd != NULL) {
5388 		/*
5389 		 * Normal vdevs cannot be removed (yet).
5390 		 */
5391 		error = SET_ERROR(ENOTSUP);
5392 	} else {
5393 		/*
5394 		 * There is no vdev of any kind with the specified guid.
5395 		 */
5396 		error = SET_ERROR(ENOENT);
5397 	}
5398 
5399 	if (!locked)
5400 		return (spa_vdev_exit(spa, NULL, txg, error));
5401 
5402 	return (error);
5403 }
5404 
5405 /*
5406  * Find any device that's done replacing, or a vdev marked 'unspare' that's
5407  * currently spared, so we can detach it.
5408  */
5409 static vdev_t *
5410 spa_vdev_resilver_done_hunt(vdev_t *vd)
5411 {
5412 	vdev_t *newvd, *oldvd;
5413 
5414 	for (int c = 0; c < vd->vdev_children; c++) {
5415 		oldvd = spa_vdev_resilver_done_hunt(vd->vdev_child[c]);
5416 		if (oldvd != NULL)
5417 			return (oldvd);
5418 	}
5419 
5420 	/*
5421 	 * Check for a completed replacement.  We always consider the first
5422 	 * vdev in the list to be the oldest vdev, and the last one to be
5423 	 * the newest (see spa_vdev_attach() for how that works).  In
5424 	 * the case where the newest vdev is faulted, we will not automatically
5425 	 * remove it after a resilver completes.  This is OK as it will require
5426 	 * user intervention to determine which disk the admin wishes to keep.
5427 	 */
5428 	if (vd->vdev_ops == &vdev_replacing_ops) {
5429 		ASSERT(vd->vdev_children > 1);
5430 
5431 		newvd = vd->vdev_child[vd->vdev_children - 1];
5432 		oldvd = vd->vdev_child[0];
5433 
5434 		if (vdev_dtl_empty(newvd, DTL_MISSING) &&
5435 		    vdev_dtl_empty(newvd, DTL_OUTAGE) &&
5436 		    !vdev_dtl_required(oldvd))
5437 			return (oldvd);
5438 	}
5439 
5440 	/*
5441 	 * Check for a completed resilver with the 'unspare' flag set.
5442 	 */
5443 	if (vd->vdev_ops == &vdev_spare_ops) {
5444 		vdev_t *first = vd->vdev_child[0];
5445 		vdev_t *last = vd->vdev_child[vd->vdev_children - 1];
5446 
5447 		if (last->vdev_unspare) {
5448 			oldvd = first;
5449 			newvd = last;
5450 		} else if (first->vdev_unspare) {
5451 			oldvd = last;
5452 			newvd = first;
5453 		} else {
5454 			oldvd = NULL;
5455 		}
5456 
5457 		if (oldvd != NULL &&
5458 		    vdev_dtl_empty(newvd, DTL_MISSING) &&
5459 		    vdev_dtl_empty(newvd, DTL_OUTAGE) &&
5460 		    !vdev_dtl_required(oldvd))
5461 			return (oldvd);
5462 
5463 		/*
5464 		 * If there are more than two spares attached to a disk,
5465 		 * and those spares are not required, then we want to
5466 		 * attempt to free them up now so that they can be used
5467 		 * by other pools.  Once we're back down to a single
5468 		 * disk+spare, we stop removing them.
5469 		 */
5470 		if (vd->vdev_children > 2) {
5471 			newvd = vd->vdev_child[1];
5472 
5473 			if (newvd->vdev_isspare && last->vdev_isspare &&
5474 			    vdev_dtl_empty(last, DTL_MISSING) &&
5475 			    vdev_dtl_empty(last, DTL_OUTAGE) &&
5476 			    !vdev_dtl_required(newvd))
5477 				return (newvd);
5478 		}
5479 	}
5480 
5481 	return (NULL);
5482 }
5483 
5484 static void
5485 spa_vdev_resilver_done(spa_t *spa)
5486 {
5487 	vdev_t *vd, *pvd, *ppvd;
5488 	uint64_t guid, sguid, pguid, ppguid;
5489 
5490 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
5491 
5492 	while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) {
5493 		pvd = vd->vdev_parent;
5494 		ppvd = pvd->vdev_parent;
5495 		guid = vd->vdev_guid;
5496 		pguid = pvd->vdev_guid;
5497 		ppguid = ppvd->vdev_guid;
5498 		sguid = 0;
5499 		/*
5500 		 * If we have just finished replacing a hot spared device, then
5501 		 * we need to detach the parent's first child (the original hot
5502 		 * spare) as well.
5503 		 */
5504 		if (ppvd->vdev_ops == &vdev_spare_ops && pvd->vdev_id == 0 &&
5505 		    ppvd->vdev_children == 2) {
5506 			ASSERT(pvd->vdev_ops == &vdev_replacing_ops);
5507 			sguid = ppvd->vdev_child[1]->vdev_guid;
5508 		}
5509 		ASSERT(vd->vdev_resilver_txg == 0 || !vdev_dtl_required(vd));
5510 
5511 		spa_config_exit(spa, SCL_ALL, FTAG);
5512 		if (spa_vdev_detach(spa, guid, pguid, B_TRUE) != 0)
5513 			return;
5514 		if (sguid && spa_vdev_detach(spa, sguid, ppguid, B_TRUE) != 0)
5515 			return;
5516 		spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
5517 	}
5518 
5519 	spa_config_exit(spa, SCL_ALL, FTAG);
5520 }
5521 
5522 /*
5523  * Update the stored path or FRU for this vdev.
5524  */
5525 int
5526 spa_vdev_set_common(spa_t *spa, uint64_t guid, const char *value,
5527     boolean_t ispath)
5528 {
5529 	vdev_t *vd;
5530 	boolean_t sync = B_FALSE;
5531 
5532 	ASSERT(spa_writeable(spa));
5533 
5534 	spa_vdev_state_enter(spa, SCL_ALL);
5535 
5536 	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
5537 		return (spa_vdev_state_exit(spa, NULL, ENOENT));
5538 
5539 	if (!vd->vdev_ops->vdev_op_leaf)
5540 		return (spa_vdev_state_exit(spa, NULL, ENOTSUP));
5541 
5542 	if (ispath) {
5543 		if (strcmp(value, vd->vdev_path) != 0) {
5544 			spa_strfree(vd->vdev_path);
5545 			vd->vdev_path = spa_strdup(value);
5546 			sync = B_TRUE;
5547 		}
5548 	} else {
5549 		if (vd->vdev_fru == NULL) {
5550 			vd->vdev_fru = spa_strdup(value);
5551 			sync = B_TRUE;
5552 		} else if (strcmp(value, vd->vdev_fru) != 0) {
5553 			spa_strfree(vd->vdev_fru);
5554 			vd->vdev_fru = spa_strdup(value);
5555 			sync = B_TRUE;
5556 		}
5557 	}
5558 
5559 	return (spa_vdev_state_exit(spa, sync ? vd : NULL, 0));
5560 }
5561 
5562 int
5563 spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath)
5564 {
5565 	return (spa_vdev_set_common(spa, guid, newpath, B_TRUE));
5566 }
5567 
5568 int
5569 spa_vdev_setfru(spa_t *spa, uint64_t guid, const char *newfru)
5570 {
5571 	return (spa_vdev_set_common(spa, guid, newfru, B_FALSE));
5572 }
5573 
5574 /*
5575  * ==========================================================================
5576  * SPA Scanning
5577  * ==========================================================================
5578  */
5579 
5580 int
5581 spa_scan_stop(spa_t *spa)
5582 {
5583 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
5584 	if (dsl_scan_resilvering(spa->spa_dsl_pool))
5585 		return (SET_ERROR(EBUSY));
5586 	return (dsl_scan_cancel(spa->spa_dsl_pool));
5587 }
5588 
5589 int
5590 spa_scan(spa_t *spa, pool_scan_func_t func)
5591 {
5592 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
5593 
5594 	if (func >= POOL_SCAN_FUNCS || func == POOL_SCAN_NONE)
5595 		return (SET_ERROR(ENOTSUP));
5596 
5597 	/*
5598 	 * If a resilver was requested, but there is no DTL on a
5599 	 * writeable leaf device, we have nothing to do.
5600 	 */
5601 	if (func == POOL_SCAN_RESILVER &&
5602 	    !vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) {
5603 		spa_async_request(spa, SPA_ASYNC_RESILVER_DONE);
5604 		return (0);
5605 	}
5606 
5607 	return (dsl_scan(spa->spa_dsl_pool, func));
5608 }
5609 
5610 /*
5611  * ==========================================================================
5612  * SPA async task processing
5613  * ==========================================================================
5614  */
5615 
5616 static void
5617 spa_async_remove(spa_t *spa, vdev_t *vd)
5618 {
5619 	if (vd->vdev_remove_wanted) {
5620 		vd->vdev_remove_wanted = B_FALSE;
5621 		vd->vdev_delayed_close = B_FALSE;
5622 		vdev_set_state(vd, B_FALSE, VDEV_STATE_REMOVED, VDEV_AUX_NONE);
5623 
5624 		/*
5625 		 * We want to clear the stats, but we don't want to do a full
5626 		 * vdev_clear() as that will cause us to throw away
5627 		 * degraded/faulted state as well as attempt to reopen the
5628 		 * device, all of which is a waste.
5629 		 */
5630 		vd->vdev_stat.vs_read_errors = 0;
5631 		vd->vdev_stat.vs_write_errors = 0;
5632 		vd->vdev_stat.vs_checksum_errors = 0;
5633 
5634 		vdev_state_dirty(vd->vdev_top);
5635 	}
5636 
5637 	for (int c = 0; c < vd->vdev_children; c++)
5638 		spa_async_remove(spa, vd->vdev_child[c]);
5639 }
5640 
5641 static void
5642 spa_async_probe(spa_t *spa, vdev_t *vd)
5643 {
5644 	if (vd->vdev_probe_wanted) {
5645 		vd->vdev_probe_wanted = B_FALSE;
5646 		vdev_reopen(vd);	/* vdev_open() does the actual probe */
5647 	}
5648 
5649 	for (int c = 0; c < vd->vdev_children; c++)
5650 		spa_async_probe(spa, vd->vdev_child[c]);
5651 }
5652 
5653 static void
5654 spa_async_autoexpand(spa_t *spa, vdev_t *vd)
5655 {
5656 	sysevent_id_t eid;
5657 	nvlist_t *attr;
5658 	char *physpath;
5659 
5660 	if (!spa->spa_autoexpand)
5661 		return;
5662 
5663 	for (int c = 0; c < vd->vdev_children; c++) {
5664 		vdev_t *cvd = vd->vdev_child[c];
5665 		spa_async_autoexpand(spa, cvd);
5666 	}
5667 
5668 	if (!vd->vdev_ops->vdev_op_leaf || vd->vdev_physpath == NULL)
5669 		return;
5670 
5671 	physpath = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
5672 	(void) snprintf(physpath, MAXPATHLEN, "/devices%s", vd->vdev_physpath);
5673 
5674 	VERIFY(nvlist_alloc(&attr, NV_UNIQUE_NAME, KM_SLEEP) == 0);
5675 	VERIFY(nvlist_add_string(attr, DEV_PHYS_PATH, physpath) == 0);
5676 
5677 	(void) ddi_log_sysevent(zfs_dip, SUNW_VENDOR, EC_DEV_STATUS,
5678 	    ESC_DEV_DLE, attr, &eid, DDI_SLEEP);
5679 
5680 	nvlist_free(attr);
5681 	kmem_free(physpath, MAXPATHLEN);
5682 }
5683 
5684 static void
5685 spa_async_thread(spa_t *spa)
5686 {
5687 	int tasks;
5688 
5689 	ASSERT(spa->spa_sync_on);
5690 
5691 	mutex_enter(&spa->spa_async_lock);
5692 	tasks = spa->spa_async_tasks;
5693 	spa->spa_async_tasks = 0;
5694 	mutex_exit(&spa->spa_async_lock);
5695 
5696 	/*
5697 	 * See if the config needs to be updated.
5698 	 */
5699 	if (tasks & SPA_ASYNC_CONFIG_UPDATE) {
5700 		uint64_t old_space, new_space;
5701 
5702 		mutex_enter(&spa_namespace_lock);
5703 		old_space = metaslab_class_get_space(spa_normal_class(spa));
5704 		spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
5705 		new_space = metaslab_class_get_space(spa_normal_class(spa));
5706 		mutex_exit(&spa_namespace_lock);
5707 
5708 		/*
5709 		 * If the pool grew as a result of the config update,
5710 		 * then log an internal history event.
5711 		 */
5712 		if (new_space != old_space) {
5713 			spa_history_log_internal(spa, "vdev online", NULL,
5714 			    "pool '%s' size: %llu(+%llu)",
5715 			    spa_name(spa), new_space, new_space - old_space);
5716 		}
5717 	}
5718 
5719 	/*
5720 	 * See if any devices need to be marked REMOVED.
5721 	 */
5722 	if (tasks & SPA_ASYNC_REMOVE) {
5723 		spa_vdev_state_enter(spa, SCL_NONE);
5724 		spa_async_remove(spa, spa->spa_root_vdev);
5725 		for (int i = 0; i < spa->spa_l2cache.sav_count; i++)
5726 			spa_async_remove(spa, spa->spa_l2cache.sav_vdevs[i]);
5727 		for (int i = 0; i < spa->spa_spares.sav_count; i++)
5728 			spa_async_remove(spa, spa->spa_spares.sav_vdevs[i]);
5729 		(void) spa_vdev_state_exit(spa, NULL, 0);
5730 	}
5731 
5732 	if ((tasks & SPA_ASYNC_AUTOEXPAND) && !spa_suspended(spa)) {
5733 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
5734 		spa_async_autoexpand(spa, spa->spa_root_vdev);
5735 		spa_config_exit(spa, SCL_CONFIG, FTAG);
5736 	}
5737 
5738 	/*
5739 	 * See if any devices need to be probed.
5740 	 */
5741 	if (tasks & SPA_ASYNC_PROBE) {
5742 		spa_vdev_state_enter(spa, SCL_NONE);
5743 		spa_async_probe(spa, spa->spa_root_vdev);
5744 		(void) spa_vdev_state_exit(spa, NULL, 0);
5745 	}
5746 
5747 	/*
5748 	 * If any devices are done replacing, detach them.
5749 	 */
5750 	if (tasks & SPA_ASYNC_RESILVER_DONE)
5751 		spa_vdev_resilver_done(spa);
5752 
5753 	/*
5754 	 * Kick off a resilver.
5755 	 */
5756 	if (tasks & SPA_ASYNC_RESILVER)
5757 		dsl_resilver_restart(spa->spa_dsl_pool, 0);
5758 
5759 	/*
5760 	 * Let the world know that we're done.
5761 	 */
5762 	mutex_enter(&spa->spa_async_lock);
5763 	spa->spa_async_thread = NULL;
5764 	cv_broadcast(&spa->spa_async_cv);
5765 	mutex_exit(&spa->spa_async_lock);
5766 	thread_exit();
5767 }
5768 
5769 void
5770 spa_async_suspend(spa_t *spa)
5771 {
5772 	mutex_enter(&spa->spa_async_lock);
5773 	spa->spa_async_suspended++;
5774 	while (spa->spa_async_thread != NULL)
5775 		cv_wait(&spa->spa_async_cv, &spa->spa_async_lock);
5776 	mutex_exit(&spa->spa_async_lock);
5777 }
5778 
5779 void
5780 spa_async_resume(spa_t *spa)
5781 {
5782 	mutex_enter(&spa->spa_async_lock);
5783 	ASSERT(spa->spa_async_suspended != 0);
5784 	spa->spa_async_suspended--;
5785 	mutex_exit(&spa->spa_async_lock);
5786 }
5787 
5788 static boolean_t
5789 spa_async_tasks_pending(spa_t *spa)
5790 {
5791 	uint_t non_config_tasks;
5792 	uint_t config_task;
5793 	boolean_t config_task_suspended;
5794 
5795 	non_config_tasks = spa->spa_async_tasks & ~SPA_ASYNC_CONFIG_UPDATE;
5796 	config_task = spa->spa_async_tasks & SPA_ASYNC_CONFIG_UPDATE;
5797 	if (spa->spa_ccw_fail_time == 0) {
5798 		config_task_suspended = B_FALSE;
5799 	} else {
5800 		config_task_suspended =
5801 		    (gethrtime() - spa->spa_ccw_fail_time) <
5802 		    (zfs_ccw_retry_interval * NANOSEC);
5803 	}
5804 
5805 	return (non_config_tasks || (config_task && !config_task_suspended));
5806 }
5807 
5808 static void
5809 spa_async_dispatch(spa_t *spa)
5810 {
5811 	mutex_enter(&spa->spa_async_lock);
5812 	if (spa_async_tasks_pending(spa) &&
5813 	    !spa->spa_async_suspended &&
5814 	    spa->spa_async_thread == NULL &&
5815 	    rootdir != NULL)
5816 		spa->spa_async_thread = thread_create(NULL, 0,
5817 		    spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri);
5818 	mutex_exit(&spa->spa_async_lock);
5819 }
5820 
5821 void
5822 spa_async_request(spa_t *spa, int task)
5823 {
5824 	zfs_dbgmsg("spa=%s async request task=%u", spa->spa_name, task);
5825 	mutex_enter(&spa->spa_async_lock);
5826 	spa->spa_async_tasks |= task;
5827 	mutex_exit(&spa->spa_async_lock);
5828 }
5829 
5830 /*
5831  * ==========================================================================
5832  * SPA syncing routines
5833  * ==========================================================================
5834  */
5835 
5836 static int
5837 bpobj_enqueue_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
5838 {
5839 	bpobj_t *bpo = arg;
5840 	bpobj_enqueue(bpo, bp, tx);
5841 	return (0);
5842 }
5843 
5844 static int
5845 spa_free_sync_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
5846 {
5847 	zio_t *zio = arg;
5848 
5849 	zio_nowait(zio_free_sync(zio, zio->io_spa, dmu_tx_get_txg(tx), bp,
5850 	    zio->io_flags));
5851 	return (0);
5852 }
5853 
5854 /*
5855  * Note: this simple function is not inlined to make it easier to dtrace the
5856  * amount of time spent syncing frees.
5857  */
5858 static void
5859 spa_sync_frees(spa_t *spa, bplist_t *bpl, dmu_tx_t *tx)
5860 {
5861 	zio_t *zio = zio_root(spa, NULL, NULL, 0);
5862 	bplist_iterate(bpl, spa_free_sync_cb, zio, tx);
5863 	VERIFY(zio_wait(zio) == 0);
5864 }
5865 
5866 /*
5867  * Note: this simple function is not inlined to make it easier to dtrace the
5868  * amount of time spent syncing deferred frees.
5869  */
5870 static void
5871 spa_sync_deferred_frees(spa_t *spa, dmu_tx_t *tx)
5872 {
5873 	zio_t *zio = zio_root(spa, NULL, NULL, 0);
5874 	VERIFY3U(bpobj_iterate(&spa->spa_deferred_bpobj,
5875 	    spa_free_sync_cb, zio, tx), ==, 0);
5876 	VERIFY0(zio_wait(zio));
5877 }
5878 
5879 
5880 static void
5881 spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx)
5882 {
5883 	char *packed = NULL;
5884 	size_t bufsize;
5885 	size_t nvsize = 0;
5886 	dmu_buf_t *db;
5887 
5888 	VERIFY(nvlist_size(nv, &nvsize, NV_ENCODE_XDR) == 0);
5889 
5890 	/*
5891 	 * Write full (SPA_CONFIG_BLOCKSIZE) blocks of configuration
5892 	 * information.  This avoids the dmu_buf_will_dirty() path and
5893 	 * saves us a pre-read to get data we don't actually care about.
5894 	 */
5895 	bufsize = P2ROUNDUP((uint64_t)nvsize, SPA_CONFIG_BLOCKSIZE);
5896 	packed = kmem_alloc(bufsize, KM_SLEEP);
5897 
5898 	VERIFY(nvlist_pack(nv, &packed, &nvsize, NV_ENCODE_XDR,
5899 	    KM_SLEEP) == 0);
5900 	bzero(packed + nvsize, bufsize - nvsize);
5901 
5902 	dmu_write(spa->spa_meta_objset, obj, 0, bufsize, packed, tx);
5903 
5904 	kmem_free(packed, bufsize);
5905 
5906 	VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db));
5907 	dmu_buf_will_dirty(db, tx);
5908 	*(uint64_t *)db->db_data = nvsize;
5909 	dmu_buf_rele(db, FTAG);
5910 }
5911 
5912 static void
5913 spa_sync_aux_dev(spa_t *spa, spa_aux_vdev_t *sav, dmu_tx_t *tx,
5914     const char *config, const char *entry)
5915 {
5916 	nvlist_t *nvroot;
5917 	nvlist_t **list;
5918 	int i;
5919 
5920 	if (!sav->sav_sync)
5921 		return;
5922 
5923 	/*
5924 	 * Update the MOS nvlist describing the list of available devices.
5925 	 * spa_validate_aux() will have already made sure this nvlist is
5926 	 * valid and the vdevs are labeled appropriately.
5927 	 */
5928 	if (sav->sav_object == 0) {
5929 		sav->sav_object = dmu_object_alloc(spa->spa_meta_objset,
5930 		    DMU_OT_PACKED_NVLIST, 1 << 14, DMU_OT_PACKED_NVLIST_SIZE,
5931 		    sizeof (uint64_t), tx);
5932 		VERIFY(zap_update(spa->spa_meta_objset,
5933 		    DMU_POOL_DIRECTORY_OBJECT, entry, sizeof (uint64_t), 1,
5934 		    &sav->sav_object, tx) == 0);
5935 	}
5936 
5937 	VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0);
5938 	if (sav->sav_count == 0) {
5939 		VERIFY(nvlist_add_nvlist_array(nvroot, config, NULL, 0) == 0);
5940 	} else {
5941 		list = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP);
5942 		for (i = 0; i < sav->sav_count; i++)
5943 			list[i] = vdev_config_generate(spa, sav->sav_vdevs[i],
5944 			    B_FALSE, VDEV_CONFIG_L2CACHE);
5945 		VERIFY(nvlist_add_nvlist_array(nvroot, config, list,
5946 		    sav->sav_count) == 0);
5947 		for (i = 0; i < sav->sav_count; i++)
5948 			nvlist_free(list[i]);
5949 		kmem_free(list, sav->sav_count * sizeof (void *));
5950 	}
5951 
5952 	spa_sync_nvlist(spa, sav->sav_object, nvroot, tx);
5953 	nvlist_free(nvroot);
5954 
5955 	sav->sav_sync = B_FALSE;
5956 }
5957 
5958 static void
5959 spa_sync_config_object(spa_t *spa, dmu_tx_t *tx)
5960 {
5961 	nvlist_t *config;
5962 
5963 	if (list_is_empty(&spa->spa_config_dirty_list))
5964 		return;
5965 
5966 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
5967 
5968 	config = spa_config_generate(spa, spa->spa_root_vdev,
5969 	    dmu_tx_get_txg(tx), B_FALSE);
5970 
5971 	/*
5972 	 * If we're upgrading the spa version then make sure that
5973 	 * the config object gets updated with the correct version.
5974 	 */
5975 	if (spa->spa_ubsync.ub_version < spa->spa_uberblock.ub_version)
5976 		fnvlist_add_uint64(config, ZPOOL_CONFIG_VERSION,
5977 		    spa->spa_uberblock.ub_version);
5978 
5979 	spa_config_exit(spa, SCL_STATE, FTAG);
5980 
5981 	if (spa->spa_config_syncing)
5982 		nvlist_free(spa->spa_config_syncing);
5983 	spa->spa_config_syncing = config;
5984 
5985 	spa_sync_nvlist(spa, spa->spa_config_object, config, tx);
5986 }
5987 
5988 static void
5989 spa_sync_version(void *arg, dmu_tx_t *tx)
5990 {
5991 	uint64_t *versionp = arg;
5992 	uint64_t version = *versionp;
5993 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
5994 
5995 	/*
5996 	 * Setting the version is special cased when first creating the pool.
5997 	 */
5998 	ASSERT(tx->tx_txg != TXG_INITIAL);
5999 
6000 	ASSERT(SPA_VERSION_IS_SUPPORTED(version));
6001 	ASSERT(version >= spa_version(spa));
6002 
6003 	spa->spa_uberblock.ub_version = version;
6004 	vdev_config_dirty(spa->spa_root_vdev);
6005 	spa_history_log_internal(spa, "set", tx, "version=%lld", version);
6006 }
6007 
6008 /*
6009  * Set zpool properties.
6010  */
6011 static void
6012 spa_sync_props(void *arg, dmu_tx_t *tx)
6013 {
6014 	nvlist_t *nvp = arg;
6015 	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
6016 	objset_t *mos = spa->spa_meta_objset;
6017 	nvpair_t *elem = NULL;
6018 
6019 	mutex_enter(&spa->spa_props_lock);
6020 
6021 	while ((elem = nvlist_next_nvpair(nvp, elem))) {
6022 		uint64_t intval;
6023 		char *strval, *fname;
6024 		zpool_prop_t prop;
6025 		const char *propname;
6026 		zprop_type_t proptype;
6027 		spa_feature_t fid;
6028 
6029 		switch (prop = zpool_name_to_prop(nvpair_name(elem))) {
6030 		case ZPROP_INVAL:
6031 			/*
6032 			 * We checked this earlier in spa_prop_validate().
6033 			 */
6034 			ASSERT(zpool_prop_feature(nvpair_name(elem)));
6035 
6036 			fname = strchr(nvpair_name(elem), '@') + 1;
6037 			VERIFY0(zfeature_lookup_name(fname, &fid));
6038 
6039 			spa_feature_enable(spa, fid, tx);
6040 			spa_history_log_internal(spa, "set", tx,
6041 			    "%s=enabled", nvpair_name(elem));
6042 			break;
6043 
6044 		case ZPOOL_PROP_VERSION:
6045 			intval = fnvpair_value_uint64(elem);
6046 			/*
6047 			 * The version is synced seperatly before other
6048 			 * properties and should be correct by now.
6049 			 */
6050 			ASSERT3U(spa_version(spa), >=, intval);
6051 			break;
6052 
6053 		case ZPOOL_PROP_ALTROOT:
6054 			/*
6055 			 * 'altroot' is a non-persistent property. It should
6056 			 * have been set temporarily at creation or import time.
6057 			 */
6058 			ASSERT(spa->spa_root != NULL);
6059 			break;
6060 
6061 		case ZPOOL_PROP_READONLY:
6062 		case ZPOOL_PROP_CACHEFILE:
6063 			/*
6064 			 * 'readonly' and 'cachefile' are also non-persisitent
6065 			 * properties.
6066 			 */
6067 			break;
6068 		case ZPOOL_PROP_COMMENT:
6069 			strval = fnvpair_value_string(elem);
6070 			if (spa->spa_comment != NULL)
6071 				spa_strfree(spa->spa_comment);
6072 			spa->spa_comment = spa_strdup(strval);
6073 			/*
6074 			 * We need to dirty the configuration on all the vdevs
6075 			 * so that their labels get updated.  It's unnecessary
6076 			 * to do this for pool creation since the vdev's
6077 			 * configuratoin has already been dirtied.
6078 			 */
6079 			if (tx->tx_txg != TXG_INITIAL)
6080 				vdev_config_dirty(spa->spa_root_vdev);
6081 			spa_history_log_internal(spa, "set", tx,
6082 			    "%s=%s", nvpair_name(elem), strval);
6083 			break;
6084 		default:
6085 			/*
6086 			 * Set pool property values in the poolprops mos object.
6087 			 */
6088 			if (spa->spa_pool_props_object == 0) {
6089 				spa->spa_pool_props_object =
6090 				    zap_create_link(mos, DMU_OT_POOL_PROPS,
6091 				    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_PROPS,
6092 				    tx);
6093 			}
6094 
6095 			/* normalize the property name */
6096 			propname = zpool_prop_to_name(prop);
6097 			proptype = zpool_prop_get_type(prop);
6098 
6099 			if (nvpair_type(elem) == DATA_TYPE_STRING) {
6100 				ASSERT(proptype == PROP_TYPE_STRING);
6101 				strval = fnvpair_value_string(elem);
6102 				VERIFY0(zap_update(mos,
6103 				    spa->spa_pool_props_object, propname,
6104 				    1, strlen(strval) + 1, strval, tx));
6105 				spa_history_log_internal(spa, "set", tx,
6106 				    "%s=%s", nvpair_name(elem), strval);
6107 			} else if (nvpair_type(elem) == DATA_TYPE_UINT64) {
6108 				intval = fnvpair_value_uint64(elem);
6109 
6110 				if (proptype == PROP_TYPE_INDEX) {
6111 					const char *unused;
6112 					VERIFY0(zpool_prop_index_to_string(
6113 					    prop, intval, &unused));
6114 				}
6115 				VERIFY0(zap_update(mos,
6116 				    spa->spa_pool_props_object, propname,
6117 				    8, 1, &intval, tx));
6118 				spa_history_log_internal(spa, "set", tx,
6119 				    "%s=%lld", nvpair_name(elem), intval);
6120 			} else {
6121 				ASSERT(0); /* not allowed */
6122 			}
6123 
6124 			switch (prop) {
6125 			case ZPOOL_PROP_DELEGATION:
6126 				spa->spa_delegation = intval;
6127 				break;
6128 			case ZPOOL_PROP_BOOTFS:
6129 				spa->spa_bootfs = intval;
6130 				break;
6131 			case ZPOOL_PROP_FAILUREMODE:
6132 				spa->spa_failmode = intval;
6133 				break;
6134 			case ZPOOL_PROP_AUTOEXPAND:
6135 				spa->spa_autoexpand = intval;
6136 				if (tx->tx_txg != TXG_INITIAL)
6137 					spa_async_request(spa,
6138 					    SPA_ASYNC_AUTOEXPAND);
6139 				break;
6140 			case ZPOOL_PROP_DEDUPDITTO:
6141 				spa->spa_dedup_ditto = intval;
6142 				break;
6143 			default:
6144 				break;
6145 			}
6146 		}
6147 
6148 	}
6149 
6150 	mutex_exit(&spa->spa_props_lock);
6151 }
6152 
6153 /*
6154  * Perform one-time upgrade on-disk changes.  spa_version() does not
6155  * reflect the new version this txg, so there must be no changes this
6156  * txg to anything that the upgrade code depends on after it executes.
6157  * Therefore this must be called after dsl_pool_sync() does the sync
6158  * tasks.
6159  */
6160 static void
6161 spa_sync_upgrades(spa_t *spa, dmu_tx_t *tx)
6162 {
6163 	dsl_pool_t *dp = spa->spa_dsl_pool;
6164 
6165 	ASSERT(spa->spa_sync_pass == 1);
6166 
6167 	rrw_enter(&dp->dp_config_rwlock, RW_WRITER, FTAG);
6168 
6169 	if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN &&
6170 	    spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) {
6171 		dsl_pool_create_origin(dp, tx);
6172 
6173 		/* Keeping the origin open increases spa_minref */
6174 		spa->spa_minref += 3;
6175 	}
6176 
6177 	if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES &&
6178 	    spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) {
6179 		dsl_pool_upgrade_clones(dp, tx);
6180 	}
6181 
6182 	if (spa->spa_ubsync.ub_version < SPA_VERSION_DIR_CLONES &&
6183 	    spa->spa_uberblock.ub_version >= SPA_VERSION_DIR_CLONES) {
6184 		dsl_pool_upgrade_dir_clones(dp, tx);
6185 
6186 		/* Keeping the freedir open increases spa_minref */
6187 		spa->spa_minref += 3;
6188 	}
6189 
6190 	if (spa->spa_ubsync.ub_version < SPA_VERSION_FEATURES &&
6191 	    spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) {
6192 		spa_feature_create_zap_objects(spa, tx);
6193 	}
6194 
6195 	/*
6196 	 * LZ4_COMPRESS feature's behaviour was changed to activate_on_enable
6197 	 * when possibility to use lz4 compression for metadata was added
6198 	 * Old pools that have this feature enabled must be upgraded to have
6199 	 * this feature active
6200 	 */
6201 	if (spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) {
6202 		boolean_t lz4_en = spa_feature_is_enabled(spa,
6203 		    SPA_FEATURE_LZ4_COMPRESS);
6204 		boolean_t lz4_ac = spa_feature_is_active(spa,
6205 		    SPA_FEATURE_LZ4_COMPRESS);
6206 
6207 		if (lz4_en && !lz4_ac)
6208 			spa_feature_incr(spa, SPA_FEATURE_LZ4_COMPRESS, tx);
6209 	}
6210 	rrw_exit(&dp->dp_config_rwlock, FTAG);
6211 }
6212 
6213 /*
6214  * Sync the specified transaction group.  New blocks may be dirtied as
6215  * part of the process, so we iterate until it converges.
6216  */
6217 void
6218 spa_sync(spa_t *spa, uint64_t txg)
6219 {
6220 	dsl_pool_t *dp = spa->spa_dsl_pool;
6221 	objset_t *mos = spa->spa_meta_objset;
6222 	bplist_t *free_bpl = &spa->spa_free_bplist[txg & TXG_MASK];
6223 	vdev_t *rvd = spa->spa_root_vdev;
6224 	vdev_t *vd;
6225 	dmu_tx_t *tx;
6226 	int error;
6227 
6228 	VERIFY(spa_writeable(spa));
6229 
6230 	/*
6231 	 * Lock out configuration changes.
6232 	 */
6233 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
6234 
6235 	spa->spa_syncing_txg = txg;
6236 	spa->spa_sync_pass = 0;
6237 
6238 	/*
6239 	 * If there are any pending vdev state changes, convert them
6240 	 * into config changes that go out with this transaction group.
6241 	 */
6242 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
6243 	while (list_head(&spa->spa_state_dirty_list) != NULL) {
6244 		/*
6245 		 * We need the write lock here because, for aux vdevs,
6246 		 * calling vdev_config_dirty() modifies sav_config.
6247 		 * This is ugly and will become unnecessary when we
6248 		 * eliminate the aux vdev wart by integrating all vdevs
6249 		 * into the root vdev tree.
6250 		 */
6251 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
6252 		spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_WRITER);
6253 		while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) {
6254 			vdev_state_clean(vd);
6255 			vdev_config_dirty(vd);
6256 		}
6257 		spa_config_exit(spa, SCL_CONFIG | SCL_STATE, FTAG);
6258 		spa_config_enter(spa, SCL_CONFIG | SCL_STATE, FTAG, RW_READER);
6259 	}
6260 	spa_config_exit(spa, SCL_STATE, FTAG);
6261 
6262 	tx = dmu_tx_create_assigned(dp, txg);
6263 
6264 	spa->spa_sync_starttime = gethrtime();
6265 	VERIFY(cyclic_reprogram(spa->spa_deadman_cycid,
6266 	    spa->spa_sync_starttime + spa->spa_deadman_synctime));
6267 
6268 	/*
6269 	 * If we are upgrading to SPA_VERSION_RAIDZ_DEFLATE this txg,
6270 	 * set spa_deflate if we have no raid-z vdevs.
6271 	 */
6272 	if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE &&
6273 	    spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) {
6274 		int i;
6275 
6276 		for (i = 0; i < rvd->vdev_children; i++) {
6277 			vd = rvd->vdev_child[i];
6278 			if (vd->vdev_deflate_ratio != SPA_MINBLOCKSIZE)
6279 				break;
6280 		}
6281 		if (i == rvd->vdev_children) {
6282 			spa->spa_deflate = TRUE;
6283 			VERIFY(0 == zap_add(spa->spa_meta_objset,
6284 			    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE,
6285 			    sizeof (uint64_t), 1, &spa->spa_deflate, tx));
6286 		}
6287 	}
6288 
6289 	/*
6290 	 * Iterate to convergence.
6291 	 */
6292 	do {
6293 		int pass = ++spa->spa_sync_pass;
6294 
6295 		spa_sync_config_object(spa, tx);
6296 		spa_sync_aux_dev(spa, &spa->spa_spares, tx,
6297 		    ZPOOL_CONFIG_SPARES, DMU_POOL_SPARES);
6298 		spa_sync_aux_dev(spa, &spa->spa_l2cache, tx,
6299 		    ZPOOL_CONFIG_L2CACHE, DMU_POOL_L2CACHE);
6300 		spa_errlog_sync(spa, txg);
6301 		dsl_pool_sync(dp, txg);
6302 
6303 		if (pass < zfs_sync_pass_deferred_free) {
6304 			spa_sync_frees(spa, free_bpl, tx);
6305 		} else {
6306 			/*
6307 			 * We can not defer frees in pass 1, because
6308 			 * we sync the deferred frees later in pass 1.
6309 			 */
6310 			ASSERT3U(pass, >, 1);
6311 			bplist_iterate(free_bpl, bpobj_enqueue_cb,
6312 			    &spa->spa_deferred_bpobj, tx);
6313 		}
6314 
6315 		ddt_sync(spa, txg);
6316 		dsl_scan_sync(dp, tx);
6317 
6318 		while (vd = txg_list_remove(&spa->spa_vdev_txg_list, txg))
6319 			vdev_sync(vd, txg);
6320 
6321 		if (pass == 1) {
6322 			spa_sync_upgrades(spa, tx);
6323 			ASSERT3U(txg, >=,
6324 			    spa->spa_uberblock.ub_rootbp.blk_birth);
6325 			/*
6326 			 * Note: We need to check if the MOS is dirty
6327 			 * because we could have marked the MOS dirty
6328 			 * without updating the uberblock (e.g. if we
6329 			 * have sync tasks but no dirty user data).  We
6330 			 * need to check the uberblock's rootbp because
6331 			 * it is updated if we have synced out dirty
6332 			 * data (though in this case the MOS will most
6333 			 * likely also be dirty due to second order
6334 			 * effects, we don't want to rely on that here).
6335 			 */
6336 			if (spa->spa_uberblock.ub_rootbp.blk_birth < txg &&
6337 			    !dmu_objset_is_dirty(mos, txg)) {
6338 				/*
6339 				 * Nothing changed on the first pass,
6340 				 * therefore this TXG is a no-op.  Avoid
6341 				 * syncing deferred frees, so that we
6342 				 * can keep this TXG as a no-op.
6343 				 */
6344 				ASSERT(txg_list_empty(&dp->dp_dirty_datasets,
6345 				    txg));
6346 				ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg));
6347 				ASSERT(txg_list_empty(&dp->dp_sync_tasks, txg));
6348 				break;
6349 			}
6350 			spa_sync_deferred_frees(spa, tx);
6351 		}
6352 
6353 	} while (dmu_objset_is_dirty(mos, txg));
6354 
6355 	/*
6356 	 * Rewrite the vdev configuration (which includes the uberblock)
6357 	 * to commit the transaction group.
6358 	 *
6359 	 * If there are no dirty vdevs, we sync the uberblock to a few
6360 	 * random top-level vdevs that are known to be visible in the
6361 	 * config cache (see spa_vdev_add() for a complete description).
6362 	 * If there *are* dirty vdevs, sync the uberblock to all vdevs.
6363 	 */
6364 	for (;;) {
6365 		/*
6366 		 * We hold SCL_STATE to prevent vdev open/close/etc.
6367 		 * while we're attempting to write the vdev labels.
6368 		 */
6369 		spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
6370 
6371 		if (list_is_empty(&spa->spa_config_dirty_list)) {
6372 			vdev_t *svd[SPA_DVAS_PER_BP];
6373 			int svdcount = 0;
6374 			int children = rvd->vdev_children;
6375 			int c0 = spa_get_random(children);
6376 
6377 			for (int c = 0; c < children; c++) {
6378 				vd = rvd->vdev_child[(c0 + c) % children];
6379 				if (vd->vdev_ms_array == 0 || vd->vdev_islog)
6380 					continue;
6381 				svd[svdcount++] = vd;
6382 				if (svdcount == SPA_DVAS_PER_BP)
6383 					break;
6384 			}
6385 			error = vdev_config_sync(svd, svdcount, txg, B_FALSE);
6386 			if (error != 0)
6387 				error = vdev_config_sync(svd, svdcount, txg,
6388 				    B_TRUE);
6389 		} else {
6390 			error = vdev_config_sync(rvd->vdev_child,
6391 			    rvd->vdev_children, txg, B_FALSE);
6392 			if (error != 0)
6393 				error = vdev_config_sync(rvd->vdev_child,
6394 				    rvd->vdev_children, txg, B_TRUE);
6395 		}
6396 
6397 		if (error == 0)
6398 			spa->spa_last_synced_guid = rvd->vdev_guid;
6399 
6400 		spa_config_exit(spa, SCL_STATE, FTAG);
6401 
6402 		if (error == 0)
6403 			break;
6404 		zio_suspend(spa, NULL);
6405 		zio_resume_wait(spa);
6406 	}
6407 	dmu_tx_commit(tx);
6408 
6409 	VERIFY(cyclic_reprogram(spa->spa_deadman_cycid, CY_INFINITY));
6410 
6411 	/*
6412 	 * Clear the dirty config list.
6413 	 */
6414 	while ((vd = list_head(&spa->spa_config_dirty_list)) != NULL)
6415 		vdev_config_clean(vd);
6416 
6417 	/*
6418 	 * Now that the new config has synced transactionally,
6419 	 * let it become visible to the config cache.
6420 	 */
6421 	if (spa->spa_config_syncing != NULL) {
6422 		spa_config_set(spa, spa->spa_config_syncing);
6423 		spa->spa_config_txg = txg;
6424 		spa->spa_config_syncing = NULL;
6425 	}
6426 
6427 	spa->spa_ubsync = spa->spa_uberblock;
6428 
6429 	dsl_pool_sync_done(dp, txg);
6430 
6431 	/*
6432 	 * Update usable space statistics.
6433 	 */
6434 	while (vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)))
6435 		vdev_sync_done(vd, txg);
6436 
6437 	spa_update_dspace(spa);
6438 
6439 	/*
6440 	 * It had better be the case that we didn't dirty anything
6441 	 * since vdev_config_sync().
6442 	 */
6443 	ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg));
6444 	ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg));
6445 	ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg));
6446 
6447 	spa->spa_sync_pass = 0;
6448 
6449 	spa_config_exit(spa, SCL_CONFIG, FTAG);
6450 
6451 	spa_handle_ignored_writes(spa);
6452 
6453 	/*
6454 	 * If any async tasks have been requested, kick them off.
6455 	 */
6456 	spa_async_dispatch(spa);
6457 }
6458 
6459 /*
6460  * Sync all pools.  We don't want to hold the namespace lock across these
6461  * operations, so we take a reference on the spa_t and drop the lock during the
6462  * sync.
6463  */
6464 void
6465 spa_sync_allpools(void)
6466 {
6467 	spa_t *spa = NULL;
6468 	mutex_enter(&spa_namespace_lock);
6469 	while ((spa = spa_next(spa)) != NULL) {
6470 		if (spa_state(spa) != POOL_STATE_ACTIVE ||
6471 		    !spa_writeable(spa) || spa_suspended(spa))
6472 			continue;
6473 		spa_open_ref(spa, FTAG);
6474 		mutex_exit(&spa_namespace_lock);
6475 		txg_wait_synced(spa_get_dsl(spa), 0);
6476 		mutex_enter(&spa_namespace_lock);
6477 		spa_close(spa, FTAG);
6478 	}
6479 	mutex_exit(&spa_namespace_lock);
6480 }
6481 
6482 /*
6483  * ==========================================================================
6484  * Miscellaneous routines
6485  * ==========================================================================
6486  */
6487 
6488 /*
6489  * Remove all pools in the system.
6490  */
6491 void
6492 spa_evict_all(void)
6493 {
6494 	spa_t *spa;
6495 
6496 	/*
6497 	 * Remove all cached state.  All pools should be closed now,
6498 	 * so every spa in the AVL tree should be unreferenced.
6499 	 */
6500 	mutex_enter(&spa_namespace_lock);
6501 	while ((spa = spa_next(NULL)) != NULL) {
6502 		/*
6503 		 * Stop async tasks.  The async thread may need to detach
6504 		 * a device that's been replaced, which requires grabbing
6505 		 * spa_namespace_lock, so we must drop it here.
6506 		 */
6507 		spa_open_ref(spa, FTAG);
6508 		mutex_exit(&spa_namespace_lock);
6509 		spa_async_suspend(spa);
6510 		mutex_enter(&spa_namespace_lock);
6511 		spa_close(spa, FTAG);
6512 
6513 		if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
6514 			spa_unload(spa);
6515 			spa_deactivate(spa);
6516 		}
6517 		spa_remove(spa);
6518 	}
6519 	mutex_exit(&spa_namespace_lock);
6520 }
6521 
6522 vdev_t *
6523 spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t aux)
6524 {
6525 	vdev_t *vd;
6526 	int i;
6527 
6528 	if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL)
6529 		return (vd);
6530 
6531 	if (aux) {
6532 		for (i = 0; i < spa->spa_l2cache.sav_count; i++) {
6533 			vd = spa->spa_l2cache.sav_vdevs[i];
6534 			if (vd->vdev_guid == guid)
6535 				return (vd);
6536 		}
6537 
6538 		for (i = 0; i < spa->spa_spares.sav_count; i++) {
6539 			vd = spa->spa_spares.sav_vdevs[i];
6540 			if (vd->vdev_guid == guid)
6541 				return (vd);
6542 		}
6543 	}
6544 
6545 	return (NULL);
6546 }
6547 
6548 void
6549 spa_upgrade(spa_t *spa, uint64_t version)
6550 {
6551 	ASSERT(spa_writeable(spa));
6552 
6553 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
6554 
6555 	/*
6556 	 * This should only be called for a non-faulted pool, and since a
6557 	 * future version would result in an unopenable pool, this shouldn't be
6558 	 * possible.
6559 	 */
6560 	ASSERT(SPA_VERSION_IS_SUPPORTED(spa->spa_uberblock.ub_version));
6561 	ASSERT3U(version, >=, spa->spa_uberblock.ub_version);
6562 
6563 	spa->spa_uberblock.ub_version = version;
6564 	vdev_config_dirty(spa->spa_root_vdev);
6565 
6566 	spa_config_exit(spa, SCL_ALL, FTAG);
6567 
6568 	txg_wait_synced(spa_get_dsl(spa), 0);
6569 }
6570 
6571 boolean_t
6572 spa_has_spare(spa_t *spa, uint64_t guid)
6573 {
6574 	int i;
6575 	uint64_t spareguid;
6576 	spa_aux_vdev_t *sav = &spa->spa_spares;
6577 
6578 	for (i = 0; i < sav->sav_count; i++)
6579 		if (sav->sav_vdevs[i]->vdev_guid == guid)
6580 			return (B_TRUE);
6581 
6582 	for (i = 0; i < sav->sav_npending; i++) {
6583 		if (nvlist_lookup_uint64(sav->sav_pending[i], ZPOOL_CONFIG_GUID,
6584 		    &spareguid) == 0 && spareguid == guid)
6585 			return (B_TRUE);
6586 	}
6587 
6588 	return (B_FALSE);
6589 }
6590 
6591 /*
6592  * Check if a pool has an active shared spare device.
6593  * Note: reference count of an active spare is 2, as a spare and as a replace
6594  */
6595 static boolean_t
6596 spa_has_active_shared_spare(spa_t *spa)
6597 {
6598 	int i, refcnt;
6599 	uint64_t pool;
6600 	spa_aux_vdev_t *sav = &spa->spa_spares;
6601 
6602 	for (i = 0; i < sav->sav_count; i++) {
6603 		if (spa_spare_exists(sav->sav_vdevs[i]->vdev_guid, &pool,
6604 		    &refcnt) && pool != 0ULL && pool == spa_guid(spa) &&
6605 		    refcnt > 2)
6606 			return (B_TRUE);
6607 	}
6608 
6609 	return (B_FALSE);
6610 }
6611 
6612 /*
6613  * Post a sysevent corresponding to the given event.  The 'name' must be one of
6614  * the event definitions in sys/sysevent/eventdefs.h.  The payload will be
6615  * filled in from the spa and (optionally) the vdev.  This doesn't do anything
6616  * in the userland libzpool, as we don't want consumers to misinterpret ztest
6617  * or zdb as real changes.
6618  */
6619 void
6620 spa_event_notify(spa_t *spa, vdev_t *vd, const char *name)
6621 {
6622 #ifdef _KERNEL
6623 	sysevent_t		*ev;
6624 	sysevent_attr_list_t	*attr = NULL;
6625 	sysevent_value_t	value;
6626 	sysevent_id_t		eid;
6627 
6628 	ev = sysevent_alloc(EC_ZFS, (char *)name, SUNW_KERN_PUB "zfs",
6629 	    SE_SLEEP);
6630 
6631 	value.value_type = SE_DATA_TYPE_STRING;
6632 	value.value.sv_string = spa_name(spa);
6633 	if (sysevent_add_attr(&attr, ZFS_EV_POOL_NAME, &value, SE_SLEEP) != 0)
6634 		goto done;
6635 
6636 	value.value_type = SE_DATA_TYPE_UINT64;
6637 	value.value.sv_uint64 = spa_guid(spa);
6638 	if (sysevent_add_attr(&attr, ZFS_EV_POOL_GUID, &value, SE_SLEEP) != 0)
6639 		goto done;
6640 
6641 	if (vd) {
6642 		value.value_type = SE_DATA_TYPE_UINT64;
6643 		value.value.sv_uint64 = vd->vdev_guid;
6644 		if (sysevent_add_attr(&attr, ZFS_EV_VDEV_GUID, &value,
6645 		    SE_SLEEP) != 0)
6646 			goto done;
6647 
6648 		if (vd->vdev_path) {
6649 			value.value_type = SE_DATA_TYPE_STRING;
6650 			value.value.sv_string = vd->vdev_path;
6651 			if (sysevent_add_attr(&attr, ZFS_EV_VDEV_PATH,
6652 			    &value, SE_SLEEP) != 0)
6653 				goto done;
6654 		}
6655 	}
6656 
6657 	if (sysevent_attach_attributes(ev, attr) != 0)
6658 		goto done;
6659 	attr = NULL;
6660 
6661 	(void) log_sysevent(ev, SE_SLEEP, &eid);
6662 
6663 done:
6664 	if (attr)
6665 		sysevent_free_attr(attr);
6666 	sysevent_free(ev);
6667 #endif
6668 }
6669