xref: /illumos-gate/usr/src/uts/common/fs/zfs/spa.c (revision 088f389458728c464569a5506b58070254fa4f7d)
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 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*
30  * This file contains all the routines used when modifying on-disk SPA state.
31  * This includes opening, importing, destroying, exporting a pool, and syncing a
32  * pool.
33  */
34 
35 #include <sys/zfs_context.h>
36 #include <sys/fm/fs/zfs.h>
37 #include <sys/spa_impl.h>
38 #include <sys/zio.h>
39 #include <sys/zio_checksum.h>
40 #include <sys/zio_compress.h>
41 #include <sys/dmu.h>
42 #include <sys/dmu_tx.h>
43 #include <sys/zap.h>
44 #include <sys/zil.h>
45 #include <sys/vdev_impl.h>
46 #include <sys/metaslab.h>
47 #include <sys/uberblock_impl.h>
48 #include <sys/txg.h>
49 #include <sys/avl.h>
50 #include <sys/dmu_traverse.h>
51 #include <sys/dmu_objset.h>
52 #include <sys/unique.h>
53 #include <sys/dsl_pool.h>
54 #include <sys/dsl_dataset.h>
55 #include <sys/dsl_dir.h>
56 #include <sys/dsl_prop.h>
57 #include <sys/dsl_synctask.h>
58 #include <sys/fs/zfs.h>
59 #include <sys/arc.h>
60 #include <sys/callb.h>
61 #include <sys/systeminfo.h>
62 #include <sys/sunddi.h>
63 #include <sys/spa_boot.h>
64 
65 #include "zfs_prop.h"
66 #include "zfs_comutil.h"
67 
68 int zio_taskq_threads = 8;
69 
70 static void spa_sync_props(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx);
71 
72 /*
73  * ==========================================================================
74  * SPA properties routines
75  * ==========================================================================
76  */
77 
78 /*
79  * Add a (source=src, propname=propval) list to an nvlist.
80  */
81 static void
82 spa_prop_add_list(nvlist_t *nvl, zpool_prop_t prop, char *strval,
83     uint64_t intval, zprop_source_t src)
84 {
85 	const char *propname = zpool_prop_to_name(prop);
86 	nvlist_t *propval;
87 
88 	VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0);
89 	VERIFY(nvlist_add_uint64(propval, ZPROP_SOURCE, src) == 0);
90 
91 	if (strval != NULL)
92 		VERIFY(nvlist_add_string(propval, ZPROP_VALUE, strval) == 0);
93 	else
94 		VERIFY(nvlist_add_uint64(propval, ZPROP_VALUE, intval) == 0);
95 
96 	VERIFY(nvlist_add_nvlist(nvl, propname, propval) == 0);
97 	nvlist_free(propval);
98 }
99 
100 /*
101  * Get property values from the spa configuration.
102  */
103 static void
104 spa_prop_get_config(spa_t *spa, nvlist_t **nvp)
105 {
106 	uint64_t size = spa_get_space(spa);
107 	uint64_t used = spa_get_alloc(spa);
108 	uint64_t cap, version;
109 	zprop_source_t src = ZPROP_SRC_NONE;
110 	spa_config_dirent_t *dp;
111 
112 	/*
113 	 * readonly properties
114 	 */
115 	spa_prop_add_list(*nvp, ZPOOL_PROP_NAME, spa->spa_name, 0, src);
116 	spa_prop_add_list(*nvp, ZPOOL_PROP_SIZE, NULL, size, src);
117 	spa_prop_add_list(*nvp, ZPOOL_PROP_USED, NULL, used, src);
118 	spa_prop_add_list(*nvp, ZPOOL_PROP_AVAILABLE, NULL, size - used, src);
119 
120 	cap = (size == 0) ? 0 : (used * 100 / size);
121 	spa_prop_add_list(*nvp, ZPOOL_PROP_CAPACITY, NULL, cap, src);
122 
123 	spa_prop_add_list(*nvp, ZPOOL_PROP_GUID, NULL, spa_guid(spa), src);
124 	spa_prop_add_list(*nvp, ZPOOL_PROP_HEALTH, NULL,
125 	    spa->spa_root_vdev->vdev_state, src);
126 
127 	/*
128 	 * settable properties that are not stored in the pool property object.
129 	 */
130 	version = spa_version(spa);
131 	if (version == zpool_prop_default_numeric(ZPOOL_PROP_VERSION))
132 		src = ZPROP_SRC_DEFAULT;
133 	else
134 		src = ZPROP_SRC_LOCAL;
135 	spa_prop_add_list(*nvp, ZPOOL_PROP_VERSION, NULL, version, src);
136 
137 	if (spa->spa_root != NULL)
138 		spa_prop_add_list(*nvp, ZPOOL_PROP_ALTROOT, spa->spa_root,
139 		    0, ZPROP_SRC_LOCAL);
140 
141 	if ((dp = list_head(&spa->spa_config_list)) != NULL) {
142 		if (dp->scd_path == NULL) {
143 			spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE,
144 			    "none", 0, ZPROP_SRC_LOCAL);
145 		} else if (strcmp(dp->scd_path, spa_config_path) != 0) {
146 			spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE,
147 			    dp->scd_path, 0, ZPROP_SRC_LOCAL);
148 		}
149 	}
150 }
151 
152 /*
153  * Get zpool property values.
154  */
155 int
156 spa_prop_get(spa_t *spa, nvlist_t **nvp)
157 {
158 	zap_cursor_t zc;
159 	zap_attribute_t za;
160 	objset_t *mos = spa->spa_meta_objset;
161 	int err;
162 
163 	VERIFY(nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0);
164 
165 	/*
166 	 * Get properties from the spa config.
167 	 */
168 	spa_prop_get_config(spa, nvp);
169 
170 	mutex_enter(&spa->spa_props_lock);
171 	/* If no pool property object, no more prop to get. */
172 	if (spa->spa_pool_props_object == 0) {
173 		mutex_exit(&spa->spa_props_lock);
174 		return (0);
175 	}
176 
177 	/*
178 	 * Get properties from the MOS pool property object.
179 	 */
180 	for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object);
181 	    (err = zap_cursor_retrieve(&zc, &za)) == 0;
182 	    zap_cursor_advance(&zc)) {
183 		uint64_t intval = 0;
184 		char *strval = NULL;
185 		zprop_source_t src = ZPROP_SRC_DEFAULT;
186 		zpool_prop_t prop;
187 
188 		if ((prop = zpool_name_to_prop(za.za_name)) == ZPROP_INVAL)
189 			continue;
190 
191 		switch (za.za_integer_length) {
192 		case 8:
193 			/* integer property */
194 			if (za.za_first_integer !=
195 			    zpool_prop_default_numeric(prop))
196 				src = ZPROP_SRC_LOCAL;
197 
198 			if (prop == ZPOOL_PROP_BOOTFS) {
199 				dsl_pool_t *dp;
200 				dsl_dataset_t *ds = NULL;
201 
202 				dp = spa_get_dsl(spa);
203 				rw_enter(&dp->dp_config_rwlock, RW_READER);
204 				if (err = dsl_dataset_hold_obj(dp,
205 				    za.za_first_integer, FTAG, &ds)) {
206 					rw_exit(&dp->dp_config_rwlock);
207 					break;
208 				}
209 
210 				strval = kmem_alloc(
211 				    MAXNAMELEN + strlen(MOS_DIR_NAME) + 1,
212 				    KM_SLEEP);
213 				dsl_dataset_name(ds, strval);
214 				dsl_dataset_rele(ds, FTAG);
215 				rw_exit(&dp->dp_config_rwlock);
216 			} else {
217 				strval = NULL;
218 				intval = za.za_first_integer;
219 			}
220 
221 			spa_prop_add_list(*nvp, prop, strval, intval, src);
222 
223 			if (strval != NULL)
224 				kmem_free(strval,
225 				    MAXNAMELEN + strlen(MOS_DIR_NAME) + 1);
226 
227 			break;
228 
229 		case 1:
230 			/* string property */
231 			strval = kmem_alloc(za.za_num_integers, KM_SLEEP);
232 			err = zap_lookup(mos, spa->spa_pool_props_object,
233 			    za.za_name, 1, za.za_num_integers, strval);
234 			if (err) {
235 				kmem_free(strval, za.za_num_integers);
236 				break;
237 			}
238 			spa_prop_add_list(*nvp, prop, strval, 0, src);
239 			kmem_free(strval, za.za_num_integers);
240 			break;
241 
242 		default:
243 			break;
244 		}
245 	}
246 	zap_cursor_fini(&zc);
247 	mutex_exit(&spa->spa_props_lock);
248 out:
249 	if (err && err != ENOENT) {
250 		nvlist_free(*nvp);
251 		*nvp = NULL;
252 		return (err);
253 	}
254 
255 	return (0);
256 }
257 
258 /*
259  * Validate the given pool properties nvlist and modify the list
260  * for the property values to be set.
261  */
262 static int
263 spa_prop_validate(spa_t *spa, nvlist_t *props)
264 {
265 	nvpair_t *elem;
266 	int error = 0, reset_bootfs = 0;
267 	uint64_t objnum;
268 
269 	elem = NULL;
270 	while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
271 		zpool_prop_t prop;
272 		char *propname, *strval;
273 		uint64_t intval;
274 		objset_t *os;
275 		char *slash;
276 
277 		propname = nvpair_name(elem);
278 
279 		if ((prop = zpool_name_to_prop(propname)) == ZPROP_INVAL)
280 			return (EINVAL);
281 
282 		switch (prop) {
283 		case ZPOOL_PROP_VERSION:
284 			error = nvpair_value_uint64(elem, &intval);
285 			if (!error &&
286 			    (intval < spa_version(spa) || intval > SPA_VERSION))
287 				error = EINVAL;
288 			break;
289 
290 		case ZPOOL_PROP_DELEGATION:
291 		case ZPOOL_PROP_AUTOREPLACE:
292 			error = nvpair_value_uint64(elem, &intval);
293 			if (!error && intval > 1)
294 				error = EINVAL;
295 			break;
296 
297 		case ZPOOL_PROP_BOOTFS:
298 			if (spa_version(spa) < SPA_VERSION_BOOTFS) {
299 				error = ENOTSUP;
300 				break;
301 			}
302 
303 			/*
304 			 * Make sure the vdev config is bootable
305 			 */
306 			if (!vdev_is_bootable(spa->spa_root_vdev)) {
307 				error = ENOTSUP;
308 				break;
309 			}
310 
311 			reset_bootfs = 1;
312 
313 			error = nvpair_value_string(elem, &strval);
314 
315 			if (!error) {
316 				uint64_t compress;
317 
318 				if (strval == NULL || strval[0] == '\0') {
319 					objnum = zpool_prop_default_numeric(
320 					    ZPOOL_PROP_BOOTFS);
321 					break;
322 				}
323 
324 				if (error = dmu_objset_open(strval, DMU_OST_ZFS,
325 				    DS_MODE_USER | DS_MODE_READONLY, &os))
326 					break;
327 
328 				/* We don't support gzip bootable datasets */
329 				if ((error = dsl_prop_get_integer(strval,
330 				    zfs_prop_to_name(ZFS_PROP_COMPRESSION),
331 				    &compress, NULL)) == 0 &&
332 				    !BOOTFS_COMPRESS_VALID(compress)) {
333 					error = ENOTSUP;
334 				} else {
335 					objnum = dmu_objset_id(os);
336 				}
337 				dmu_objset_close(os);
338 			}
339 			break;
340 		case ZPOOL_PROP_FAILUREMODE:
341 			error = nvpair_value_uint64(elem, &intval);
342 			if (!error && (intval < ZIO_FAILURE_MODE_WAIT ||
343 			    intval > ZIO_FAILURE_MODE_PANIC))
344 				error = EINVAL;
345 
346 			/*
347 			 * This is a special case which only occurs when
348 			 * the pool has completely failed. This allows
349 			 * the user to change the in-core failmode property
350 			 * without syncing it out to disk (I/Os might
351 			 * currently be blocked). We do this by returning
352 			 * EIO to the caller (spa_prop_set) to trick it
353 			 * into thinking we encountered a property validation
354 			 * error.
355 			 */
356 			if (!error && spa_state(spa) == POOL_STATE_IO_FAILURE) {
357 				spa->spa_failmode = intval;
358 				error = EIO;
359 			}
360 			break;
361 
362 		case ZPOOL_PROP_CACHEFILE:
363 			if ((error = nvpair_value_string(elem, &strval)) != 0)
364 				break;
365 
366 			if (strval[0] == '\0')
367 				break;
368 
369 			if (strcmp(strval, "none") == 0)
370 				break;
371 
372 			if (strval[0] != '/') {
373 				error = EINVAL;
374 				break;
375 			}
376 
377 			slash = strrchr(strval, '/');
378 			ASSERT(slash != NULL);
379 
380 			if (slash[1] == '\0' || strcmp(slash, "/.") == 0 ||
381 			    strcmp(slash, "/..") == 0)
382 				error = EINVAL;
383 			break;
384 		}
385 
386 		if (error)
387 			break;
388 	}
389 
390 	if (!error && reset_bootfs) {
391 		error = nvlist_remove(props,
392 		    zpool_prop_to_name(ZPOOL_PROP_BOOTFS), DATA_TYPE_STRING);
393 
394 		if (!error) {
395 			error = nvlist_add_uint64(props,
396 			    zpool_prop_to_name(ZPOOL_PROP_BOOTFS), objnum);
397 		}
398 	}
399 
400 	return (error);
401 }
402 
403 int
404 spa_prop_set(spa_t *spa, nvlist_t *nvp)
405 {
406 	int error;
407 
408 	if ((error = spa_prop_validate(spa, nvp)) != 0)
409 		return (error);
410 
411 	return (dsl_sync_task_do(spa_get_dsl(spa), NULL, spa_sync_props,
412 	    spa, nvp, 3));
413 }
414 
415 /*
416  * If the bootfs property value is dsobj, clear it.
417  */
418 void
419 spa_prop_clear_bootfs(spa_t *spa, uint64_t dsobj, dmu_tx_t *tx)
420 {
421 	if (spa->spa_bootfs == dsobj && spa->spa_pool_props_object != 0) {
422 		VERIFY(zap_remove(spa->spa_meta_objset,
423 		    spa->spa_pool_props_object,
424 		    zpool_prop_to_name(ZPOOL_PROP_BOOTFS), tx) == 0);
425 		spa->spa_bootfs = 0;
426 	}
427 }
428 
429 /*
430  * ==========================================================================
431  * SPA state manipulation (open/create/destroy/import/export)
432  * ==========================================================================
433  */
434 
435 static int
436 spa_error_entry_compare(const void *a, const void *b)
437 {
438 	spa_error_entry_t *sa = (spa_error_entry_t *)a;
439 	spa_error_entry_t *sb = (spa_error_entry_t *)b;
440 	int ret;
441 
442 	ret = bcmp(&sa->se_bookmark, &sb->se_bookmark,
443 	    sizeof (zbookmark_t));
444 
445 	if (ret < 0)
446 		return (-1);
447 	else if (ret > 0)
448 		return (1);
449 	else
450 		return (0);
451 }
452 
453 /*
454  * Utility function which retrieves copies of the current logs and
455  * re-initializes them in the process.
456  */
457 void
458 spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub)
459 {
460 	ASSERT(MUTEX_HELD(&spa->spa_errlist_lock));
461 
462 	bcopy(&spa->spa_errlist_last, last, sizeof (avl_tree_t));
463 	bcopy(&spa->spa_errlist_scrub, scrub, sizeof (avl_tree_t));
464 
465 	avl_create(&spa->spa_errlist_scrub,
466 	    spa_error_entry_compare, sizeof (spa_error_entry_t),
467 	    offsetof(spa_error_entry_t, se_avl));
468 	avl_create(&spa->spa_errlist_last,
469 	    spa_error_entry_compare, sizeof (spa_error_entry_t),
470 	    offsetof(spa_error_entry_t, se_avl));
471 }
472 
473 /*
474  * Activate an uninitialized pool.
475  */
476 static void
477 spa_activate(spa_t *spa)
478 {
479 	int t;
480 
481 	ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED);
482 
483 	spa->spa_state = POOL_STATE_ACTIVE;
484 
485 	spa->spa_normal_class = metaslab_class_create();
486 	spa->spa_log_class = metaslab_class_create();
487 
488 	for (t = 0; t < ZIO_TYPES; t++) {
489 		spa->spa_zio_issue_taskq[t] = taskq_create("spa_zio_issue",
490 		    zio_taskq_threads, maxclsyspri, 50, INT_MAX,
491 		    TASKQ_PREPOPULATE);
492 		spa->spa_zio_intr_taskq[t] = taskq_create("spa_zio_intr",
493 		    zio_taskq_threads, maxclsyspri, 50, INT_MAX,
494 		    TASKQ_PREPOPULATE);
495 	}
496 
497 	list_create(&spa->spa_dirty_list, sizeof (vdev_t),
498 	    offsetof(vdev_t, vdev_dirty_node));
499 	list_create(&spa->spa_zio_list, sizeof (zio_t),
500 	    offsetof(zio_t, zio_link_node));
501 
502 	txg_list_create(&spa->spa_vdev_txg_list,
503 	    offsetof(struct vdev, vdev_txg_node));
504 
505 	avl_create(&spa->spa_errlist_scrub,
506 	    spa_error_entry_compare, sizeof (spa_error_entry_t),
507 	    offsetof(spa_error_entry_t, se_avl));
508 	avl_create(&spa->spa_errlist_last,
509 	    spa_error_entry_compare, sizeof (spa_error_entry_t),
510 	    offsetof(spa_error_entry_t, se_avl));
511 }
512 
513 /*
514  * Opposite of spa_activate().
515  */
516 static void
517 spa_deactivate(spa_t *spa)
518 {
519 	int t;
520 
521 	ASSERT(spa->spa_sync_on == B_FALSE);
522 	ASSERT(spa->spa_dsl_pool == NULL);
523 	ASSERT(spa->spa_root_vdev == NULL);
524 
525 	ASSERT(spa->spa_state != POOL_STATE_UNINITIALIZED);
526 
527 	txg_list_destroy(&spa->spa_vdev_txg_list);
528 
529 	list_destroy(&spa->spa_dirty_list);
530 	list_destroy(&spa->spa_zio_list);
531 
532 	for (t = 0; t < ZIO_TYPES; t++) {
533 		taskq_destroy(spa->spa_zio_issue_taskq[t]);
534 		taskq_destroy(spa->spa_zio_intr_taskq[t]);
535 		spa->spa_zio_issue_taskq[t] = NULL;
536 		spa->spa_zio_intr_taskq[t] = NULL;
537 	}
538 
539 	metaslab_class_destroy(spa->spa_normal_class);
540 	spa->spa_normal_class = NULL;
541 
542 	metaslab_class_destroy(spa->spa_log_class);
543 	spa->spa_log_class = NULL;
544 
545 	/*
546 	 * If this was part of an import or the open otherwise failed, we may
547 	 * still have errors left in the queues.  Empty them just in case.
548 	 */
549 	spa_errlog_drain(spa);
550 
551 	avl_destroy(&spa->spa_errlist_scrub);
552 	avl_destroy(&spa->spa_errlist_last);
553 
554 	spa->spa_state = POOL_STATE_UNINITIALIZED;
555 }
556 
557 /*
558  * Verify a pool configuration, and construct the vdev tree appropriately.  This
559  * will create all the necessary vdevs in the appropriate layout, with each vdev
560  * in the CLOSED state.  This will prep the pool before open/creation/import.
561  * All vdev validation is done by the vdev_alloc() routine.
562  */
563 static int
564 spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent,
565     uint_t id, int atype)
566 {
567 	nvlist_t **child;
568 	uint_t c, children;
569 	int error;
570 
571 	if ((error = vdev_alloc(spa, vdp, nv, parent, id, atype)) != 0)
572 		return (error);
573 
574 	if ((*vdp)->vdev_ops->vdev_op_leaf)
575 		return (0);
576 
577 	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
578 	    &child, &children) != 0) {
579 		vdev_free(*vdp);
580 		*vdp = NULL;
581 		return (EINVAL);
582 	}
583 
584 	for (c = 0; c < children; c++) {
585 		vdev_t *vd;
586 		if ((error = spa_config_parse(spa, &vd, child[c], *vdp, c,
587 		    atype)) != 0) {
588 			vdev_free(*vdp);
589 			*vdp = NULL;
590 			return (error);
591 		}
592 	}
593 
594 	ASSERT(*vdp != NULL);
595 
596 	return (0);
597 }
598 
599 /*
600  * Opposite of spa_load().
601  */
602 static void
603 spa_unload(spa_t *spa)
604 {
605 	int i;
606 
607 	/*
608 	 * Stop async tasks.
609 	 */
610 	spa_async_suspend(spa);
611 
612 	/*
613 	 * Stop syncing.
614 	 */
615 	if (spa->spa_sync_on) {
616 		txg_sync_stop(spa->spa_dsl_pool);
617 		spa->spa_sync_on = B_FALSE;
618 	}
619 
620 	/*
621 	 * Wait for any outstanding prefetch I/O to complete.
622 	 */
623 	spa_config_enter(spa, RW_WRITER, FTAG);
624 	spa_config_exit(spa, FTAG);
625 
626 	/*
627 	 * Drop and purge level 2 cache
628 	 */
629 	spa_l2cache_drop(spa);
630 
631 	/*
632 	 * Close the dsl pool.
633 	 */
634 	if (spa->spa_dsl_pool) {
635 		dsl_pool_close(spa->spa_dsl_pool);
636 		spa->spa_dsl_pool = NULL;
637 	}
638 
639 	/*
640 	 * Close all vdevs.
641 	 */
642 	if (spa->spa_root_vdev)
643 		vdev_free(spa->spa_root_vdev);
644 	ASSERT(spa->spa_root_vdev == NULL);
645 
646 	for (i = 0; i < spa->spa_spares.sav_count; i++)
647 		vdev_free(spa->spa_spares.sav_vdevs[i]);
648 	if (spa->spa_spares.sav_vdevs) {
649 		kmem_free(spa->spa_spares.sav_vdevs,
650 		    spa->spa_spares.sav_count * sizeof (void *));
651 		spa->spa_spares.sav_vdevs = NULL;
652 	}
653 	if (spa->spa_spares.sav_config) {
654 		nvlist_free(spa->spa_spares.sav_config);
655 		spa->spa_spares.sav_config = NULL;
656 	}
657 
658 	for (i = 0; i < spa->spa_l2cache.sav_count; i++)
659 		vdev_free(spa->spa_l2cache.sav_vdevs[i]);
660 	if (spa->spa_l2cache.sav_vdevs) {
661 		kmem_free(spa->spa_l2cache.sav_vdevs,
662 		    spa->spa_l2cache.sav_count * sizeof (void *));
663 		spa->spa_l2cache.sav_vdevs = NULL;
664 	}
665 	if (spa->spa_l2cache.sav_config) {
666 		nvlist_free(spa->spa_l2cache.sav_config);
667 		spa->spa_l2cache.sav_config = NULL;
668 	}
669 
670 	spa->spa_async_suspended = 0;
671 }
672 
673 /*
674  * Load (or re-load) the current list of vdevs describing the active spares for
675  * this pool.  When this is called, we have some form of basic information in
676  * 'spa_spares.sav_config'.  We parse this into vdevs, try to open them, and
677  * then re-generate a more complete list including status information.
678  */
679 static void
680 spa_load_spares(spa_t *spa)
681 {
682 	nvlist_t **spares;
683 	uint_t nspares;
684 	int i;
685 	vdev_t *vd, *tvd;
686 
687 	/*
688 	 * First, close and free any existing spare vdevs.
689 	 */
690 	for (i = 0; i < spa->spa_spares.sav_count; i++) {
691 		vd = spa->spa_spares.sav_vdevs[i];
692 
693 		/* Undo the call to spa_activate() below */
694 		if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid,
695 		    B_FALSE)) != NULL && tvd->vdev_isspare)
696 			spa_spare_remove(tvd);
697 		vdev_close(vd);
698 		vdev_free(vd);
699 	}
700 
701 	if (spa->spa_spares.sav_vdevs)
702 		kmem_free(spa->spa_spares.sav_vdevs,
703 		    spa->spa_spares.sav_count * sizeof (void *));
704 
705 	if (spa->spa_spares.sav_config == NULL)
706 		nspares = 0;
707 	else
708 		VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
709 		    ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);
710 
711 	spa->spa_spares.sav_count = (int)nspares;
712 	spa->spa_spares.sav_vdevs = NULL;
713 
714 	if (nspares == 0)
715 		return;
716 
717 	/*
718 	 * Construct the array of vdevs, opening them to get status in the
719 	 * process.   For each spare, there is potentially two different vdev_t
720 	 * structures associated with it: one in the list of spares (used only
721 	 * for basic validation purposes) and one in the active vdev
722 	 * configuration (if it's spared in).  During this phase we open and
723 	 * validate each vdev on the spare list.  If the vdev also exists in the
724 	 * active configuration, then we also mark this vdev as an active spare.
725 	 */
726 	spa->spa_spares.sav_vdevs = kmem_alloc(nspares * sizeof (void *),
727 	    KM_SLEEP);
728 	for (i = 0; i < spa->spa_spares.sav_count; i++) {
729 		VERIFY(spa_config_parse(spa, &vd, spares[i], NULL, 0,
730 		    VDEV_ALLOC_SPARE) == 0);
731 		ASSERT(vd != NULL);
732 
733 		spa->spa_spares.sav_vdevs[i] = vd;
734 
735 		if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid,
736 		    B_FALSE)) != NULL) {
737 			if (!tvd->vdev_isspare)
738 				spa_spare_add(tvd);
739 
740 			/*
741 			 * We only mark the spare active if we were successfully
742 			 * able to load the vdev.  Otherwise, importing a pool
743 			 * with a bad active spare would result in strange
744 			 * behavior, because multiple pool would think the spare
745 			 * is actively in use.
746 			 *
747 			 * There is a vulnerability here to an equally bizarre
748 			 * circumstance, where a dead active spare is later
749 			 * brought back to life (onlined or otherwise).  Given
750 			 * the rarity of this scenario, and the extra complexity
751 			 * it adds, we ignore the possibility.
752 			 */
753 			if (!vdev_is_dead(tvd))
754 				spa_spare_activate(tvd);
755 		}
756 
757 		if (vdev_open(vd) != 0)
758 			continue;
759 
760 		vd->vdev_top = vd;
761 		if (vdev_validate_aux(vd) == 0)
762 			spa_spare_add(vd);
763 	}
764 
765 	/*
766 	 * Recompute the stashed list of spares, with status information
767 	 * this time.
768 	 */
769 	VERIFY(nvlist_remove(spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES,
770 	    DATA_TYPE_NVLIST_ARRAY) == 0);
771 
772 	spares = kmem_alloc(spa->spa_spares.sav_count * sizeof (void *),
773 	    KM_SLEEP);
774 	for (i = 0; i < spa->spa_spares.sav_count; i++)
775 		spares[i] = vdev_config_generate(spa,
776 		    spa->spa_spares.sav_vdevs[i], B_TRUE, B_TRUE, B_FALSE);
777 	VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
778 	    ZPOOL_CONFIG_SPARES, spares, spa->spa_spares.sav_count) == 0);
779 	for (i = 0; i < spa->spa_spares.sav_count; i++)
780 		nvlist_free(spares[i]);
781 	kmem_free(spares, spa->spa_spares.sav_count * sizeof (void *));
782 }
783 
784 /*
785  * Load (or re-load) the current list of vdevs describing the active l2cache for
786  * this pool.  When this is called, we have some form of basic information in
787  * 'spa_l2cache.sav_config'.  We parse this into vdevs, try to open them, and
788  * then re-generate a more complete list including status information.
789  * Devices which are already active have their details maintained, and are
790  * not re-opened.
791  */
792 static void
793 spa_load_l2cache(spa_t *spa)
794 {
795 	nvlist_t **l2cache;
796 	uint_t nl2cache;
797 	int i, j, oldnvdevs;
798 	uint64_t guid, size;
799 	vdev_t *vd, **oldvdevs, **newvdevs;
800 	spa_aux_vdev_t *sav = &spa->spa_l2cache;
801 
802 	if (sav->sav_config != NULL) {
803 		VERIFY(nvlist_lookup_nvlist_array(sav->sav_config,
804 		    ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0);
805 		newvdevs = kmem_alloc(nl2cache * sizeof (void *), KM_SLEEP);
806 	} else {
807 		nl2cache = 0;
808 	}
809 
810 	oldvdevs = sav->sav_vdevs;
811 	oldnvdevs = sav->sav_count;
812 	sav->sav_vdevs = NULL;
813 	sav->sav_count = 0;
814 
815 	/*
816 	 * Process new nvlist of vdevs.
817 	 */
818 	for (i = 0; i < nl2cache; i++) {
819 		VERIFY(nvlist_lookup_uint64(l2cache[i], ZPOOL_CONFIG_GUID,
820 		    &guid) == 0);
821 
822 		newvdevs[i] = NULL;
823 		for (j = 0; j < oldnvdevs; j++) {
824 			vd = oldvdevs[j];
825 			if (vd != NULL && guid == vd->vdev_guid) {
826 				/*
827 				 * Retain previous vdev for add/remove ops.
828 				 */
829 				newvdevs[i] = vd;
830 				oldvdevs[j] = NULL;
831 				break;
832 			}
833 		}
834 
835 		if (newvdevs[i] == NULL) {
836 			/*
837 			 * Create new vdev
838 			 */
839 			VERIFY(spa_config_parse(spa, &vd, l2cache[i], NULL, 0,
840 			    VDEV_ALLOC_L2CACHE) == 0);
841 			ASSERT(vd != NULL);
842 			newvdevs[i] = vd;
843 
844 			/*
845 			 * Commit this vdev as an l2cache device,
846 			 * even if it fails to open.
847 			 */
848 			spa_l2cache_add(vd);
849 
850 			vd->vdev_top = vd;
851 			vd->vdev_aux = sav;
852 
853 			spa_l2cache_activate(vd);
854 
855 			if (vdev_open(vd) != 0)
856 				continue;
857 
858 			(void) vdev_validate_aux(vd);
859 
860 			if (!vdev_is_dead(vd)) {
861 				size = vdev_get_rsize(vd);
862 				l2arc_add_vdev(spa, vd,
863 				    VDEV_LABEL_START_SIZE,
864 				    size - VDEV_LABEL_START_SIZE);
865 			}
866 		}
867 	}
868 
869 	/*
870 	 * Purge vdevs that were dropped
871 	 */
872 	for (i = 0; i < oldnvdevs; i++) {
873 		uint64_t pool;
874 
875 		vd = oldvdevs[i];
876 		if (vd != NULL) {
877 			if (spa_mode & FWRITE &&
878 			    spa_l2cache_exists(vd->vdev_guid, &pool) &&
879 			    pool != 0ULL &&
880 			    l2arc_vdev_present(vd)) {
881 				l2arc_remove_vdev(vd);
882 			}
883 			(void) vdev_close(vd);
884 			spa_l2cache_remove(vd);
885 		}
886 	}
887 
888 	if (oldvdevs)
889 		kmem_free(oldvdevs, oldnvdevs * sizeof (void *));
890 
891 	if (sav->sav_config == NULL)
892 		goto out;
893 
894 	sav->sav_vdevs = newvdevs;
895 	sav->sav_count = (int)nl2cache;
896 
897 	/*
898 	 * Recompute the stashed list of l2cache devices, with status
899 	 * information this time.
900 	 */
901 	VERIFY(nvlist_remove(sav->sav_config, ZPOOL_CONFIG_L2CACHE,
902 	    DATA_TYPE_NVLIST_ARRAY) == 0);
903 
904 	l2cache = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP);
905 	for (i = 0; i < sav->sav_count; i++)
906 		l2cache[i] = vdev_config_generate(spa,
907 		    sav->sav_vdevs[i], B_TRUE, B_FALSE, B_TRUE);
908 	VERIFY(nvlist_add_nvlist_array(sav->sav_config,
909 	    ZPOOL_CONFIG_L2CACHE, l2cache, sav->sav_count) == 0);
910 out:
911 	for (i = 0; i < sav->sav_count; i++)
912 		nvlist_free(l2cache[i]);
913 	if (sav->sav_count)
914 		kmem_free(l2cache, sav->sav_count * sizeof (void *));
915 }
916 
917 static int
918 load_nvlist(spa_t *spa, uint64_t obj, nvlist_t **value)
919 {
920 	dmu_buf_t *db;
921 	char *packed = NULL;
922 	size_t nvsize = 0;
923 	int error;
924 	*value = NULL;
925 
926 	VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db));
927 	nvsize = *(uint64_t *)db->db_data;
928 	dmu_buf_rele(db, FTAG);
929 
930 	packed = kmem_alloc(nvsize, KM_SLEEP);
931 	error = dmu_read(spa->spa_meta_objset, obj, 0, nvsize, packed);
932 	if (error == 0)
933 		error = nvlist_unpack(packed, nvsize, value, 0);
934 	kmem_free(packed, nvsize);
935 
936 	return (error);
937 }
938 
939 /*
940  * Checks to see if the given vdev could not be opened, in which case we post a
941  * sysevent to notify the autoreplace code that the device has been removed.
942  */
943 static void
944 spa_check_removed(vdev_t *vd)
945 {
946 	int c;
947 
948 	for (c = 0; c < vd->vdev_children; c++)
949 		spa_check_removed(vd->vdev_child[c]);
950 
951 	if (vd->vdev_ops->vdev_op_leaf && vdev_is_dead(vd)) {
952 		zfs_post_autoreplace(vd->vdev_spa, vd);
953 		spa_event_notify(vd->vdev_spa, vd, ESC_ZFS_VDEV_CHECK);
954 	}
955 }
956 
957 /*
958  * Load an existing storage pool, using the pool's builtin spa_config as a
959  * source of configuration information.
960  */
961 static int
962 spa_load(spa_t *spa, nvlist_t *config, spa_load_state_t state, int mosconfig)
963 {
964 	int error = 0;
965 	nvlist_t *nvroot = NULL;
966 	vdev_t *rvd;
967 	uberblock_t *ub = &spa->spa_uberblock;
968 	uint64_t config_cache_txg = spa->spa_config_txg;
969 	uint64_t pool_guid;
970 	uint64_t version;
971 	zio_t *zio;
972 	uint64_t autoreplace = 0;
973 
974 	spa->spa_load_state = state;
975 
976 	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvroot) ||
977 	    nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid)) {
978 		error = EINVAL;
979 		goto out;
980 	}
981 
982 	/*
983 	 * Versioning wasn't explicitly added to the label until later, so if
984 	 * it's not present treat it as the initial version.
985 	 */
986 	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, &version) != 0)
987 		version = SPA_VERSION_INITIAL;
988 
989 	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG,
990 	    &spa->spa_config_txg);
991 
992 	if ((state == SPA_LOAD_IMPORT || state == SPA_LOAD_TRYIMPORT) &&
993 	    spa_guid_exists(pool_guid, 0)) {
994 		error = EEXIST;
995 		goto out;
996 	}
997 
998 	spa->spa_load_guid = pool_guid;
999 
1000 	/*
1001 	 * Parse the configuration into a vdev tree.  We explicitly set the
1002 	 * value that will be returned by spa_version() since parsing the
1003 	 * configuration requires knowing the version number.
1004 	 */
1005 	spa_config_enter(spa, RW_WRITER, FTAG);
1006 	spa->spa_ubsync.ub_version = version;
1007 	error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_LOAD);
1008 	spa_config_exit(spa, FTAG);
1009 
1010 	if (error != 0)
1011 		goto out;
1012 
1013 	ASSERT(spa->spa_root_vdev == rvd);
1014 	ASSERT(spa_guid(spa) == pool_guid);
1015 
1016 	/*
1017 	 * Try to open all vdevs, loading each label in the process.
1018 	 */
1019 	error = vdev_open(rvd);
1020 	if (error != 0)
1021 		goto out;
1022 
1023 	/*
1024 	 * Validate the labels for all leaf vdevs.  We need to grab the config
1025 	 * lock because all label I/O is done with the ZIO_FLAG_CONFIG_HELD
1026 	 * flag.
1027 	 */
1028 	spa_config_enter(spa, RW_READER, FTAG);
1029 	error = vdev_validate(rvd);
1030 	spa_config_exit(spa, FTAG);
1031 
1032 	if (error != 0)
1033 		goto out;
1034 
1035 	if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) {
1036 		error = ENXIO;
1037 		goto out;
1038 	}
1039 
1040 	/*
1041 	 * Find the best uberblock.
1042 	 */
1043 	bzero(ub, sizeof (uberblock_t));
1044 
1045 	zio = zio_root(spa, NULL, NULL,
1046 	    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE);
1047 	vdev_uberblock_load(zio, rvd, ub);
1048 	error = zio_wait(zio);
1049 
1050 	/*
1051 	 * If we weren't able to find a single valid uberblock, return failure.
1052 	 */
1053 	if (ub->ub_txg == 0) {
1054 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1055 		    VDEV_AUX_CORRUPT_DATA);
1056 		error = ENXIO;
1057 		goto out;
1058 	}
1059 
1060 	/*
1061 	 * If the pool is newer than the code, we can't open it.
1062 	 */
1063 	if (ub->ub_version > SPA_VERSION) {
1064 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1065 		    VDEV_AUX_VERSION_NEWER);
1066 		error = ENOTSUP;
1067 		goto out;
1068 	}
1069 
1070 	/*
1071 	 * If the vdev guid sum doesn't match the uberblock, we have an
1072 	 * incomplete configuration.
1073 	 */
1074 	if (rvd->vdev_guid_sum != ub->ub_guid_sum && mosconfig) {
1075 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1076 		    VDEV_AUX_BAD_GUID_SUM);
1077 		error = ENXIO;
1078 		goto out;
1079 	}
1080 
1081 	/*
1082 	 * Initialize internal SPA structures.
1083 	 */
1084 	spa->spa_state = POOL_STATE_ACTIVE;
1085 	spa->spa_ubsync = spa->spa_uberblock;
1086 	spa->spa_first_txg = spa_last_synced_txg(spa) + 1;
1087 	error = dsl_pool_open(spa, spa->spa_first_txg, &spa->spa_dsl_pool);
1088 	if (error) {
1089 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1090 		    VDEV_AUX_CORRUPT_DATA);
1091 		goto out;
1092 	}
1093 	spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset;
1094 
1095 	if (zap_lookup(spa->spa_meta_objset,
1096 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG,
1097 	    sizeof (uint64_t), 1, &spa->spa_config_object) != 0) {
1098 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1099 		    VDEV_AUX_CORRUPT_DATA);
1100 		error = EIO;
1101 		goto out;
1102 	}
1103 
1104 	if (!mosconfig) {
1105 		nvlist_t *newconfig;
1106 		uint64_t hostid;
1107 
1108 		if (load_nvlist(spa, spa->spa_config_object, &newconfig) != 0) {
1109 			vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1110 			    VDEV_AUX_CORRUPT_DATA);
1111 			error = EIO;
1112 			goto out;
1113 		}
1114 
1115 		if (nvlist_lookup_uint64(newconfig, ZPOOL_CONFIG_HOSTID,
1116 		    &hostid) == 0) {
1117 			char *hostname;
1118 			unsigned long myhostid = 0;
1119 
1120 			VERIFY(nvlist_lookup_string(newconfig,
1121 			    ZPOOL_CONFIG_HOSTNAME, &hostname) == 0);
1122 
1123 			(void) ddi_strtoul(hw_serial, NULL, 10, &myhostid);
1124 			if (hostid != 0 && myhostid != 0 &&
1125 			    (unsigned long)hostid != myhostid) {
1126 				cmn_err(CE_WARN, "pool '%s' could not be "
1127 				    "loaded as it was last accessed by "
1128 				    "another system (host: %s hostid: 0x%lx).  "
1129 				    "See: http://www.sun.com/msg/ZFS-8000-EY",
1130 				    spa->spa_name, hostname,
1131 				    (unsigned long)hostid);
1132 				error = EBADF;
1133 				goto out;
1134 			}
1135 		}
1136 
1137 		spa_config_set(spa, newconfig);
1138 		spa_unload(spa);
1139 		spa_deactivate(spa);
1140 		spa_activate(spa);
1141 
1142 		return (spa_load(spa, newconfig, state, B_TRUE));
1143 	}
1144 
1145 	if (zap_lookup(spa->spa_meta_objset,
1146 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPLIST,
1147 	    sizeof (uint64_t), 1, &spa->spa_sync_bplist_obj) != 0) {
1148 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1149 		    VDEV_AUX_CORRUPT_DATA);
1150 		error = EIO;
1151 		goto out;
1152 	}
1153 
1154 	/*
1155 	 * Load the bit that tells us to use the new accounting function
1156 	 * (raid-z deflation).  If we have an older pool, this will not
1157 	 * be present.
1158 	 */
1159 	error = zap_lookup(spa->spa_meta_objset,
1160 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE,
1161 	    sizeof (uint64_t), 1, &spa->spa_deflate);
1162 	if (error != 0 && error != ENOENT) {
1163 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1164 		    VDEV_AUX_CORRUPT_DATA);
1165 		error = EIO;
1166 		goto out;
1167 	}
1168 
1169 	/*
1170 	 * Load the persistent error log.  If we have an older pool, this will
1171 	 * not be present.
1172 	 */
1173 	error = zap_lookup(spa->spa_meta_objset,
1174 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ERRLOG_LAST,
1175 	    sizeof (uint64_t), 1, &spa->spa_errlog_last);
1176 	if (error != 0 && error != ENOENT) {
1177 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1178 		    VDEV_AUX_CORRUPT_DATA);
1179 		error = EIO;
1180 		goto out;
1181 	}
1182 
1183 	error = zap_lookup(spa->spa_meta_objset,
1184 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ERRLOG_SCRUB,
1185 	    sizeof (uint64_t), 1, &spa->spa_errlog_scrub);
1186 	if (error != 0 && error != ENOENT) {
1187 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1188 		    VDEV_AUX_CORRUPT_DATA);
1189 		error = EIO;
1190 		goto out;
1191 	}
1192 
1193 	/*
1194 	 * Load the history object.  If we have an older pool, this
1195 	 * will not be present.
1196 	 */
1197 	error = zap_lookup(spa->spa_meta_objset,
1198 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_HISTORY,
1199 	    sizeof (uint64_t), 1, &spa->spa_history);
1200 	if (error != 0 && error != ENOENT) {
1201 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1202 		    VDEV_AUX_CORRUPT_DATA);
1203 		error = EIO;
1204 		goto out;
1205 	}
1206 
1207 	/*
1208 	 * Load any hot spares for this pool.
1209 	 */
1210 	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
1211 	    DMU_POOL_SPARES, sizeof (uint64_t), 1, &spa->spa_spares.sav_object);
1212 	if (error != 0 && error != ENOENT) {
1213 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1214 		    VDEV_AUX_CORRUPT_DATA);
1215 		error = EIO;
1216 		goto out;
1217 	}
1218 	if (error == 0) {
1219 		ASSERT(spa_version(spa) >= SPA_VERSION_SPARES);
1220 		if (load_nvlist(spa, spa->spa_spares.sav_object,
1221 		    &spa->spa_spares.sav_config) != 0) {
1222 			vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1223 			    VDEV_AUX_CORRUPT_DATA);
1224 			error = EIO;
1225 			goto out;
1226 		}
1227 
1228 		spa_config_enter(spa, RW_WRITER, FTAG);
1229 		spa_load_spares(spa);
1230 		spa_config_exit(spa, FTAG);
1231 	}
1232 
1233 	/*
1234 	 * Load any level 2 ARC devices for this pool.
1235 	 */
1236 	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
1237 	    DMU_POOL_L2CACHE, sizeof (uint64_t), 1,
1238 	    &spa->spa_l2cache.sav_object);
1239 	if (error != 0 && error != ENOENT) {
1240 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1241 		    VDEV_AUX_CORRUPT_DATA);
1242 		error = EIO;
1243 		goto out;
1244 	}
1245 	if (error == 0) {
1246 		ASSERT(spa_version(spa) >= SPA_VERSION_L2CACHE);
1247 		if (load_nvlist(spa, spa->spa_l2cache.sav_object,
1248 		    &spa->spa_l2cache.sav_config) != 0) {
1249 			vdev_set_state(rvd, B_TRUE,
1250 			    VDEV_STATE_CANT_OPEN,
1251 			    VDEV_AUX_CORRUPT_DATA);
1252 			error = EIO;
1253 			goto out;
1254 		}
1255 
1256 		spa_config_enter(spa, RW_WRITER, FTAG);
1257 		spa_load_l2cache(spa);
1258 		spa_config_exit(spa, FTAG);
1259 	}
1260 
1261 	spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION);
1262 
1263 	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
1264 	    DMU_POOL_PROPS, sizeof (uint64_t), 1, &spa->spa_pool_props_object);
1265 
1266 	if (error && error != ENOENT) {
1267 		vdev_set_state(rvd, B_TRUE, VDEV_STATE_CANT_OPEN,
1268 		    VDEV_AUX_CORRUPT_DATA);
1269 		error = EIO;
1270 		goto out;
1271 	}
1272 
1273 	if (error == 0) {
1274 		(void) zap_lookup(spa->spa_meta_objset,
1275 		    spa->spa_pool_props_object,
1276 		    zpool_prop_to_name(ZPOOL_PROP_BOOTFS),
1277 		    sizeof (uint64_t), 1, &spa->spa_bootfs);
1278 		(void) zap_lookup(spa->spa_meta_objset,
1279 		    spa->spa_pool_props_object,
1280 		    zpool_prop_to_name(ZPOOL_PROP_AUTOREPLACE),
1281 		    sizeof (uint64_t), 1, &autoreplace);
1282 		(void) zap_lookup(spa->spa_meta_objset,
1283 		    spa->spa_pool_props_object,
1284 		    zpool_prop_to_name(ZPOOL_PROP_DELEGATION),
1285 		    sizeof (uint64_t), 1, &spa->spa_delegation);
1286 		(void) zap_lookup(spa->spa_meta_objset,
1287 		    spa->spa_pool_props_object,
1288 		    zpool_prop_to_name(ZPOOL_PROP_FAILUREMODE),
1289 		    sizeof (uint64_t), 1, &spa->spa_failmode);
1290 	}
1291 
1292 	/*
1293 	 * If the 'autoreplace' property is set, then post a resource notifying
1294 	 * the ZFS DE that it should not issue any faults for unopenable
1295 	 * devices.  We also iterate over the vdevs, and post a sysevent for any
1296 	 * unopenable vdevs so that the normal autoreplace handler can take
1297 	 * over.
1298 	 */
1299 	if (autoreplace && state != SPA_LOAD_TRYIMPORT)
1300 		spa_check_removed(spa->spa_root_vdev);
1301 
1302 	/*
1303 	 * Load the vdev state for all toplevel vdevs.
1304 	 */
1305 	vdev_load(rvd);
1306 
1307 	/*
1308 	 * Propagate the leaf DTLs we just loaded all the way up the tree.
1309 	 */
1310 	spa_config_enter(spa, RW_WRITER, FTAG);
1311 	vdev_dtl_reassess(rvd, 0, 0, B_FALSE);
1312 	spa_config_exit(spa, FTAG);
1313 
1314 	/*
1315 	 * Check the state of the root vdev.  If it can't be opened, it
1316 	 * indicates one or more toplevel vdevs are faulted.
1317 	 */
1318 	if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) {
1319 		error = ENXIO;
1320 		goto out;
1321 	}
1322 
1323 	if ((spa_mode & FWRITE) && state != SPA_LOAD_TRYIMPORT) {
1324 		dmu_tx_t *tx;
1325 		int need_update = B_FALSE;
1326 		int c;
1327 
1328 		/*
1329 		 * Claim log blocks that haven't been committed yet.
1330 		 * This must all happen in a single txg.
1331 		 */
1332 		tx = dmu_tx_create_assigned(spa_get_dsl(spa),
1333 		    spa_first_txg(spa));
1334 		(void) dmu_objset_find(spa->spa_name,
1335 		    zil_claim, tx, DS_FIND_CHILDREN);
1336 		dmu_tx_commit(tx);
1337 
1338 		spa->spa_sync_on = B_TRUE;
1339 		txg_sync_start(spa->spa_dsl_pool);
1340 
1341 		/*
1342 		 * Wait for all claims to sync.
1343 		 */
1344 		txg_wait_synced(spa->spa_dsl_pool, 0);
1345 
1346 		/*
1347 		 * If the config cache is stale, or we have uninitialized
1348 		 * metaslabs (see spa_vdev_add()), then update the config.
1349 		 */
1350 		if (config_cache_txg != spa->spa_config_txg ||
1351 		    state == SPA_LOAD_IMPORT)
1352 			need_update = B_TRUE;
1353 
1354 		for (c = 0; c < rvd->vdev_children; c++)
1355 			if (rvd->vdev_child[c]->vdev_ms_array == 0)
1356 				need_update = B_TRUE;
1357 
1358 		/*
1359 		 * Update the config cache asychronously in case we're the
1360 		 * root pool, in which case the config cache isn't writable yet.
1361 		 */
1362 		if (need_update)
1363 			spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
1364 	}
1365 
1366 	error = 0;
1367 out:
1368 	spa->spa_minref = refcount_count(&spa->spa_refcount);
1369 	if (error && error != EBADF)
1370 		zfs_ereport_post(FM_EREPORT_ZFS_POOL, spa, NULL, NULL, 0, 0);
1371 	spa->spa_load_state = SPA_LOAD_NONE;
1372 	spa->spa_ena = 0;
1373 
1374 	return (error);
1375 }
1376 
1377 /*
1378  * Pool Open/Import
1379  *
1380  * The import case is identical to an open except that the configuration is sent
1381  * down from userland, instead of grabbed from the configuration cache.  For the
1382  * case of an open, the pool configuration will exist in the
1383  * POOL_STATE_UNINITIALIZED state.
1384  *
1385  * The stats information (gen/count/ustats) is used to gather vdev statistics at
1386  * the same time open the pool, without having to keep around the spa_t in some
1387  * ambiguous state.
1388  */
1389 static int
1390 spa_open_common(const char *pool, spa_t **spapp, void *tag, nvlist_t **config)
1391 {
1392 	spa_t *spa;
1393 	int error;
1394 	int locked = B_FALSE;
1395 
1396 	*spapp = NULL;
1397 
1398 	/*
1399 	 * As disgusting as this is, we need to support recursive calls to this
1400 	 * function because dsl_dir_open() is called during spa_load(), and ends
1401 	 * up calling spa_open() again.  The real fix is to figure out how to
1402 	 * avoid dsl_dir_open() calling this in the first place.
1403 	 */
1404 	if (mutex_owner(&spa_namespace_lock) != curthread) {
1405 		mutex_enter(&spa_namespace_lock);
1406 		locked = B_TRUE;
1407 	}
1408 
1409 	if ((spa = spa_lookup(pool)) == NULL) {
1410 		if (locked)
1411 			mutex_exit(&spa_namespace_lock);
1412 		return (ENOENT);
1413 	}
1414 	if (spa->spa_state == POOL_STATE_UNINITIALIZED) {
1415 
1416 		spa_activate(spa);
1417 
1418 		error = spa_load(spa, spa->spa_config, SPA_LOAD_OPEN, B_FALSE);
1419 
1420 		if (error == EBADF) {
1421 			/*
1422 			 * If vdev_validate() returns failure (indicated by
1423 			 * EBADF), it indicates that one of the vdevs indicates
1424 			 * that the pool has been exported or destroyed.  If
1425 			 * this is the case, the config cache is out of sync and
1426 			 * we should remove the pool from the namespace.
1427 			 */
1428 			spa_unload(spa);
1429 			spa_deactivate(spa);
1430 			spa_config_sync(spa, B_TRUE, B_TRUE);
1431 			spa_remove(spa);
1432 			if (locked)
1433 				mutex_exit(&spa_namespace_lock);
1434 			return (ENOENT);
1435 		}
1436 
1437 		if (error) {
1438 			/*
1439 			 * We can't open the pool, but we still have useful
1440 			 * information: the state of each vdev after the
1441 			 * attempted vdev_open().  Return this to the user.
1442 			 */
1443 			if (config != NULL && spa->spa_root_vdev != NULL) {
1444 				spa_config_enter(spa, RW_READER, FTAG);
1445 				*config = spa_config_generate(spa, NULL, -1ULL,
1446 				    B_TRUE);
1447 				spa_config_exit(spa, FTAG);
1448 			}
1449 			spa_unload(spa);
1450 			spa_deactivate(spa);
1451 			spa->spa_last_open_failed = B_TRUE;
1452 			if (locked)
1453 				mutex_exit(&spa_namespace_lock);
1454 			*spapp = NULL;
1455 			return (error);
1456 		} else {
1457 			spa->spa_last_open_failed = B_FALSE;
1458 		}
1459 	}
1460 
1461 	spa_open_ref(spa, tag);
1462 
1463 	if (locked)
1464 		mutex_exit(&spa_namespace_lock);
1465 
1466 	*spapp = spa;
1467 
1468 	if (config != NULL) {
1469 		spa_config_enter(spa, RW_READER, FTAG);
1470 		*config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
1471 		spa_config_exit(spa, FTAG);
1472 	}
1473 
1474 	return (0);
1475 }
1476 
1477 int
1478 spa_open(const char *name, spa_t **spapp, void *tag)
1479 {
1480 	return (spa_open_common(name, spapp, tag, NULL));
1481 }
1482 
1483 /*
1484  * Lookup the given spa_t, incrementing the inject count in the process,
1485  * preventing it from being exported or destroyed.
1486  */
1487 spa_t *
1488 spa_inject_addref(char *name)
1489 {
1490 	spa_t *spa;
1491 
1492 	mutex_enter(&spa_namespace_lock);
1493 	if ((spa = spa_lookup(name)) == NULL) {
1494 		mutex_exit(&spa_namespace_lock);
1495 		return (NULL);
1496 	}
1497 	spa->spa_inject_ref++;
1498 	mutex_exit(&spa_namespace_lock);
1499 
1500 	return (spa);
1501 }
1502 
1503 void
1504 spa_inject_delref(spa_t *spa)
1505 {
1506 	mutex_enter(&spa_namespace_lock);
1507 	spa->spa_inject_ref--;
1508 	mutex_exit(&spa_namespace_lock);
1509 }
1510 
1511 /*
1512  * Add spares device information to the nvlist.
1513  */
1514 static void
1515 spa_add_spares(spa_t *spa, nvlist_t *config)
1516 {
1517 	nvlist_t **spares;
1518 	uint_t i, nspares;
1519 	nvlist_t *nvroot;
1520 	uint64_t guid;
1521 	vdev_stat_t *vs;
1522 	uint_t vsc;
1523 	uint64_t pool;
1524 
1525 	if (spa->spa_spares.sav_count == 0)
1526 		return;
1527 
1528 	VERIFY(nvlist_lookup_nvlist(config,
1529 	    ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
1530 	VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
1531 	    ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);
1532 	if (nspares != 0) {
1533 		VERIFY(nvlist_add_nvlist_array(nvroot,
1534 		    ZPOOL_CONFIG_SPARES, spares, nspares) == 0);
1535 		VERIFY(nvlist_lookup_nvlist_array(nvroot,
1536 		    ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);
1537 
1538 		/*
1539 		 * Go through and find any spares which have since been
1540 		 * repurposed as an active spare.  If this is the case, update
1541 		 * their status appropriately.
1542 		 */
1543 		for (i = 0; i < nspares; i++) {
1544 			VERIFY(nvlist_lookup_uint64(spares[i],
1545 			    ZPOOL_CONFIG_GUID, &guid) == 0);
1546 			if (spa_spare_exists(guid, &pool) && pool != 0ULL) {
1547 				VERIFY(nvlist_lookup_uint64_array(
1548 				    spares[i], ZPOOL_CONFIG_STATS,
1549 				    (uint64_t **)&vs, &vsc) == 0);
1550 				vs->vs_state = VDEV_STATE_CANT_OPEN;
1551 				vs->vs_aux = VDEV_AUX_SPARED;
1552 			}
1553 		}
1554 	}
1555 }
1556 
1557 /*
1558  * Add l2cache device information to the nvlist, including vdev stats.
1559  */
1560 static void
1561 spa_add_l2cache(spa_t *spa, nvlist_t *config)
1562 {
1563 	nvlist_t **l2cache;
1564 	uint_t i, j, nl2cache;
1565 	nvlist_t *nvroot;
1566 	uint64_t guid;
1567 	vdev_t *vd;
1568 	vdev_stat_t *vs;
1569 	uint_t vsc;
1570 
1571 	if (spa->spa_l2cache.sav_count == 0)
1572 		return;
1573 
1574 	spa_config_enter(spa, RW_READER, FTAG);
1575 
1576 	VERIFY(nvlist_lookup_nvlist(config,
1577 	    ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
1578 	VERIFY(nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config,
1579 	    ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0);
1580 	if (nl2cache != 0) {
1581 		VERIFY(nvlist_add_nvlist_array(nvroot,
1582 		    ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0);
1583 		VERIFY(nvlist_lookup_nvlist_array(nvroot,
1584 		    ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0);
1585 
1586 		/*
1587 		 * Update level 2 cache device stats.
1588 		 */
1589 
1590 		for (i = 0; i < nl2cache; i++) {
1591 			VERIFY(nvlist_lookup_uint64(l2cache[i],
1592 			    ZPOOL_CONFIG_GUID, &guid) == 0);
1593 
1594 			vd = NULL;
1595 			for (j = 0; j < spa->spa_l2cache.sav_count; j++) {
1596 				if (guid ==
1597 				    spa->spa_l2cache.sav_vdevs[j]->vdev_guid) {
1598 					vd = spa->spa_l2cache.sav_vdevs[j];
1599 					break;
1600 				}
1601 			}
1602 			ASSERT(vd != NULL);
1603 
1604 			VERIFY(nvlist_lookup_uint64_array(l2cache[i],
1605 			    ZPOOL_CONFIG_STATS, (uint64_t **)&vs, &vsc) == 0);
1606 			vdev_get_stats(vd, vs);
1607 		}
1608 	}
1609 
1610 	spa_config_exit(spa, FTAG);
1611 }
1612 
1613 int
1614 spa_get_stats(const char *name, nvlist_t **config, char *altroot, size_t buflen)
1615 {
1616 	int error;
1617 	spa_t *spa;
1618 
1619 	*config = NULL;
1620 	error = spa_open_common(name, &spa, FTAG, config);
1621 
1622 	if (spa && *config != NULL) {
1623 		VERIFY(nvlist_add_uint64(*config, ZPOOL_CONFIG_ERRCOUNT,
1624 		    spa_get_errlog_size(spa)) == 0);
1625 
1626 		spa_add_spares(spa, *config);
1627 		spa_add_l2cache(spa, *config);
1628 	}
1629 
1630 	/*
1631 	 * We want to get the alternate root even for faulted pools, so we cheat
1632 	 * and call spa_lookup() directly.
1633 	 */
1634 	if (altroot) {
1635 		if (spa == NULL) {
1636 			mutex_enter(&spa_namespace_lock);
1637 			spa = spa_lookup(name);
1638 			if (spa)
1639 				spa_altroot(spa, altroot, buflen);
1640 			else
1641 				altroot[0] = '\0';
1642 			spa = NULL;
1643 			mutex_exit(&spa_namespace_lock);
1644 		} else {
1645 			spa_altroot(spa, altroot, buflen);
1646 		}
1647 	}
1648 
1649 	if (spa != NULL)
1650 		spa_close(spa, FTAG);
1651 
1652 	return (error);
1653 }
1654 
1655 /*
1656  * Validate that the auxiliary device array is well formed.  We must have an
1657  * array of nvlists, each which describes a valid leaf vdev.  If this is an
1658  * import (mode is VDEV_ALLOC_SPARE), then we allow corrupted spares to be
1659  * specified, as long as they are well-formed.
1660  */
1661 static int
1662 spa_validate_aux_devs(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode,
1663     spa_aux_vdev_t *sav, const char *config, uint64_t version,
1664     vdev_labeltype_t label)
1665 {
1666 	nvlist_t **dev;
1667 	uint_t i, ndev;
1668 	vdev_t *vd;
1669 	int error;
1670 
1671 	/*
1672 	 * It's acceptable to have no devs specified.
1673 	 */
1674 	if (nvlist_lookup_nvlist_array(nvroot, config, &dev, &ndev) != 0)
1675 		return (0);
1676 
1677 	if (ndev == 0)
1678 		return (EINVAL);
1679 
1680 	/*
1681 	 * Make sure the pool is formatted with a version that supports this
1682 	 * device type.
1683 	 */
1684 	if (spa_version(spa) < version)
1685 		return (ENOTSUP);
1686 
1687 	/*
1688 	 * Set the pending device list so we correctly handle device in-use
1689 	 * checking.
1690 	 */
1691 	sav->sav_pending = dev;
1692 	sav->sav_npending = ndev;
1693 
1694 	for (i = 0; i < ndev; i++) {
1695 		if ((error = spa_config_parse(spa, &vd, dev[i], NULL, 0,
1696 		    mode)) != 0)
1697 			goto out;
1698 
1699 		if (!vd->vdev_ops->vdev_op_leaf) {
1700 			vdev_free(vd);
1701 			error = EINVAL;
1702 			goto out;
1703 		}
1704 
1705 		/*
1706 		 * The L2ARC currently only supports disk devices.
1707 		 */
1708 		if ((strcmp(config, ZPOOL_CONFIG_L2CACHE) == 0) &&
1709 		    strcmp(vd->vdev_ops->vdev_op_type, VDEV_TYPE_DISK) != 0) {
1710 			error = ENOTBLK;
1711 			goto out;
1712 		}
1713 
1714 		vd->vdev_top = vd;
1715 
1716 		if ((error = vdev_open(vd)) == 0 &&
1717 		    (error = vdev_label_init(vd, crtxg, label)) == 0) {
1718 			VERIFY(nvlist_add_uint64(dev[i], ZPOOL_CONFIG_GUID,
1719 			    vd->vdev_guid) == 0);
1720 		}
1721 
1722 		vdev_free(vd);
1723 
1724 		if (error &&
1725 		    (mode != VDEV_ALLOC_SPARE && mode != VDEV_ALLOC_L2CACHE))
1726 			goto out;
1727 		else
1728 			error = 0;
1729 	}
1730 
1731 out:
1732 	sav->sav_pending = NULL;
1733 	sav->sav_npending = 0;
1734 	return (error);
1735 }
1736 
1737 static int
1738 spa_validate_aux(spa_t *spa, nvlist_t *nvroot, uint64_t crtxg, int mode)
1739 {
1740 	int error;
1741 
1742 	if ((error = spa_validate_aux_devs(spa, nvroot, crtxg, mode,
1743 	    &spa->spa_spares, ZPOOL_CONFIG_SPARES, SPA_VERSION_SPARES,
1744 	    VDEV_LABEL_SPARE)) != 0) {
1745 		return (error);
1746 	}
1747 
1748 	return (spa_validate_aux_devs(spa, nvroot, crtxg, mode,
1749 	    &spa->spa_l2cache, ZPOOL_CONFIG_L2CACHE, SPA_VERSION_L2CACHE,
1750 	    VDEV_LABEL_L2CACHE));
1751 }
1752 
1753 static void
1754 spa_set_aux_vdevs(spa_aux_vdev_t *sav, nvlist_t **devs, int ndevs,
1755     const char *config)
1756 {
1757 	int i;
1758 
1759 	if (sav->sav_config != NULL) {
1760 		nvlist_t **olddevs;
1761 		uint_t oldndevs;
1762 		nvlist_t **newdevs;
1763 
1764 		/*
1765 		 * Generate new dev list by concatentating with the
1766 		 * current dev list.
1767 		 */
1768 		VERIFY(nvlist_lookup_nvlist_array(sav->sav_config, config,
1769 		    &olddevs, &oldndevs) == 0);
1770 
1771 		newdevs = kmem_alloc(sizeof (void *) *
1772 		    (ndevs + oldndevs), KM_SLEEP);
1773 		for (i = 0; i < oldndevs; i++)
1774 			VERIFY(nvlist_dup(olddevs[i], &newdevs[i],
1775 			    KM_SLEEP) == 0);
1776 		for (i = 0; i < ndevs; i++)
1777 			VERIFY(nvlist_dup(devs[i], &newdevs[i + oldndevs],
1778 			    KM_SLEEP) == 0);
1779 
1780 		VERIFY(nvlist_remove(sav->sav_config, config,
1781 		    DATA_TYPE_NVLIST_ARRAY) == 0);
1782 
1783 		VERIFY(nvlist_add_nvlist_array(sav->sav_config,
1784 		    config, newdevs, ndevs + oldndevs) == 0);
1785 		for (i = 0; i < oldndevs + ndevs; i++)
1786 			nvlist_free(newdevs[i]);
1787 		kmem_free(newdevs, (oldndevs + ndevs) * sizeof (void *));
1788 	} else {
1789 		/*
1790 		 * Generate a new dev list.
1791 		 */
1792 		VERIFY(nvlist_alloc(&sav->sav_config, NV_UNIQUE_NAME,
1793 		    KM_SLEEP) == 0);
1794 		VERIFY(nvlist_add_nvlist_array(sav->sav_config, config,
1795 		    devs, ndevs) == 0);
1796 	}
1797 }
1798 
1799 /*
1800  * Stop and drop level 2 ARC devices
1801  */
1802 void
1803 spa_l2cache_drop(spa_t *spa)
1804 {
1805 	vdev_t *vd;
1806 	int i;
1807 	spa_aux_vdev_t *sav = &spa->spa_l2cache;
1808 
1809 	for (i = 0; i < sav->sav_count; i++) {
1810 		uint64_t pool;
1811 
1812 		vd = sav->sav_vdevs[i];
1813 		ASSERT(vd != NULL);
1814 
1815 		if (spa_mode & FWRITE &&
1816 		    spa_l2cache_exists(vd->vdev_guid, &pool) && pool != 0ULL &&
1817 		    l2arc_vdev_present(vd)) {
1818 			l2arc_remove_vdev(vd);
1819 		}
1820 		if (vd->vdev_isl2cache)
1821 			spa_l2cache_remove(vd);
1822 		vdev_clear_stats(vd);
1823 		(void) vdev_close(vd);
1824 	}
1825 }
1826 
1827 /*
1828  * Pool Creation
1829  */
1830 int
1831 spa_create(const char *pool, nvlist_t *nvroot, nvlist_t *props,
1832     const char *history_str)
1833 {
1834 	spa_t *spa;
1835 	char *altroot = NULL;
1836 	vdev_t *rvd;
1837 	dsl_pool_t *dp;
1838 	dmu_tx_t *tx;
1839 	int c, error = 0;
1840 	uint64_t txg = TXG_INITIAL;
1841 	nvlist_t **spares, **l2cache;
1842 	uint_t nspares, nl2cache;
1843 	uint64_t version;
1844 
1845 	/*
1846 	 * If this pool already exists, return failure.
1847 	 */
1848 	mutex_enter(&spa_namespace_lock);
1849 	if (spa_lookup(pool) != NULL) {
1850 		mutex_exit(&spa_namespace_lock);
1851 		return (EEXIST);
1852 	}
1853 
1854 	/*
1855 	 * Allocate a new spa_t structure.
1856 	 */
1857 	(void) nvlist_lookup_string(props,
1858 	    zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot);
1859 	spa = spa_add(pool, altroot);
1860 	spa_activate(spa);
1861 
1862 	spa->spa_uberblock.ub_txg = txg - 1;
1863 
1864 	if (props && (error = spa_prop_validate(spa, props))) {
1865 		spa_unload(spa);
1866 		spa_deactivate(spa);
1867 		spa_remove(spa);
1868 		mutex_exit(&spa_namespace_lock);
1869 		return (error);
1870 	}
1871 
1872 	if (nvlist_lookup_uint64(props, zpool_prop_to_name(ZPOOL_PROP_VERSION),
1873 	    &version) != 0)
1874 		version = SPA_VERSION;
1875 	ASSERT(version <= SPA_VERSION);
1876 	spa->spa_uberblock.ub_version = version;
1877 	spa->spa_ubsync = spa->spa_uberblock;
1878 
1879 	/*
1880 	 * Create the root vdev.
1881 	 */
1882 	spa_config_enter(spa, RW_WRITER, FTAG);
1883 
1884 	error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_ADD);
1885 
1886 	ASSERT(error != 0 || rvd != NULL);
1887 	ASSERT(error != 0 || spa->spa_root_vdev == rvd);
1888 
1889 	if (error == 0 && !zfs_allocatable_devs(nvroot))
1890 		error = EINVAL;
1891 
1892 	if (error == 0 &&
1893 	    (error = vdev_create(rvd, txg, B_FALSE)) == 0 &&
1894 	    (error = spa_validate_aux(spa, nvroot, txg,
1895 	    VDEV_ALLOC_ADD)) == 0) {
1896 		for (c = 0; c < rvd->vdev_children; c++)
1897 			vdev_init(rvd->vdev_child[c], txg);
1898 		vdev_config_dirty(rvd);
1899 	}
1900 
1901 	spa_config_exit(spa, FTAG);
1902 
1903 	if (error != 0) {
1904 		spa_unload(spa);
1905 		spa_deactivate(spa);
1906 		spa_remove(spa);
1907 		mutex_exit(&spa_namespace_lock);
1908 		return (error);
1909 	}
1910 
1911 	/*
1912 	 * Get the list of spares, if specified.
1913 	 */
1914 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
1915 	    &spares, &nspares) == 0) {
1916 		VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, NV_UNIQUE_NAME,
1917 		    KM_SLEEP) == 0);
1918 		VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
1919 		    ZPOOL_CONFIG_SPARES, spares, nspares) == 0);
1920 		spa_config_enter(spa, RW_WRITER, FTAG);
1921 		spa_load_spares(spa);
1922 		spa_config_exit(spa, FTAG);
1923 		spa->spa_spares.sav_sync = B_TRUE;
1924 	}
1925 
1926 	/*
1927 	 * Get the list of level 2 cache devices, if specified.
1928 	 */
1929 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
1930 	    &l2cache, &nl2cache) == 0) {
1931 		VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config,
1932 		    NV_UNIQUE_NAME, KM_SLEEP) == 0);
1933 		VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config,
1934 		    ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0);
1935 		spa_config_enter(spa, RW_WRITER, FTAG);
1936 		spa_load_l2cache(spa);
1937 		spa_config_exit(spa, FTAG);
1938 		spa->spa_l2cache.sav_sync = B_TRUE;
1939 	}
1940 
1941 	spa->spa_dsl_pool = dp = dsl_pool_create(spa, txg);
1942 	spa->spa_meta_objset = dp->dp_meta_objset;
1943 
1944 	tx = dmu_tx_create_assigned(dp, txg);
1945 
1946 	/*
1947 	 * Create the pool config object.
1948 	 */
1949 	spa->spa_config_object = dmu_object_alloc(spa->spa_meta_objset,
1950 	    DMU_OT_PACKED_NVLIST, 1 << 14,
1951 	    DMU_OT_PACKED_NVLIST_SIZE, sizeof (uint64_t), tx);
1952 
1953 	if (zap_add(spa->spa_meta_objset,
1954 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG,
1955 	    sizeof (uint64_t), 1, &spa->spa_config_object, tx) != 0) {
1956 		cmn_err(CE_PANIC, "failed to add pool config");
1957 	}
1958 
1959 	/* Newly created pools with the right version are always deflated. */
1960 	if (version >= SPA_VERSION_RAIDZ_DEFLATE) {
1961 		spa->spa_deflate = TRUE;
1962 		if (zap_add(spa->spa_meta_objset,
1963 		    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE,
1964 		    sizeof (uint64_t), 1, &spa->spa_deflate, tx) != 0) {
1965 			cmn_err(CE_PANIC, "failed to add deflate");
1966 		}
1967 	}
1968 
1969 	/*
1970 	 * Create the deferred-free bplist object.  Turn off compression
1971 	 * because sync-to-convergence takes longer if the blocksize
1972 	 * keeps changing.
1973 	 */
1974 	spa->spa_sync_bplist_obj = bplist_create(spa->spa_meta_objset,
1975 	    1 << 14, tx);
1976 	dmu_object_set_compress(spa->spa_meta_objset, spa->spa_sync_bplist_obj,
1977 	    ZIO_COMPRESS_OFF, tx);
1978 
1979 	if (zap_add(spa->spa_meta_objset,
1980 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPLIST,
1981 	    sizeof (uint64_t), 1, &spa->spa_sync_bplist_obj, tx) != 0) {
1982 		cmn_err(CE_PANIC, "failed to add bplist");
1983 	}
1984 
1985 	/*
1986 	 * Create the pool's history object.
1987 	 */
1988 	if (version >= SPA_VERSION_ZPOOL_HISTORY)
1989 		spa_history_create_obj(spa, tx);
1990 
1991 	/*
1992 	 * Set pool properties.
1993 	 */
1994 	spa->spa_bootfs = zpool_prop_default_numeric(ZPOOL_PROP_BOOTFS);
1995 	spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION);
1996 	spa->spa_failmode = zpool_prop_default_numeric(ZPOOL_PROP_FAILUREMODE);
1997 	if (props)
1998 		spa_sync_props(spa, props, CRED(), tx);
1999 
2000 	dmu_tx_commit(tx);
2001 
2002 	spa->spa_sync_on = B_TRUE;
2003 	txg_sync_start(spa->spa_dsl_pool);
2004 
2005 	/*
2006 	 * We explicitly wait for the first transaction to complete so that our
2007 	 * bean counters are appropriately updated.
2008 	 */
2009 	txg_wait_synced(spa->spa_dsl_pool, txg);
2010 
2011 	spa_config_sync(spa, B_FALSE, B_TRUE);
2012 
2013 	if (version >= SPA_VERSION_ZPOOL_HISTORY && history_str != NULL)
2014 		(void) spa_history_log(spa, history_str, LOG_CMD_POOL_CREATE);
2015 
2016 	mutex_exit(&spa_namespace_lock);
2017 
2018 	spa->spa_minref = refcount_count(&spa->spa_refcount);
2019 
2020 	return (0);
2021 }
2022 
2023 /*
2024  * Import the given pool into the system.  We set up the necessary spa_t and
2025  * then call spa_load() to do the dirty work.
2026  */
2027 static int
2028 spa_import_common(const char *pool, nvlist_t *config, nvlist_t *props,
2029     boolean_t isroot, boolean_t allowfaulted)
2030 {
2031 	spa_t *spa;
2032 	char *altroot = NULL;
2033 	int error, loaderr;
2034 	nvlist_t *nvroot;
2035 	nvlist_t **spares, **l2cache;
2036 	uint_t nspares, nl2cache;
2037 
2038 	/*
2039 	 * If a pool with this name exists, return failure.
2040 	 */
2041 	mutex_enter(&spa_namespace_lock);
2042 	if (spa_lookup(pool) != NULL) {
2043 		mutex_exit(&spa_namespace_lock);
2044 		return (EEXIST);
2045 	}
2046 
2047 	/*
2048 	 * Create and initialize the spa structure.
2049 	 */
2050 	(void) nvlist_lookup_string(props,
2051 	    zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot);
2052 	spa = spa_add(pool, altroot);
2053 	spa_activate(spa);
2054 
2055 	if (allowfaulted)
2056 		spa->spa_import_faulted = B_TRUE;
2057 	spa->spa_is_root = isroot;
2058 
2059 	/*
2060 	 * Pass off the heavy lifting to spa_load().
2061 	 * Pass TRUE for mosconfig (unless this is a root pool) because
2062 	 * the user-supplied config is actually the one to trust when
2063 	 * doing an import.
2064 	 */
2065 	loaderr = error = spa_load(spa, config, SPA_LOAD_IMPORT, !isroot);
2066 
2067 	spa_config_enter(spa, RW_WRITER, FTAG);
2068 	/*
2069 	 * Toss any existing sparelist, as it doesn't have any validity anymore,
2070 	 * and conflicts with spa_has_spare().
2071 	 */
2072 	if (!isroot && spa->spa_spares.sav_config) {
2073 		nvlist_free(spa->spa_spares.sav_config);
2074 		spa->spa_spares.sav_config = NULL;
2075 		spa_load_spares(spa);
2076 	}
2077 	if (!isroot && spa->spa_l2cache.sav_config) {
2078 		nvlist_free(spa->spa_l2cache.sav_config);
2079 		spa->spa_l2cache.sav_config = NULL;
2080 		spa_load_l2cache(spa);
2081 	}
2082 
2083 	VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
2084 	    &nvroot) == 0);
2085 	if (error == 0)
2086 		error = spa_validate_aux(spa, nvroot, -1ULL, VDEV_ALLOC_SPARE);
2087 	if (error == 0)
2088 		error = spa_validate_aux(spa, nvroot, -1ULL,
2089 		    VDEV_ALLOC_L2CACHE);
2090 	spa_config_exit(spa, FTAG);
2091 
2092 	if (error != 0 || (props && (error = spa_prop_set(spa, props)))) {
2093 		if (loaderr != 0 && loaderr != EINVAL && allowfaulted) {
2094 			/*
2095 			 * If we failed to load the pool, but 'allowfaulted' is
2096 			 * set, then manually set the config as if the config
2097 			 * passed in was specified in the cache file.
2098 			 */
2099 			error = 0;
2100 			spa->spa_import_faulted = B_FALSE;
2101 			if (spa->spa_config == NULL) {
2102 				spa_config_enter(spa, RW_READER, FTAG);
2103 				spa->spa_config = spa_config_generate(spa,
2104 				    NULL, -1ULL, B_TRUE);
2105 				spa_config_exit(spa, FTAG);
2106 			}
2107 			spa_unload(spa);
2108 			spa_deactivate(spa);
2109 			spa_config_sync(spa, B_FALSE, B_TRUE);
2110 		} else {
2111 			spa_unload(spa);
2112 			spa_deactivate(spa);
2113 			spa_remove(spa);
2114 		}
2115 		mutex_exit(&spa_namespace_lock);
2116 		return (error);
2117 	}
2118 
2119 	/*
2120 	 * Override any spares and level 2 cache devices as specified by
2121 	 * the user, as these may have correct device names/devids, etc.
2122 	 */
2123 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
2124 	    &spares, &nspares) == 0) {
2125 		if (spa->spa_spares.sav_config)
2126 			VERIFY(nvlist_remove(spa->spa_spares.sav_config,
2127 			    ZPOOL_CONFIG_SPARES, DATA_TYPE_NVLIST_ARRAY) == 0);
2128 		else
2129 			VERIFY(nvlist_alloc(&spa->spa_spares.sav_config,
2130 			    NV_UNIQUE_NAME, KM_SLEEP) == 0);
2131 		VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
2132 		    ZPOOL_CONFIG_SPARES, spares, nspares) == 0);
2133 		spa_config_enter(spa, RW_WRITER, FTAG);
2134 		spa_load_spares(spa);
2135 		spa_config_exit(spa, FTAG);
2136 		spa->spa_spares.sav_sync = B_TRUE;
2137 	}
2138 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
2139 	    &l2cache, &nl2cache) == 0) {
2140 		if (spa->spa_l2cache.sav_config)
2141 			VERIFY(nvlist_remove(spa->spa_l2cache.sav_config,
2142 			    ZPOOL_CONFIG_L2CACHE, DATA_TYPE_NVLIST_ARRAY) == 0);
2143 		else
2144 			VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config,
2145 			    NV_UNIQUE_NAME, KM_SLEEP) == 0);
2146 		VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config,
2147 		    ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0);
2148 		spa_config_enter(spa, RW_WRITER, FTAG);
2149 		spa_load_l2cache(spa);
2150 		spa_config_exit(spa, FTAG);
2151 		spa->spa_l2cache.sav_sync = B_TRUE;
2152 	}
2153 
2154 	if (spa_mode & FWRITE) {
2155 		/*
2156 		 * Update the config cache to include the newly-imported pool.
2157 		 */
2158 		spa_config_update_common(spa, SPA_CONFIG_UPDATE_POOL, isroot);
2159 	}
2160 
2161 	spa->spa_import_faulted = B_FALSE;
2162 	mutex_exit(&spa_namespace_lock);
2163 
2164 	return (0);
2165 }
2166 
2167 #ifdef _KERNEL
2168 /*
2169  * Build a "root" vdev for a top level vdev read in from a rootpool
2170  * device label.
2171  */
2172 static void
2173 spa_build_rootpool_config(nvlist_t *config)
2174 {
2175 	nvlist_t *nvtop, *nvroot;
2176 	uint64_t pgid;
2177 
2178 	/*
2179 	 * Add this top-level vdev to the child array.
2180 	 */
2181 	VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvtop)
2182 	    == 0);
2183 	VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pgid)
2184 	    == 0);
2185 
2186 	/*
2187 	 * Put this pool's top-level vdevs into a root vdev.
2188 	 */
2189 	VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0);
2190 	VERIFY(nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT)
2191 	    == 0);
2192 	VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_ID, 0ULL) == 0);
2193 	VERIFY(nvlist_add_uint64(nvroot, ZPOOL_CONFIG_GUID, pgid) == 0);
2194 	VERIFY(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
2195 	    &nvtop, 1) == 0);
2196 
2197 	/*
2198 	 * Replace the existing vdev_tree with the new root vdev in
2199 	 * this pool's configuration (remove the old, add the new).
2200 	 */
2201 	VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, nvroot) == 0);
2202 	nvlist_free(nvroot);
2203 }
2204 
2205 /*
2206  * Get the root pool information from the root disk, then import the root pool
2207  * during the system boot up time.
2208  */
2209 extern nvlist_t *vdev_disk_read_rootlabel(char *);
2210 
2211 void
2212 spa_check_rootconf(char *devpath, char **bestdev, nvlist_t **bestconf,
2213     uint64_t *besttxg)
2214 {
2215 	nvlist_t *config;
2216 	uint64_t txg;
2217 
2218 	if ((config = vdev_disk_read_rootlabel(devpath)) == NULL)
2219 		return;
2220 
2221 	VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, &txg) == 0);
2222 
2223 	if (txg > *besttxg) {
2224 		*besttxg = txg;
2225 		if (*bestconf != NULL)
2226 			nvlist_free(*bestconf);
2227 		*bestconf = config;
2228 		*bestdev = devpath;
2229 	}
2230 }
2231 
2232 boolean_t
2233 spa_rootdev_validate(nvlist_t *nv)
2234 {
2235 	uint64_t ival;
2236 
2237 	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_OFFLINE, &ival) == 0 ||
2238 	    nvlist_lookup_uint64(nv, ZPOOL_CONFIG_FAULTED, &ival) == 0 ||
2239 	    nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DEGRADED, &ival) == 0 ||
2240 	    nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVED, &ival) == 0)
2241 		return (B_FALSE);
2242 
2243 	return (B_TRUE);
2244 }
2245 
2246 /*
2247  * Import a root pool.
2248  *
2249  * For x86. devpath_list will consist the physpath name of the vdev in a single
2250  * disk root pool or a list of physnames for the vdevs in a mirrored rootpool.
2251  * e.g.
2252  *	"/pci@1f,0/ide@d/disk@0,0:a /pci@1f,o/ide@d/disk@2,0:a"
2253  *
2254  * For Sparc, devpath_list consists the physpath name of the booting device
2255  * no matter the rootpool is a single device pool or a mirrored pool.
2256  * e.g.
2257  *	"/pci@1f,0/ide@d/disk@0,0:a"
2258  */
2259 int
2260 spa_import_rootpool(char *devpath_list)
2261 {
2262 	nvlist_t *conf = NULL;
2263 	char *dev = NULL;
2264 	char *pname;
2265 	int error;
2266 
2267 	/*
2268 	 * Get the vdev pathname and configuation from the most
2269 	 * recently updated vdev (highest txg).
2270 	 */
2271 	if (error = spa_get_rootconf(devpath_list, &dev, &conf))
2272 		goto msg_out;
2273 
2274 	/*
2275 	 * Add type "root" vdev to the config.
2276 	 */
2277 	spa_build_rootpool_config(conf);
2278 
2279 	VERIFY(nvlist_lookup_string(conf, ZPOOL_CONFIG_POOL_NAME, &pname) == 0);
2280 
2281 	/*
2282 	 * We specify 'allowfaulted' for this to be treated like spa_open()
2283 	 * instead of spa_import().  This prevents us from marking vdevs as
2284 	 * persistently unavailable, and generates FMA ereports as if it were a
2285 	 * pool open, not import.
2286 	 */
2287 	error = spa_import_common(pname, conf, NULL, B_TRUE, B_TRUE);
2288 	if (error == EEXIST)
2289 		error = 0;
2290 
2291 	nvlist_free(conf);
2292 	return (error);
2293 
2294 msg_out:
2295 	cmn_err(CE_NOTE, "\n\n"
2296 	    "  ***************************************************  \n"
2297 	    "  *  This device is not bootable!                   *  \n"
2298 	    "  *  It is either offlined or detached or faulted.  *  \n"
2299 	    "  *  Please try to boot from a different device.    *  \n"
2300 	    "  ***************************************************  \n\n");
2301 
2302 	return (error);
2303 }
2304 #endif
2305 
2306 /*
2307  * Import a non-root pool into the system.
2308  */
2309 int
2310 spa_import(const char *pool, nvlist_t *config, nvlist_t *props)
2311 {
2312 	return (spa_import_common(pool, config, props, B_FALSE, B_FALSE));
2313 }
2314 
2315 int
2316 spa_import_faulted(const char *pool, nvlist_t *config, nvlist_t *props)
2317 {
2318 	return (spa_import_common(pool, config, props, B_FALSE, B_TRUE));
2319 }
2320 
2321 
2322 /*
2323  * This (illegal) pool name is used when temporarily importing a spa_t in order
2324  * to get the vdev stats associated with the imported devices.
2325  */
2326 #define	TRYIMPORT_NAME	"$import"
2327 
2328 nvlist_t *
2329 spa_tryimport(nvlist_t *tryconfig)
2330 {
2331 	nvlist_t *config = NULL;
2332 	char *poolname;
2333 	spa_t *spa;
2334 	uint64_t state;
2335 
2336 	if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname))
2337 		return (NULL);
2338 
2339 	if (nvlist_lookup_uint64(tryconfig, ZPOOL_CONFIG_POOL_STATE, &state))
2340 		return (NULL);
2341 
2342 	/*
2343 	 * Create and initialize the spa structure.
2344 	 */
2345 	mutex_enter(&spa_namespace_lock);
2346 	spa = spa_add(TRYIMPORT_NAME, NULL);
2347 	spa_activate(spa);
2348 
2349 	/*
2350 	 * Pass off the heavy lifting to spa_load().
2351 	 * Pass TRUE for mosconfig because the user-supplied config
2352 	 * is actually the one to trust when doing an import.
2353 	 */
2354 	(void) spa_load(spa, tryconfig, SPA_LOAD_TRYIMPORT, B_TRUE);
2355 
2356 	/*
2357 	 * If 'tryconfig' was at least parsable, return the current config.
2358 	 */
2359 	if (spa->spa_root_vdev != NULL) {
2360 		spa_config_enter(spa, RW_READER, FTAG);
2361 		config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
2362 		spa_config_exit(spa, FTAG);
2363 		VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME,
2364 		    poolname) == 0);
2365 		VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE,
2366 		    state) == 0);
2367 		VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_TIMESTAMP,
2368 		    spa->spa_uberblock.ub_timestamp) == 0);
2369 
2370 		/*
2371 		 * If the bootfs property exists on this pool then we
2372 		 * copy it out so that external consumers can tell which
2373 		 * pools are bootable.
2374 		 */
2375 		if (spa->spa_bootfs) {
2376 			char *tmpname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2377 
2378 			/*
2379 			 * We have to play games with the name since the
2380 			 * pool was opened as TRYIMPORT_NAME.
2381 			 */
2382 			if (dsl_dsobj_to_dsname(spa->spa_name,
2383 			    spa->spa_bootfs, tmpname) == 0) {
2384 				char *cp;
2385 				char *dsname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2386 
2387 				cp = strchr(tmpname, '/');
2388 				if (cp == NULL) {
2389 					(void) strlcpy(dsname, tmpname,
2390 					    MAXPATHLEN);
2391 				} else {
2392 					(void) snprintf(dsname, MAXPATHLEN,
2393 					    "%s/%s", poolname, ++cp);
2394 				}
2395 				VERIFY(nvlist_add_string(config,
2396 				    ZPOOL_CONFIG_BOOTFS, dsname) == 0);
2397 				kmem_free(dsname, MAXPATHLEN);
2398 			}
2399 			kmem_free(tmpname, MAXPATHLEN);
2400 		}
2401 
2402 		/*
2403 		 * Add the list of hot spares and level 2 cache devices.
2404 		 */
2405 		spa_add_spares(spa, config);
2406 		spa_add_l2cache(spa, config);
2407 	}
2408 
2409 	spa_unload(spa);
2410 	spa_deactivate(spa);
2411 	spa_remove(spa);
2412 	mutex_exit(&spa_namespace_lock);
2413 
2414 	return (config);
2415 }
2416 
2417 /*
2418  * Pool export/destroy
2419  *
2420  * The act of destroying or exporting a pool is very simple.  We make sure there
2421  * is no more pending I/O and any references to the pool are gone.  Then, we
2422  * update the pool state and sync all the labels to disk, removing the
2423  * configuration from the cache afterwards.
2424  */
2425 static int
2426 spa_export_common(char *pool, int new_state, nvlist_t **oldconfig)
2427 {
2428 	spa_t *spa;
2429 
2430 	if (oldconfig)
2431 		*oldconfig = NULL;
2432 
2433 	if (!(spa_mode & FWRITE))
2434 		return (EROFS);
2435 
2436 	mutex_enter(&spa_namespace_lock);
2437 	if ((spa = spa_lookup(pool)) == NULL) {
2438 		mutex_exit(&spa_namespace_lock);
2439 		return (ENOENT);
2440 	}
2441 
2442 	/*
2443 	 * Put a hold on the pool, drop the namespace lock, stop async tasks,
2444 	 * reacquire the namespace lock, and see if we can export.
2445 	 */
2446 	spa_open_ref(spa, FTAG);
2447 	mutex_exit(&spa_namespace_lock);
2448 	spa_async_suspend(spa);
2449 	mutex_enter(&spa_namespace_lock);
2450 	spa_close(spa, FTAG);
2451 
2452 	/*
2453 	 * The pool will be in core if it's openable,
2454 	 * in which case we can modify its state.
2455 	 */
2456 	if (spa->spa_state != POOL_STATE_UNINITIALIZED && spa->spa_sync_on) {
2457 		/*
2458 		 * Objsets may be open only because they're dirty, so we
2459 		 * have to force it to sync before checking spa_refcnt.
2460 		 */
2461 		txg_wait_synced(spa->spa_dsl_pool, 0);
2462 
2463 		/*
2464 		 * A pool cannot be exported or destroyed if there are active
2465 		 * references.  If we are resetting a pool, allow references by
2466 		 * fault injection handlers.
2467 		 */
2468 		if (!spa_refcount_zero(spa) ||
2469 		    (spa->spa_inject_ref != 0 &&
2470 		    new_state != POOL_STATE_UNINITIALIZED)) {
2471 			spa_async_resume(spa);
2472 			mutex_exit(&spa_namespace_lock);
2473 			return (EBUSY);
2474 		}
2475 
2476 		/*
2477 		 * We want this to be reflected on every label,
2478 		 * so mark them all dirty.  spa_unload() will do the
2479 		 * final sync that pushes these changes out.
2480 		 */
2481 		if (new_state != POOL_STATE_UNINITIALIZED) {
2482 			spa_config_enter(spa, RW_WRITER, FTAG);
2483 			spa->spa_state = new_state;
2484 			spa->spa_final_txg = spa_last_synced_txg(spa) + 1;
2485 			vdev_config_dirty(spa->spa_root_vdev);
2486 			spa_config_exit(spa, FTAG);
2487 		}
2488 	}
2489 
2490 	spa_event_notify(spa, NULL, ESC_ZFS_POOL_DESTROY);
2491 
2492 	if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
2493 		spa_unload(spa);
2494 		spa_deactivate(spa);
2495 	}
2496 
2497 	if (oldconfig && spa->spa_config)
2498 		VERIFY(nvlist_dup(spa->spa_config, oldconfig, 0) == 0);
2499 
2500 	if (new_state != POOL_STATE_UNINITIALIZED) {
2501 		spa_config_sync(spa, B_TRUE, B_TRUE);
2502 		spa_remove(spa);
2503 	}
2504 	mutex_exit(&spa_namespace_lock);
2505 
2506 	return (0);
2507 }
2508 
2509 /*
2510  * Destroy a storage pool.
2511  */
2512 int
2513 spa_destroy(char *pool)
2514 {
2515 	return (spa_export_common(pool, POOL_STATE_DESTROYED, NULL));
2516 }
2517 
2518 /*
2519  * Export a storage pool.
2520  */
2521 int
2522 spa_export(char *pool, nvlist_t **oldconfig)
2523 {
2524 	return (spa_export_common(pool, POOL_STATE_EXPORTED, oldconfig));
2525 }
2526 
2527 /*
2528  * Similar to spa_export(), this unloads the spa_t without actually removing it
2529  * from the namespace in any way.
2530  */
2531 int
2532 spa_reset(char *pool)
2533 {
2534 	return (spa_export_common(pool, POOL_STATE_UNINITIALIZED, NULL));
2535 }
2536 
2537 /*
2538  * ==========================================================================
2539  * Device manipulation
2540  * ==========================================================================
2541  */
2542 
2543 /*
2544  * Add a device to a storage pool.
2545  */
2546 int
2547 spa_vdev_add(spa_t *spa, nvlist_t *nvroot)
2548 {
2549 	uint64_t txg;
2550 	int c, error;
2551 	vdev_t *rvd = spa->spa_root_vdev;
2552 	vdev_t *vd, *tvd;
2553 	nvlist_t **spares, **l2cache;
2554 	uint_t nspares, nl2cache;
2555 
2556 	txg = spa_vdev_enter(spa);
2557 
2558 	if ((error = spa_config_parse(spa, &vd, nvroot, NULL, 0,
2559 	    VDEV_ALLOC_ADD)) != 0)
2560 		return (spa_vdev_exit(spa, NULL, txg, error));
2561 
2562 	spa->spa_pending_vdev = vd;
2563 
2564 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, &spares,
2565 	    &nspares) != 0)
2566 		nspares = 0;
2567 
2568 	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, &l2cache,
2569 	    &nl2cache) != 0)
2570 		nl2cache = 0;
2571 
2572 	if (vd->vdev_children == 0 && nspares == 0 && nl2cache == 0) {
2573 		spa->spa_pending_vdev = NULL;
2574 		return (spa_vdev_exit(spa, vd, txg, EINVAL));
2575 	}
2576 
2577 	if (vd->vdev_children != 0) {
2578 		if ((error = vdev_create(vd, txg, B_FALSE)) != 0) {
2579 			spa->spa_pending_vdev = NULL;
2580 			return (spa_vdev_exit(spa, vd, txg, error));
2581 		}
2582 	}
2583 
2584 	/*
2585 	 * We must validate the spares and l2cache devices after checking the
2586 	 * children.  Otherwise, vdev_inuse() will blindly overwrite the spare.
2587 	 */
2588 	if ((error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) != 0) {
2589 		spa->spa_pending_vdev = NULL;
2590 		return (spa_vdev_exit(spa, vd, txg, error));
2591 	}
2592 
2593 	spa->spa_pending_vdev = NULL;
2594 
2595 	/*
2596 	 * Transfer each new top-level vdev from vd to rvd.
2597 	 */
2598 	for (c = 0; c < vd->vdev_children; c++) {
2599 		tvd = vd->vdev_child[c];
2600 		vdev_remove_child(vd, tvd);
2601 		tvd->vdev_id = rvd->vdev_children;
2602 		vdev_add_child(rvd, tvd);
2603 		vdev_config_dirty(tvd);
2604 	}
2605 
2606 	if (nspares != 0) {
2607 		spa_set_aux_vdevs(&spa->spa_spares, spares, nspares,
2608 		    ZPOOL_CONFIG_SPARES);
2609 		spa_load_spares(spa);
2610 		spa->spa_spares.sav_sync = B_TRUE;
2611 	}
2612 
2613 	if (nl2cache != 0) {
2614 		spa_set_aux_vdevs(&spa->spa_l2cache, l2cache, nl2cache,
2615 		    ZPOOL_CONFIG_L2CACHE);
2616 		spa_load_l2cache(spa);
2617 		spa->spa_l2cache.sav_sync = B_TRUE;
2618 	}
2619 
2620 	/*
2621 	 * We have to be careful when adding new vdevs to an existing pool.
2622 	 * If other threads start allocating from these vdevs before we
2623 	 * sync the config cache, and we lose power, then upon reboot we may
2624 	 * fail to open the pool because there are DVAs that the config cache
2625 	 * can't translate.  Therefore, we first add the vdevs without
2626 	 * initializing metaslabs; sync the config cache (via spa_vdev_exit());
2627 	 * and then let spa_config_update() initialize the new metaslabs.
2628 	 *
2629 	 * spa_load() checks for added-but-not-initialized vdevs, so that
2630 	 * if we lose power at any point in this sequence, the remaining
2631 	 * steps will be completed the next time we load the pool.
2632 	 */
2633 	(void) spa_vdev_exit(spa, vd, txg, 0);
2634 
2635 	mutex_enter(&spa_namespace_lock);
2636 	spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
2637 	mutex_exit(&spa_namespace_lock);
2638 
2639 	return (0);
2640 }
2641 
2642 /*
2643  * Attach a device to a mirror.  The arguments are the path to any device
2644  * in the mirror, and the nvroot for the new device.  If the path specifies
2645  * a device that is not mirrored, we automatically insert the mirror vdev.
2646  *
2647  * If 'replacing' is specified, the new device is intended to replace the
2648  * existing device; in this case the two devices are made into their own
2649  * mirror using the 'replacing' vdev, which is functionally identical to
2650  * the mirror vdev (it actually reuses all the same ops) but has a few
2651  * extra rules: you can't attach to it after it's been created, and upon
2652  * completion of resilvering, the first disk (the one being replaced)
2653  * is automatically detached.
2654  */
2655 int
2656 spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot, int replacing)
2657 {
2658 	uint64_t txg, open_txg;
2659 	int error;
2660 	vdev_t *rvd = spa->spa_root_vdev;
2661 	vdev_t *oldvd, *newvd, *newrootvd, *pvd, *tvd;
2662 	vdev_ops_t *pvops;
2663 	int is_log;
2664 
2665 	txg = spa_vdev_enter(spa);
2666 
2667 	oldvd = spa_lookup_by_guid(spa, guid, B_FALSE);
2668 
2669 	if (oldvd == NULL)
2670 		return (spa_vdev_exit(spa, NULL, txg, ENODEV));
2671 
2672 	if (!oldvd->vdev_ops->vdev_op_leaf)
2673 		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
2674 
2675 	pvd = oldvd->vdev_parent;
2676 
2677 	if ((error = spa_config_parse(spa, &newrootvd, nvroot, NULL, 0,
2678 	    VDEV_ALLOC_ADD)) != 0)
2679 		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
2680 
2681 	if (newrootvd->vdev_children != 1)
2682 		return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));
2683 
2684 	newvd = newrootvd->vdev_child[0];
2685 
2686 	if (!newvd->vdev_ops->vdev_op_leaf)
2687 		return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));
2688 
2689 	if ((error = vdev_create(newrootvd, txg, replacing)) != 0)
2690 		return (spa_vdev_exit(spa, newrootvd, txg, error));
2691 
2692 	/*
2693 	 * Spares can't replace logs
2694 	 */
2695 	is_log = oldvd->vdev_islog;
2696 	if (is_log && newvd->vdev_isspare)
2697 		return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2698 
2699 	if (!replacing) {
2700 		/*
2701 		 * For attach, the only allowable parent is a mirror or the root
2702 		 * vdev.
2703 		 */
2704 		if (pvd->vdev_ops != &vdev_mirror_ops &&
2705 		    pvd->vdev_ops != &vdev_root_ops)
2706 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2707 
2708 		pvops = &vdev_mirror_ops;
2709 	} else {
2710 		/*
2711 		 * Active hot spares can only be replaced by inactive hot
2712 		 * spares.
2713 		 */
2714 		if (pvd->vdev_ops == &vdev_spare_ops &&
2715 		    pvd->vdev_child[1] == oldvd &&
2716 		    !spa_has_spare(spa, newvd->vdev_guid))
2717 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2718 
2719 		/*
2720 		 * If the source is a hot spare, and the parent isn't already a
2721 		 * spare, then we want to create a new hot spare.  Otherwise, we
2722 		 * want to create a replacing vdev.  The user is not allowed to
2723 		 * attach to a spared vdev child unless the 'isspare' state is
2724 		 * the same (spare replaces spare, non-spare replaces
2725 		 * non-spare).
2726 		 */
2727 		if (pvd->vdev_ops == &vdev_replacing_ops)
2728 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2729 		else if (pvd->vdev_ops == &vdev_spare_ops &&
2730 		    newvd->vdev_isspare != oldvd->vdev_isspare)
2731 			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2732 		else if (pvd->vdev_ops != &vdev_spare_ops &&
2733 		    newvd->vdev_isspare)
2734 			pvops = &vdev_spare_ops;
2735 		else
2736 			pvops = &vdev_replacing_ops;
2737 	}
2738 
2739 	/*
2740 	 * Compare the new device size with the replaceable/attachable
2741 	 * device size.
2742 	 */
2743 	if (newvd->vdev_psize < vdev_get_rsize(oldvd))
2744 		return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW));
2745 
2746 	/*
2747 	 * The new device cannot have a higher alignment requirement
2748 	 * than the top-level vdev.
2749 	 */
2750 	if (newvd->vdev_ashift > oldvd->vdev_top->vdev_ashift)
2751 		return (spa_vdev_exit(spa, newrootvd, txg, EDOM));
2752 
2753 	/*
2754 	 * If this is an in-place replacement, update oldvd's path and devid
2755 	 * to make it distinguishable from newvd, and unopenable from now on.
2756 	 */
2757 	if (strcmp(oldvd->vdev_path, newvd->vdev_path) == 0) {
2758 		spa_strfree(oldvd->vdev_path);
2759 		oldvd->vdev_path = kmem_alloc(strlen(newvd->vdev_path) + 5,
2760 		    KM_SLEEP);
2761 		(void) sprintf(oldvd->vdev_path, "%s/%s",
2762 		    newvd->vdev_path, "old");
2763 		if (oldvd->vdev_devid != NULL) {
2764 			spa_strfree(oldvd->vdev_devid);
2765 			oldvd->vdev_devid = NULL;
2766 		}
2767 	}
2768 
2769 	/*
2770 	 * If the parent is not a mirror, or if we're replacing, insert the new
2771 	 * mirror/replacing/spare vdev above oldvd.
2772 	 */
2773 	if (pvd->vdev_ops != pvops)
2774 		pvd = vdev_add_parent(oldvd, pvops);
2775 
2776 	ASSERT(pvd->vdev_top->vdev_parent == rvd);
2777 	ASSERT(pvd->vdev_ops == pvops);
2778 	ASSERT(oldvd->vdev_parent == pvd);
2779 
2780 	/*
2781 	 * Extract the new device from its root and add it to pvd.
2782 	 */
2783 	vdev_remove_child(newrootvd, newvd);
2784 	newvd->vdev_id = pvd->vdev_children;
2785 	vdev_add_child(pvd, newvd);
2786 
2787 	/*
2788 	 * If newvd is smaller than oldvd, but larger than its rsize,
2789 	 * the addition of newvd may have decreased our parent's asize.
2790 	 */
2791 	pvd->vdev_asize = MIN(pvd->vdev_asize, newvd->vdev_asize);
2792 
2793 	tvd = newvd->vdev_top;
2794 	ASSERT(pvd->vdev_top == tvd);
2795 	ASSERT(tvd->vdev_parent == rvd);
2796 
2797 	vdev_config_dirty(tvd);
2798 
2799 	/*
2800 	 * Set newvd's DTL to [TXG_INITIAL, open_txg].  It will propagate
2801 	 * upward when spa_vdev_exit() calls vdev_dtl_reassess().
2802 	 */
2803 	open_txg = txg + TXG_CONCURRENT_STATES - 1;
2804 
2805 	mutex_enter(&newvd->vdev_dtl_lock);
2806 	space_map_add(&newvd->vdev_dtl_map, TXG_INITIAL,
2807 	    open_txg - TXG_INITIAL + 1);
2808 	mutex_exit(&newvd->vdev_dtl_lock);
2809 
2810 	if (newvd->vdev_isspare)
2811 		spa_spare_activate(newvd);
2812 
2813 	/*
2814 	 * Mark newvd's DTL dirty in this txg.
2815 	 */
2816 	vdev_dirty(tvd, VDD_DTL, newvd, txg);
2817 
2818 	(void) spa_vdev_exit(spa, newrootvd, open_txg, 0);
2819 
2820 	/*
2821 	 * Kick off a resilver to update newvd.
2822 	 */
2823 	VERIFY3U(spa_scrub(spa, POOL_SCRUB_RESILVER), ==, 0);
2824 
2825 	return (0);
2826 }
2827 
2828 /*
2829  * Detach a device from a mirror or replacing vdev.
2830  * If 'replace_done' is specified, only detach if the parent
2831  * is a replacing vdev.
2832  */
2833 int
2834 spa_vdev_detach(spa_t *spa, uint64_t guid, int replace_done)
2835 {
2836 	uint64_t txg;
2837 	int c, t, error;
2838 	vdev_t *rvd = spa->spa_root_vdev;
2839 	vdev_t *vd, *pvd, *cvd, *tvd;
2840 	boolean_t unspare = B_FALSE;
2841 	uint64_t unspare_guid;
2842 	size_t len;
2843 
2844 	txg = spa_vdev_enter(spa);
2845 
2846 	vd = spa_lookup_by_guid(spa, guid, B_FALSE);
2847 
2848 	if (vd == NULL)
2849 		return (spa_vdev_exit(spa, NULL, txg, ENODEV));
2850 
2851 	if (!vd->vdev_ops->vdev_op_leaf)
2852 		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
2853 
2854 	pvd = vd->vdev_parent;
2855 
2856 	/*
2857 	 * If replace_done is specified, only remove this device if it's
2858 	 * the first child of a replacing vdev.  For the 'spare' vdev, either
2859 	 * disk can be removed.
2860 	 */
2861 	if (replace_done) {
2862 		if (pvd->vdev_ops == &vdev_replacing_ops) {
2863 			if (vd->vdev_id != 0)
2864 				return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
2865 		} else if (pvd->vdev_ops != &vdev_spare_ops) {
2866 			return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
2867 		}
2868 	}
2869 
2870 	ASSERT(pvd->vdev_ops != &vdev_spare_ops ||
2871 	    spa_version(spa) >= SPA_VERSION_SPARES);
2872 
2873 	/*
2874 	 * Only mirror, replacing, and spare vdevs support detach.
2875 	 */
2876 	if (pvd->vdev_ops != &vdev_replacing_ops &&
2877 	    pvd->vdev_ops != &vdev_mirror_ops &&
2878 	    pvd->vdev_ops != &vdev_spare_ops)
2879 		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
2880 
2881 	/*
2882 	 * If there's only one replica, you can't detach it.
2883 	 */
2884 	if (pvd->vdev_children <= 1)
2885 		return (spa_vdev_exit(spa, NULL, txg, EBUSY));
2886 
2887 	/*
2888 	 * If all siblings have non-empty DTLs, this device may have the only
2889 	 * valid copy of the data, which means we cannot safely detach it.
2890 	 *
2891 	 * XXX -- as in the vdev_offline() case, we really want a more
2892 	 * precise DTL check.
2893 	 */
2894 	for (c = 0; c < pvd->vdev_children; c++) {
2895 		uint64_t dirty;
2896 
2897 		cvd = pvd->vdev_child[c];
2898 		if (cvd == vd)
2899 			continue;
2900 		if (vdev_is_dead(cvd))
2901 			continue;
2902 		mutex_enter(&cvd->vdev_dtl_lock);
2903 		dirty = cvd->vdev_dtl_map.sm_space |
2904 		    cvd->vdev_dtl_scrub.sm_space;
2905 		mutex_exit(&cvd->vdev_dtl_lock);
2906 		if (!dirty)
2907 			break;
2908 	}
2909 
2910 	/*
2911 	 * If we are a replacing or spare vdev, then we can always detach the
2912 	 * latter child, as that is how one cancels the operation.
2913 	 */
2914 	if ((pvd->vdev_ops == &vdev_mirror_ops || vd->vdev_id != 1) &&
2915 	    c == pvd->vdev_children)
2916 		return (spa_vdev_exit(spa, NULL, txg, EBUSY));
2917 
2918 	/*
2919 	 * If we are detaching the second disk from a replacing vdev, then
2920 	 * check to see if we changed the original vdev's path to have "/old"
2921 	 * at the end in spa_vdev_attach().  If so, undo that change now.
2922 	 */
2923 	if (pvd->vdev_ops == &vdev_replacing_ops && vd->vdev_id == 1 &&
2924 	    pvd->vdev_child[0]->vdev_path != NULL &&
2925 	    pvd->vdev_child[1]->vdev_path != NULL) {
2926 		ASSERT(pvd->vdev_child[1] == vd);
2927 		cvd = pvd->vdev_child[0];
2928 		len = strlen(vd->vdev_path);
2929 		if (strncmp(cvd->vdev_path, vd->vdev_path, len) == 0 &&
2930 		    strcmp(cvd->vdev_path + len, "/old") == 0) {
2931 			spa_strfree(cvd->vdev_path);
2932 			cvd->vdev_path = spa_strdup(vd->vdev_path);
2933 		}
2934 	}
2935 
2936 	/*
2937 	 * If we are detaching the original disk from a spare, then it implies
2938 	 * that the spare should become a real disk, and be removed from the
2939 	 * active spare list for the pool.
2940 	 */
2941 	if (pvd->vdev_ops == &vdev_spare_ops &&
2942 	    vd->vdev_id == 0)
2943 		unspare = B_TRUE;
2944 
2945 	/*
2946 	 * Erase the disk labels so the disk can be used for other things.
2947 	 * This must be done after all other error cases are handled,
2948 	 * but before we disembowel vd (so we can still do I/O to it).
2949 	 * But if we can't do it, don't treat the error as fatal --
2950 	 * it may be that the unwritability of the disk is the reason
2951 	 * it's being detached!
2952 	 */
2953 	error = vdev_label_init(vd, 0, VDEV_LABEL_REMOVE);
2954 
2955 	/*
2956 	 * Remove vd from its parent and compact the parent's children.
2957 	 */
2958 	vdev_remove_child(pvd, vd);
2959 	vdev_compact_children(pvd);
2960 
2961 	/*
2962 	 * Remember one of the remaining children so we can get tvd below.
2963 	 */
2964 	cvd = pvd->vdev_child[0];
2965 
2966 	/*
2967 	 * If we need to remove the remaining child from the list of hot spares,
2968 	 * do it now, marking the vdev as no longer a spare in the process.  We
2969 	 * must do this before vdev_remove_parent(), because that can change the
2970 	 * GUID if it creates a new toplevel GUID.
2971 	 */
2972 	if (unspare) {
2973 		ASSERT(cvd->vdev_isspare);
2974 		spa_spare_remove(cvd);
2975 		unspare_guid = cvd->vdev_guid;
2976 	}
2977 
2978 	/*
2979 	 * If the parent mirror/replacing vdev only has one child,
2980 	 * the parent is no longer needed.  Remove it from the tree.
2981 	 */
2982 	if (pvd->vdev_children == 1)
2983 		vdev_remove_parent(cvd);
2984 
2985 	/*
2986 	 * We don't set tvd until now because the parent we just removed
2987 	 * may have been the previous top-level vdev.
2988 	 */
2989 	tvd = cvd->vdev_top;
2990 	ASSERT(tvd->vdev_parent == rvd);
2991 
2992 	/*
2993 	 * Reevaluate the parent vdev state.
2994 	 */
2995 	vdev_propagate_state(cvd);
2996 
2997 	/*
2998 	 * If the device we just detached was smaller than the others, it may be
2999 	 * possible to add metaslabs (i.e. grow the pool).  vdev_metaslab_init()
3000 	 * can't fail because the existing metaslabs are already in core, so
3001 	 * there's nothing to read from disk.
3002 	 */
3003 	VERIFY(vdev_metaslab_init(tvd, txg) == 0);
3004 
3005 	vdev_config_dirty(tvd);
3006 
3007 	/*
3008 	 * Mark vd's DTL as dirty in this txg.  vdev_dtl_sync() will see that
3009 	 * vd->vdev_detached is set and free vd's DTL object in syncing context.
3010 	 * But first make sure we're not on any *other* txg's DTL list, to
3011 	 * prevent vd from being accessed after it's freed.
3012 	 */
3013 	for (t = 0; t < TXG_SIZE; t++)
3014 		(void) txg_list_remove_this(&tvd->vdev_dtl_list, vd, t);
3015 	vd->vdev_detached = B_TRUE;
3016 	vdev_dirty(tvd, VDD_DTL, vd, txg);
3017 
3018 	spa_event_notify(spa, vd, ESC_ZFS_VDEV_REMOVE);
3019 
3020 	error = spa_vdev_exit(spa, vd, txg, 0);
3021 
3022 	/*
3023 	 * If this was the removal of the original device in a hot spare vdev,
3024 	 * then we want to go through and remove the device from the hot spare
3025 	 * list of every other pool.
3026 	 */
3027 	if (unspare) {
3028 		spa = NULL;
3029 		mutex_enter(&spa_namespace_lock);
3030 		while ((spa = spa_next(spa)) != NULL) {
3031 			if (spa->spa_state != POOL_STATE_ACTIVE)
3032 				continue;
3033 
3034 			(void) spa_vdev_remove(spa, unspare_guid, B_TRUE);
3035 		}
3036 		mutex_exit(&spa_namespace_lock);
3037 	}
3038 
3039 	return (error);
3040 }
3041 
3042 /*
3043  * Remove a spares vdev from the nvlist config.
3044  */
3045 static int
3046 spa_remove_spares(spa_aux_vdev_t *sav, uint64_t guid, boolean_t unspare,
3047     nvlist_t **spares, int nspares, vdev_t *vd)
3048 {
3049 	nvlist_t *nv, **newspares;
3050 	int i, j;
3051 
3052 	nv = NULL;
3053 	for (i = 0; i < nspares; i++) {
3054 		uint64_t theguid;
3055 
3056 		VERIFY(nvlist_lookup_uint64(spares[i],
3057 		    ZPOOL_CONFIG_GUID, &theguid) == 0);
3058 		if (theguid == guid) {
3059 			nv = spares[i];
3060 			break;
3061 		}
3062 	}
3063 
3064 	/*
3065 	 * Only remove the hot spare if it's not currently in use in this pool.
3066 	 */
3067 	if (nv == NULL && vd == NULL)
3068 		return (ENOENT);
3069 
3070 	if (nv == NULL && vd != NULL)
3071 		return (ENOTSUP);
3072 
3073 	if (!unspare && nv != NULL && vd != NULL)
3074 		return (EBUSY);
3075 
3076 	if (nspares == 1) {
3077 		newspares = NULL;
3078 	} else {
3079 		newspares = kmem_alloc((nspares - 1) * sizeof (void *),
3080 		    KM_SLEEP);
3081 		for (i = 0, j = 0; i < nspares; i++) {
3082 			if (spares[i] != nv)
3083 				VERIFY(nvlist_dup(spares[i],
3084 				    &newspares[j++], KM_SLEEP) == 0);
3085 		}
3086 	}
3087 
3088 	VERIFY(nvlist_remove(sav->sav_config, ZPOOL_CONFIG_SPARES,
3089 	    DATA_TYPE_NVLIST_ARRAY) == 0);
3090 	VERIFY(nvlist_add_nvlist_array(sav->sav_config,
3091 	    ZPOOL_CONFIG_SPARES, newspares, nspares - 1) == 0);
3092 	for (i = 0; i < nspares - 1; i++)
3093 		nvlist_free(newspares[i]);
3094 	kmem_free(newspares, (nspares - 1) * sizeof (void *));
3095 
3096 	return (0);
3097 }
3098 
3099 /*
3100  * Remove an l2cache vdev from the nvlist config.
3101  */
3102 static int
3103 spa_remove_l2cache(spa_aux_vdev_t *sav, uint64_t guid, nvlist_t **l2cache,
3104     int nl2cache, vdev_t *vd)
3105 {
3106 	nvlist_t *nv, **newl2cache;
3107 	int i, j;
3108 
3109 	nv = NULL;
3110 	for (i = 0; i < nl2cache; i++) {
3111 		uint64_t theguid;
3112 
3113 		VERIFY(nvlist_lookup_uint64(l2cache[i],
3114 		    ZPOOL_CONFIG_GUID, &theguid) == 0);
3115 		if (theguid == guid) {
3116 			nv = l2cache[i];
3117 			break;
3118 		}
3119 	}
3120 
3121 	if (vd == NULL) {
3122 		for (i = 0; i < nl2cache; i++) {
3123 			if (sav->sav_vdevs[i]->vdev_guid == guid) {
3124 				vd = sav->sav_vdevs[i];
3125 				break;
3126 			}
3127 		}
3128 	}
3129 
3130 	if (nv == NULL && vd == NULL)
3131 		return (ENOENT);
3132 
3133 	if (nv == NULL && vd != NULL)
3134 		return (ENOTSUP);
3135 
3136 	if (nl2cache == 1) {
3137 		newl2cache = NULL;
3138 	} else {
3139 		newl2cache = kmem_alloc((nl2cache - 1) * sizeof (void *),
3140 		    KM_SLEEP);
3141 		for (i = 0, j = 0; i < nl2cache; i++) {
3142 			if (l2cache[i] != nv)
3143 				VERIFY(nvlist_dup(l2cache[i],
3144 				    &newl2cache[j++], KM_SLEEP) == 0);
3145 		}
3146 	}
3147 
3148 	VERIFY(nvlist_remove(sav->sav_config, ZPOOL_CONFIG_L2CACHE,
3149 	    DATA_TYPE_NVLIST_ARRAY) == 0);
3150 	VERIFY(nvlist_add_nvlist_array(sav->sav_config,
3151 	    ZPOOL_CONFIG_L2CACHE, newl2cache, nl2cache - 1) == 0);
3152 	for (i = 0; i < nl2cache - 1; i++)
3153 		nvlist_free(newl2cache[i]);
3154 	kmem_free(newl2cache, (nl2cache - 1) * sizeof (void *));
3155 
3156 	return (0);
3157 }
3158 
3159 /*
3160  * Remove a device from the pool.  Currently, this supports removing only hot
3161  * spares and level 2 ARC devices.
3162  */
3163 int
3164 spa_vdev_remove(spa_t *spa, uint64_t guid, boolean_t unspare)
3165 {
3166 	vdev_t *vd;
3167 	nvlist_t **spares, **l2cache;
3168 	uint_t nspares, nl2cache;
3169 	int error = 0;
3170 
3171 	spa_config_enter(spa, RW_WRITER, FTAG);
3172 
3173 	vd = spa_lookup_by_guid(spa, guid, B_FALSE);
3174 
3175 	if (spa->spa_spares.sav_vdevs != NULL &&
3176 	    nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
3177 	    ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0) {
3178 		if ((error = spa_remove_spares(&spa->spa_spares, guid, unspare,
3179 		    spares, nspares, vd)) != 0)
3180 			goto out;
3181 		spa_load_spares(spa);
3182 		spa->spa_spares.sav_sync = B_TRUE;
3183 		goto out;
3184 	}
3185 
3186 	if (spa->spa_l2cache.sav_vdevs != NULL &&
3187 	    nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config,
3188 	    ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0) {
3189 		if ((error = spa_remove_l2cache(&spa->spa_l2cache, guid,
3190 		    l2cache, nl2cache, vd)) != 0)
3191 			goto out;
3192 		spa_load_l2cache(spa);
3193 		spa->spa_l2cache.sav_sync = B_TRUE;
3194 	}
3195 
3196 out:
3197 	spa_config_exit(spa, FTAG);
3198 	return (error);
3199 }
3200 
3201 /*
3202  * Find any device that's done replacing, or a vdev marked 'unspare' that's
3203  * current spared, so we can detach it.
3204  */
3205 static vdev_t *
3206 spa_vdev_resilver_done_hunt(vdev_t *vd)
3207 {
3208 	vdev_t *newvd, *oldvd;
3209 	int c;
3210 
3211 	for (c = 0; c < vd->vdev_children; c++) {
3212 		oldvd = spa_vdev_resilver_done_hunt(vd->vdev_child[c]);
3213 		if (oldvd != NULL)
3214 			return (oldvd);
3215 	}
3216 
3217 	/*
3218 	 * Check for a completed replacement.
3219 	 */
3220 	if (vd->vdev_ops == &vdev_replacing_ops && vd->vdev_children == 2) {
3221 		oldvd = vd->vdev_child[0];
3222 		newvd = vd->vdev_child[1];
3223 
3224 		mutex_enter(&newvd->vdev_dtl_lock);
3225 		if (newvd->vdev_dtl_map.sm_space == 0 &&
3226 		    newvd->vdev_dtl_scrub.sm_space == 0) {
3227 			mutex_exit(&newvd->vdev_dtl_lock);
3228 			return (oldvd);
3229 		}
3230 		mutex_exit(&newvd->vdev_dtl_lock);
3231 	}
3232 
3233 	/*
3234 	 * Check for a completed resilver with the 'unspare' flag set.
3235 	 */
3236 	if (vd->vdev_ops == &vdev_spare_ops && vd->vdev_children == 2) {
3237 		newvd = vd->vdev_child[0];
3238 		oldvd = vd->vdev_child[1];
3239 
3240 		mutex_enter(&newvd->vdev_dtl_lock);
3241 		if (newvd->vdev_unspare &&
3242 		    newvd->vdev_dtl_map.sm_space == 0 &&
3243 		    newvd->vdev_dtl_scrub.sm_space == 0) {
3244 			newvd->vdev_unspare = 0;
3245 			mutex_exit(&newvd->vdev_dtl_lock);
3246 			return (oldvd);
3247 		}
3248 		mutex_exit(&newvd->vdev_dtl_lock);
3249 	}
3250 
3251 	return (NULL);
3252 }
3253 
3254 static void
3255 spa_vdev_resilver_done(spa_t *spa)
3256 {
3257 	vdev_t *vd;
3258 	vdev_t *pvd;
3259 	uint64_t guid;
3260 	uint64_t pguid = 0;
3261 
3262 	spa_config_enter(spa, RW_READER, FTAG);
3263 
3264 	while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) {
3265 		guid = vd->vdev_guid;
3266 		/*
3267 		 * If we have just finished replacing a hot spared device, then
3268 		 * we need to detach the parent's first child (the original hot
3269 		 * spare) as well.
3270 		 */
3271 		pvd = vd->vdev_parent;
3272 		if (pvd->vdev_parent->vdev_ops == &vdev_spare_ops &&
3273 		    pvd->vdev_id == 0) {
3274 			ASSERT(pvd->vdev_ops == &vdev_replacing_ops);
3275 			ASSERT(pvd->vdev_parent->vdev_children == 2);
3276 			pguid = pvd->vdev_parent->vdev_child[1]->vdev_guid;
3277 		}
3278 		spa_config_exit(spa, FTAG);
3279 		if (spa_vdev_detach(spa, guid, B_TRUE) != 0)
3280 			return;
3281 		if (pguid != 0 && spa_vdev_detach(spa, pguid, B_TRUE) != 0)
3282 			return;
3283 		spa_config_enter(spa, RW_READER, FTAG);
3284 	}
3285 
3286 	spa_config_exit(spa, FTAG);
3287 }
3288 
3289 /*
3290  * Update the stored path for this vdev.  Dirty the vdev configuration, relying
3291  * on spa_vdev_enter/exit() to synchronize the labels and cache.
3292  */
3293 int
3294 spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath)
3295 {
3296 	vdev_t *vd;
3297 	uint64_t txg;
3298 
3299 	txg = spa_vdev_enter(spa);
3300 
3301 	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL) {
3302 		/*
3303 		 * Determine if this is a reference to a hot spare device.  If
3304 		 * it is, update the path manually as there is no associated
3305 		 * vdev_t that can be synced to disk.
3306 		 */
3307 		nvlist_t **spares;
3308 		uint_t i, nspares;
3309 
3310 		if (spa->spa_spares.sav_config != NULL) {
3311 			VERIFY(nvlist_lookup_nvlist_array(
3312 			    spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES,
3313 			    &spares, &nspares) == 0);
3314 			for (i = 0; i < nspares; i++) {
3315 				uint64_t theguid;
3316 				VERIFY(nvlist_lookup_uint64(spares[i],
3317 				    ZPOOL_CONFIG_GUID, &theguid) == 0);
3318 				if (theguid == guid) {
3319 					VERIFY(nvlist_add_string(spares[i],
3320 					    ZPOOL_CONFIG_PATH, newpath) == 0);
3321 					spa_load_spares(spa);
3322 					spa->spa_spares.sav_sync = B_TRUE;
3323 					return (spa_vdev_exit(spa, NULL, txg,
3324 					    0));
3325 				}
3326 			}
3327 		}
3328 
3329 		return (spa_vdev_exit(spa, NULL, txg, ENOENT));
3330 	}
3331 
3332 	if (!vd->vdev_ops->vdev_op_leaf)
3333 		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
3334 
3335 	spa_strfree(vd->vdev_path);
3336 	vd->vdev_path = spa_strdup(newpath);
3337 
3338 	vdev_config_dirty(vd->vdev_top);
3339 
3340 	return (spa_vdev_exit(spa, NULL, txg, 0));
3341 }
3342 
3343 /*
3344  * ==========================================================================
3345  * SPA Scrubbing
3346  * ==========================================================================
3347  */
3348 
3349 int
3350 spa_scrub(spa_t *spa, pool_scrub_type_t type)
3351 {
3352 	ASSERT(!spa_config_held(spa, RW_WRITER));
3353 
3354 	if ((uint_t)type >= POOL_SCRUB_TYPES)
3355 		return (ENOTSUP);
3356 
3357 	/*
3358 	 * If a resilver was requested, but there is no DTL on a
3359 	 * writeable leaf device, we have nothing to do.
3360 	 */
3361 	if (type == POOL_SCRUB_RESILVER &&
3362 	    !vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) {
3363 		spa_async_request(spa, SPA_ASYNC_RESILVER_DONE);
3364 		return (0);
3365 	}
3366 
3367 	if (type == POOL_SCRUB_EVERYTHING &&
3368 	    spa->spa_dsl_pool->dp_scrub_func != SCRUB_FUNC_NONE &&
3369 	    spa->spa_dsl_pool->dp_scrub_isresilver)
3370 		return (EBUSY);
3371 
3372 	if (type == POOL_SCRUB_EVERYTHING || type == POOL_SCRUB_RESILVER) {
3373 		return (dsl_pool_scrub_clean(spa->spa_dsl_pool));
3374 	} else if (type == POOL_SCRUB_NONE) {
3375 		return (dsl_pool_scrub_cancel(spa->spa_dsl_pool));
3376 	} else {
3377 		return (EINVAL);
3378 	}
3379 }
3380 
3381 /*
3382  * ==========================================================================
3383  * SPA async task processing
3384  * ==========================================================================
3385  */
3386 
3387 static void
3388 spa_async_remove(spa_t *spa, vdev_t *vd)
3389 {
3390 	vdev_t *tvd;
3391 	int c;
3392 
3393 	for (c = 0; c < vd->vdev_children; c++) {
3394 		tvd = vd->vdev_child[c];
3395 		if (tvd->vdev_remove_wanted) {
3396 			tvd->vdev_remove_wanted = 0;
3397 			vdev_set_state(tvd, B_FALSE, VDEV_STATE_REMOVED,
3398 			    VDEV_AUX_NONE);
3399 			vdev_clear(spa, tvd, B_TRUE);
3400 			vdev_config_dirty(tvd->vdev_top);
3401 		}
3402 		spa_async_remove(spa, tvd);
3403 	}
3404 }
3405 
3406 static void
3407 spa_async_thread(spa_t *spa)
3408 {
3409 	int tasks;
3410 	uint64_t txg;
3411 
3412 	ASSERT(spa->spa_sync_on);
3413 
3414 	mutex_enter(&spa->spa_async_lock);
3415 	tasks = spa->spa_async_tasks;
3416 	spa->spa_async_tasks = 0;
3417 	mutex_exit(&spa->spa_async_lock);
3418 
3419 	/*
3420 	 * See if the config needs to be updated.
3421 	 */
3422 	if (tasks & SPA_ASYNC_CONFIG_UPDATE) {
3423 		mutex_enter(&spa_namespace_lock);
3424 		spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
3425 		mutex_exit(&spa_namespace_lock);
3426 	}
3427 
3428 	/*
3429 	 * See if any devices need to be marked REMOVED.
3430 	 *
3431 	 * XXX - We avoid doing this when we are in
3432 	 * I/O failure state since spa_vdev_enter() grabs
3433 	 * the namespace lock and would not be able to obtain
3434 	 * the writer config lock.
3435 	 */
3436 	if (tasks & SPA_ASYNC_REMOVE &&
3437 	    spa_state(spa) != POOL_STATE_IO_FAILURE) {
3438 		txg = spa_vdev_enter(spa);
3439 		spa_async_remove(spa, spa->spa_root_vdev);
3440 		(void) spa_vdev_exit(spa, NULL, txg, 0);
3441 	}
3442 
3443 	/*
3444 	 * If any devices are done replacing, detach them.
3445 	 */
3446 	if (tasks & SPA_ASYNC_RESILVER_DONE)
3447 		spa_vdev_resilver_done(spa);
3448 
3449 	/*
3450 	 * Kick off a resilver.
3451 	 */
3452 	if (tasks & SPA_ASYNC_RESILVER)
3453 		VERIFY(spa_scrub(spa, POOL_SCRUB_RESILVER) == 0);
3454 
3455 	/*
3456 	 * Let the world know that we're done.
3457 	 */
3458 	mutex_enter(&spa->spa_async_lock);
3459 	spa->spa_async_thread = NULL;
3460 	cv_broadcast(&spa->spa_async_cv);
3461 	mutex_exit(&spa->spa_async_lock);
3462 	thread_exit();
3463 }
3464 
3465 void
3466 spa_async_suspend(spa_t *spa)
3467 {
3468 	mutex_enter(&spa->spa_async_lock);
3469 	spa->spa_async_suspended++;
3470 	while (spa->spa_async_thread != NULL)
3471 		cv_wait(&spa->spa_async_cv, &spa->spa_async_lock);
3472 	mutex_exit(&spa->spa_async_lock);
3473 }
3474 
3475 void
3476 spa_async_resume(spa_t *spa)
3477 {
3478 	mutex_enter(&spa->spa_async_lock);
3479 	ASSERT(spa->spa_async_suspended != 0);
3480 	spa->spa_async_suspended--;
3481 	mutex_exit(&spa->spa_async_lock);
3482 }
3483 
3484 static void
3485 spa_async_dispatch(spa_t *spa)
3486 {
3487 	mutex_enter(&spa->spa_async_lock);
3488 	if (spa->spa_async_tasks && !spa->spa_async_suspended &&
3489 	    spa->spa_async_thread == NULL &&
3490 	    rootdir != NULL && !vn_is_readonly(rootdir))
3491 		spa->spa_async_thread = thread_create(NULL, 0,
3492 		    spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri);
3493 	mutex_exit(&spa->spa_async_lock);
3494 }
3495 
3496 void
3497 spa_async_request(spa_t *spa, int task)
3498 {
3499 	mutex_enter(&spa->spa_async_lock);
3500 	spa->spa_async_tasks |= task;
3501 	mutex_exit(&spa->spa_async_lock);
3502 }
3503 
3504 /*
3505  * ==========================================================================
3506  * SPA syncing routines
3507  * ==========================================================================
3508  */
3509 
3510 static void
3511 spa_sync_deferred_frees(spa_t *spa, uint64_t txg)
3512 {
3513 	bplist_t *bpl = &spa->spa_sync_bplist;
3514 	dmu_tx_t *tx;
3515 	blkptr_t blk;
3516 	uint64_t itor = 0;
3517 	zio_t *zio;
3518 	int error;
3519 	uint8_t c = 1;
3520 
3521 	zio = zio_root(spa, NULL, NULL, ZIO_FLAG_CONFIG_HELD);
3522 
3523 	while (bplist_iterate(bpl, &itor, &blk) == 0)
3524 		zio_nowait(zio_free(zio, spa, txg, &blk, NULL, NULL));
3525 
3526 	error = zio_wait(zio);
3527 	ASSERT3U(error, ==, 0);
3528 
3529 	tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg);
3530 	bplist_vacate(bpl, tx);
3531 
3532 	/*
3533 	 * Pre-dirty the first block so we sync to convergence faster.
3534 	 * (Usually only the first block is needed.)
3535 	 */
3536 	dmu_write(spa->spa_meta_objset, spa->spa_sync_bplist_obj, 0, 1, &c, tx);
3537 	dmu_tx_commit(tx);
3538 }
3539 
3540 static void
3541 spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx)
3542 {
3543 	char *packed = NULL;
3544 	size_t nvsize = 0;
3545 	dmu_buf_t *db;
3546 
3547 	VERIFY(nvlist_size(nv, &nvsize, NV_ENCODE_XDR) == 0);
3548 
3549 	packed = kmem_alloc(nvsize, KM_SLEEP);
3550 
3551 	VERIFY(nvlist_pack(nv, &packed, &nvsize, NV_ENCODE_XDR,
3552 	    KM_SLEEP) == 0);
3553 
3554 	dmu_write(spa->spa_meta_objset, obj, 0, nvsize, packed, tx);
3555 
3556 	kmem_free(packed, nvsize);
3557 
3558 	VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db));
3559 	dmu_buf_will_dirty(db, tx);
3560 	*(uint64_t *)db->db_data = nvsize;
3561 	dmu_buf_rele(db, FTAG);
3562 }
3563 
3564 static void
3565 spa_sync_aux_dev(spa_t *spa, spa_aux_vdev_t *sav, dmu_tx_t *tx,
3566     const char *config, const char *entry)
3567 {
3568 	nvlist_t *nvroot;
3569 	nvlist_t **list;
3570 	int i;
3571 
3572 	if (!sav->sav_sync)
3573 		return;
3574 
3575 	/*
3576 	 * Update the MOS nvlist describing the list of available devices.
3577 	 * spa_validate_aux() will have already made sure this nvlist is
3578 	 * valid and the vdevs are labeled appropriately.
3579 	 */
3580 	if (sav->sav_object == 0) {
3581 		sav->sav_object = dmu_object_alloc(spa->spa_meta_objset,
3582 		    DMU_OT_PACKED_NVLIST, 1 << 14, DMU_OT_PACKED_NVLIST_SIZE,
3583 		    sizeof (uint64_t), tx);
3584 		VERIFY(zap_update(spa->spa_meta_objset,
3585 		    DMU_POOL_DIRECTORY_OBJECT, entry, sizeof (uint64_t), 1,
3586 		    &sav->sav_object, tx) == 0);
3587 	}
3588 
3589 	VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0);
3590 	if (sav->sav_count == 0) {
3591 		VERIFY(nvlist_add_nvlist_array(nvroot, config, NULL, 0) == 0);
3592 	} else {
3593 		list = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP);
3594 		for (i = 0; i < sav->sav_count; i++)
3595 			list[i] = vdev_config_generate(spa, sav->sav_vdevs[i],
3596 			    B_FALSE, B_FALSE, B_TRUE);
3597 		VERIFY(nvlist_add_nvlist_array(nvroot, config, list,
3598 		    sav->sav_count) == 0);
3599 		for (i = 0; i < sav->sav_count; i++)
3600 			nvlist_free(list[i]);
3601 		kmem_free(list, sav->sav_count * sizeof (void *));
3602 	}
3603 
3604 	spa_sync_nvlist(spa, sav->sav_object, nvroot, tx);
3605 	nvlist_free(nvroot);
3606 
3607 	sav->sav_sync = B_FALSE;
3608 }
3609 
3610 static void
3611 spa_sync_config_object(spa_t *spa, dmu_tx_t *tx)
3612 {
3613 	nvlist_t *config;
3614 
3615 	if (list_is_empty(&spa->spa_dirty_list))
3616 		return;
3617 
3618 	config = spa_config_generate(spa, NULL, dmu_tx_get_txg(tx), B_FALSE);
3619 
3620 	if (spa->spa_config_syncing)
3621 		nvlist_free(spa->spa_config_syncing);
3622 	spa->spa_config_syncing = config;
3623 
3624 	spa_sync_nvlist(spa, spa->spa_config_object, config, tx);
3625 }
3626 
3627 /*
3628  * Set zpool properties.
3629  */
3630 static void
3631 spa_sync_props(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)
3632 {
3633 	spa_t *spa = arg1;
3634 	objset_t *mos = spa->spa_meta_objset;
3635 	nvlist_t *nvp = arg2;
3636 	nvpair_t *elem;
3637 	uint64_t intval;
3638 	char *strval;
3639 	zpool_prop_t prop;
3640 	const char *propname;
3641 	zprop_type_t proptype;
3642 	spa_config_dirent_t *dp;
3643 
3644 	elem = NULL;
3645 	while ((elem = nvlist_next_nvpair(nvp, elem))) {
3646 		switch (prop = zpool_name_to_prop(nvpair_name(elem))) {
3647 		case ZPOOL_PROP_VERSION:
3648 			/*
3649 			 * Only set version for non-zpool-creation cases
3650 			 * (set/import). spa_create() needs special care
3651 			 * for version setting.
3652 			 */
3653 			if (tx->tx_txg != TXG_INITIAL) {
3654 				VERIFY(nvpair_value_uint64(elem,
3655 				    &intval) == 0);
3656 				ASSERT(intval <= SPA_VERSION);
3657 				ASSERT(intval >= spa_version(spa));
3658 				spa->spa_uberblock.ub_version = intval;
3659 				vdev_config_dirty(spa->spa_root_vdev);
3660 			}
3661 			break;
3662 
3663 		case ZPOOL_PROP_ALTROOT:
3664 			/*
3665 			 * 'altroot' is a non-persistent property. It should
3666 			 * have been set temporarily at creation or import time.
3667 			 */
3668 			ASSERT(spa->spa_root != NULL);
3669 			break;
3670 
3671 		case ZPOOL_PROP_CACHEFILE:
3672 			/*
3673 			 * 'cachefile' is a non-persistent property, but note
3674 			 * an async request that the config cache needs to be
3675 			 * udpated.
3676 			 */
3677 			VERIFY(nvpair_value_string(elem, &strval) == 0);
3678 
3679 			dp = kmem_alloc(sizeof (spa_config_dirent_t),
3680 			    KM_SLEEP);
3681 
3682 			if (strval[0] == '\0')
3683 				dp->scd_path = spa_strdup(spa_config_path);
3684 			else if (strcmp(strval, "none") == 0)
3685 				dp->scd_path = NULL;
3686 			else
3687 				dp->scd_path = spa_strdup(strval);
3688 
3689 			list_insert_head(&spa->spa_config_list, dp);
3690 			spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
3691 			break;
3692 		default:
3693 			/*
3694 			 * Set pool property values in the poolprops mos object.
3695 			 */
3696 			mutex_enter(&spa->spa_props_lock);
3697 			if (spa->spa_pool_props_object == 0) {
3698 				objset_t *mos = spa->spa_meta_objset;
3699 
3700 				VERIFY((spa->spa_pool_props_object =
3701 				    zap_create(mos, DMU_OT_POOL_PROPS,
3702 				    DMU_OT_NONE, 0, tx)) > 0);
3703 
3704 				VERIFY(zap_update(mos,
3705 				    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_PROPS,
3706 				    8, 1, &spa->spa_pool_props_object, tx)
3707 				    == 0);
3708 			}
3709 			mutex_exit(&spa->spa_props_lock);
3710 
3711 			/* normalize the property name */
3712 			propname = zpool_prop_to_name(prop);
3713 			proptype = zpool_prop_get_type(prop);
3714 
3715 			if (nvpair_type(elem) == DATA_TYPE_STRING) {
3716 				ASSERT(proptype == PROP_TYPE_STRING);
3717 				VERIFY(nvpair_value_string(elem, &strval) == 0);
3718 				VERIFY(zap_update(mos,
3719 				    spa->spa_pool_props_object, propname,
3720 				    1, strlen(strval) + 1, strval, tx) == 0);
3721 
3722 			} else if (nvpair_type(elem) == DATA_TYPE_UINT64) {
3723 				VERIFY(nvpair_value_uint64(elem, &intval) == 0);
3724 
3725 				if (proptype == PROP_TYPE_INDEX) {
3726 					const char *unused;
3727 					VERIFY(zpool_prop_index_to_string(
3728 					    prop, intval, &unused) == 0);
3729 				}
3730 				VERIFY(zap_update(mos,
3731 				    spa->spa_pool_props_object, propname,
3732 				    8, 1, &intval, tx) == 0);
3733 			} else {
3734 				ASSERT(0); /* not allowed */
3735 			}
3736 
3737 			switch (prop) {
3738 			case ZPOOL_PROP_DELEGATION:
3739 				spa->spa_delegation = intval;
3740 				break;
3741 			case ZPOOL_PROP_BOOTFS:
3742 				spa->spa_bootfs = intval;
3743 				break;
3744 			case ZPOOL_PROP_FAILUREMODE:
3745 				spa->spa_failmode = intval;
3746 				break;
3747 			default:
3748 				break;
3749 			}
3750 		}
3751 
3752 		/* log internal history if this is not a zpool create */
3753 		if (spa_version(spa) >= SPA_VERSION_ZPOOL_HISTORY &&
3754 		    tx->tx_txg != TXG_INITIAL) {
3755 			spa_history_internal_log(LOG_POOL_PROPSET,
3756 			    spa, tx, cr, "%s %lld %s",
3757 			    nvpair_name(elem), intval, spa->spa_name);
3758 		}
3759 	}
3760 }
3761 
3762 /*
3763  * Sync the specified transaction group.  New blocks may be dirtied as
3764  * part of the process, so we iterate until it converges.
3765  */
3766 void
3767 spa_sync(spa_t *spa, uint64_t txg)
3768 {
3769 	dsl_pool_t *dp = spa->spa_dsl_pool;
3770 	objset_t *mos = spa->spa_meta_objset;
3771 	bplist_t *bpl = &spa->spa_sync_bplist;
3772 	vdev_t *rvd = spa->spa_root_vdev;
3773 	vdev_t *vd;
3774 	dmu_tx_t *tx;
3775 	int dirty_vdevs;
3776 
3777 	/*
3778 	 * Lock out configuration changes.
3779 	 */
3780 	spa_config_enter(spa, RW_READER, FTAG);
3781 
3782 	spa->spa_syncing_txg = txg;
3783 	spa->spa_sync_pass = 0;
3784 
3785 	VERIFY(0 == bplist_open(bpl, mos, spa->spa_sync_bplist_obj));
3786 
3787 	tx = dmu_tx_create_assigned(dp, txg);
3788 
3789 	/*
3790 	 * If we are upgrading to SPA_VERSION_RAIDZ_DEFLATE this txg,
3791 	 * set spa_deflate if we have no raid-z vdevs.
3792 	 */
3793 	if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE &&
3794 	    spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) {
3795 		int i;
3796 
3797 		for (i = 0; i < rvd->vdev_children; i++) {
3798 			vd = rvd->vdev_child[i];
3799 			if (vd->vdev_deflate_ratio != SPA_MINBLOCKSIZE)
3800 				break;
3801 		}
3802 		if (i == rvd->vdev_children) {
3803 			spa->spa_deflate = TRUE;
3804 			VERIFY(0 == zap_add(spa->spa_meta_objset,
3805 			    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE,
3806 			    sizeof (uint64_t), 1, &spa->spa_deflate, tx));
3807 		}
3808 	}
3809 
3810 	if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN &&
3811 	    spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) {
3812 		dsl_pool_create_origin(dp, tx);
3813 
3814 		/* Keeping the origin open increases spa_minref */
3815 		spa->spa_minref += 3;
3816 	}
3817 
3818 	if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES &&
3819 	    spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) {
3820 		dsl_pool_upgrade_clones(dp, tx);
3821 	}
3822 
3823 	/*
3824 	 * If anything has changed in this txg, push the deferred frees
3825 	 * from the previous txg.  If not, leave them alone so that we
3826 	 * don't generate work on an otherwise idle system.
3827 	 */
3828 	if (!txg_list_empty(&dp->dp_dirty_datasets, txg) ||
3829 	    !txg_list_empty(&dp->dp_dirty_dirs, txg) ||
3830 	    !txg_list_empty(&dp->dp_sync_tasks, txg))
3831 		spa_sync_deferred_frees(spa, txg);
3832 
3833 	/*
3834 	 * Iterate to convergence.
3835 	 */
3836 	do {
3837 		spa->spa_sync_pass++;
3838 
3839 		spa_sync_config_object(spa, tx);
3840 		spa_sync_aux_dev(spa, &spa->spa_spares, tx,
3841 		    ZPOOL_CONFIG_SPARES, DMU_POOL_SPARES);
3842 		spa_sync_aux_dev(spa, &spa->spa_l2cache, tx,
3843 		    ZPOOL_CONFIG_L2CACHE, DMU_POOL_L2CACHE);
3844 		spa_errlog_sync(spa, txg);
3845 		dsl_pool_sync(dp, txg);
3846 
3847 		dirty_vdevs = 0;
3848 		while (vd = txg_list_remove(&spa->spa_vdev_txg_list, txg)) {
3849 			vdev_sync(vd, txg);
3850 			dirty_vdevs++;
3851 		}
3852 
3853 		bplist_sync(bpl, tx);
3854 	} while (dirty_vdevs);
3855 
3856 	bplist_close(bpl);
3857 
3858 	dprintf("txg %llu passes %d\n", txg, spa->spa_sync_pass);
3859 
3860 	/*
3861 	 * Rewrite the vdev configuration (which includes the uberblock)
3862 	 * to commit the transaction group.
3863 	 *
3864 	 * If there are no dirty vdevs, we sync the uberblock to a few
3865 	 * random top-level vdevs that are known to be visible in the
3866 	 * config cache (see spa_vdev_add() for details).  If there *are*
3867 	 * dirty vdevs -- or if the sync to our random subset fails --
3868 	 * then sync the uberblock to all vdevs.
3869 	 */
3870 	if (list_is_empty(&spa->spa_dirty_list)) {
3871 		vdev_t *svd[SPA_DVAS_PER_BP];
3872 		int svdcount = 0;
3873 		int children = rvd->vdev_children;
3874 		int c0 = spa_get_random(children);
3875 		int c;
3876 
3877 		for (c = 0; c < children; c++) {
3878 			vd = rvd->vdev_child[(c0 + c) % children];
3879 			if (vd->vdev_ms_array == 0 || vd->vdev_islog)
3880 				continue;
3881 			svd[svdcount++] = vd;
3882 			if (svdcount == SPA_DVAS_PER_BP)
3883 				break;
3884 		}
3885 		vdev_config_sync(svd, svdcount, txg);
3886 	} else {
3887 		vdev_config_sync(rvd->vdev_child, rvd->vdev_children, txg);
3888 	}
3889 	dmu_tx_commit(tx);
3890 
3891 	/*
3892 	 * Clear the dirty config list.
3893 	 */
3894 	while ((vd = list_head(&spa->spa_dirty_list)) != NULL)
3895 		vdev_config_clean(vd);
3896 
3897 	/*
3898 	 * Now that the new config has synced transactionally,
3899 	 * let it become visible to the config cache.
3900 	 */
3901 	if (spa->spa_config_syncing != NULL) {
3902 		spa_config_set(spa, spa->spa_config_syncing);
3903 		spa->spa_config_txg = txg;
3904 		spa->spa_config_syncing = NULL;
3905 	}
3906 
3907 	spa->spa_traverse_wanted = B_TRUE;
3908 	rw_enter(&spa->spa_traverse_lock, RW_WRITER);
3909 	spa->spa_traverse_wanted = B_FALSE;
3910 	spa->spa_ubsync = spa->spa_uberblock;
3911 	rw_exit(&spa->spa_traverse_lock);
3912 
3913 	/*
3914 	 * Clean up the ZIL records for the synced txg.
3915 	 */
3916 	dsl_pool_zil_clean(dp);
3917 
3918 	/*
3919 	 * Update usable space statistics.
3920 	 */
3921 	while (vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)))
3922 		vdev_sync_done(vd, txg);
3923 
3924 	/*
3925 	 * It had better be the case that we didn't dirty anything
3926 	 * since vdev_config_sync().
3927 	 */
3928 	ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg));
3929 	ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg));
3930 	ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg));
3931 	ASSERT(bpl->bpl_queue == NULL);
3932 
3933 	spa_config_exit(spa, FTAG);
3934 
3935 	/*
3936 	 * If any async tasks have been requested, kick them off.
3937 	 */
3938 	spa_async_dispatch(spa);
3939 }
3940 
3941 /*
3942  * Sync all pools.  We don't want to hold the namespace lock across these
3943  * operations, so we take a reference on the spa_t and drop the lock during the
3944  * sync.
3945  */
3946 void
3947 spa_sync_allpools(void)
3948 {
3949 	spa_t *spa = NULL;
3950 	mutex_enter(&spa_namespace_lock);
3951 	while ((spa = spa_next(spa)) != NULL) {
3952 		if (spa_state(spa) != POOL_STATE_ACTIVE)
3953 			continue;
3954 		spa_open_ref(spa, FTAG);
3955 		mutex_exit(&spa_namespace_lock);
3956 		txg_wait_synced(spa_get_dsl(spa), 0);
3957 		mutex_enter(&spa_namespace_lock);
3958 		spa_close(spa, FTAG);
3959 	}
3960 	mutex_exit(&spa_namespace_lock);
3961 }
3962 
3963 /*
3964  * ==========================================================================
3965  * Miscellaneous routines
3966  * ==========================================================================
3967  */
3968 
3969 /*
3970  * Remove all pools in the system.
3971  */
3972 void
3973 spa_evict_all(void)
3974 {
3975 	spa_t *spa;
3976 
3977 	/*
3978 	 * Remove all cached state.  All pools should be closed now,
3979 	 * so every spa in the AVL tree should be unreferenced.
3980 	 */
3981 	mutex_enter(&spa_namespace_lock);
3982 	while ((spa = spa_next(NULL)) != NULL) {
3983 		/*
3984 		 * Stop async tasks.  The async thread may need to detach
3985 		 * a device that's been replaced, which requires grabbing
3986 		 * spa_namespace_lock, so we must drop it here.
3987 		 */
3988 		spa_open_ref(spa, FTAG);
3989 		mutex_exit(&spa_namespace_lock);
3990 		spa_async_suspend(spa);
3991 		mutex_enter(&spa_namespace_lock);
3992 		spa_close(spa, FTAG);
3993 
3994 		if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
3995 			spa_unload(spa);
3996 			spa_deactivate(spa);
3997 		}
3998 		spa_remove(spa);
3999 	}
4000 	mutex_exit(&spa_namespace_lock);
4001 }
4002 
4003 vdev_t *
4004 spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t l2cache)
4005 {
4006 	vdev_t *vd;
4007 	int i;
4008 
4009 	if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL)
4010 		return (vd);
4011 
4012 	if (l2cache) {
4013 		for (i = 0; i < spa->spa_l2cache.sav_count; i++) {
4014 			vd = spa->spa_l2cache.sav_vdevs[i];
4015 			if (vd->vdev_guid == guid)
4016 				return (vd);
4017 		}
4018 	}
4019 
4020 	return (NULL);
4021 }
4022 
4023 void
4024 spa_upgrade(spa_t *spa, uint64_t version)
4025 {
4026 	spa_config_enter(spa, RW_WRITER, FTAG);
4027 
4028 	/*
4029 	 * This should only be called for a non-faulted pool, and since a
4030 	 * future version would result in an unopenable pool, this shouldn't be
4031 	 * possible.
4032 	 */
4033 	ASSERT(spa->spa_uberblock.ub_version <= SPA_VERSION);
4034 	ASSERT(version >= spa->spa_uberblock.ub_version);
4035 
4036 	spa->spa_uberblock.ub_version = version;
4037 	vdev_config_dirty(spa->spa_root_vdev);
4038 
4039 	spa_config_exit(spa, FTAG);
4040 
4041 	txg_wait_synced(spa_get_dsl(spa), 0);
4042 }
4043 
4044 boolean_t
4045 spa_has_spare(spa_t *spa, uint64_t guid)
4046 {
4047 	int i;
4048 	uint64_t spareguid;
4049 	spa_aux_vdev_t *sav = &spa->spa_spares;
4050 
4051 	for (i = 0; i < sav->sav_count; i++)
4052 		if (sav->sav_vdevs[i]->vdev_guid == guid)
4053 			return (B_TRUE);
4054 
4055 	for (i = 0; i < sav->sav_npending; i++) {
4056 		if (nvlist_lookup_uint64(sav->sav_pending[i], ZPOOL_CONFIG_GUID,
4057 		    &spareguid) == 0 && spareguid == guid)
4058 			return (B_TRUE);
4059 	}
4060 
4061 	return (B_FALSE);
4062 }
4063 
4064 /*
4065  * Post a sysevent corresponding to the given event.  The 'name' must be one of
4066  * the event definitions in sys/sysevent/eventdefs.h.  The payload will be
4067  * filled in from the spa and (optionally) the vdev.  This doesn't do anything
4068  * in the userland libzpool, as we don't want consumers to misinterpret ztest
4069  * or zdb as real changes.
4070  */
4071 void
4072 spa_event_notify(spa_t *spa, vdev_t *vd, const char *name)
4073 {
4074 #ifdef _KERNEL
4075 	sysevent_t		*ev;
4076 	sysevent_attr_list_t	*attr = NULL;
4077 	sysevent_value_t	value;
4078 	sysevent_id_t		eid;
4079 
4080 	ev = sysevent_alloc(EC_ZFS, (char *)name, SUNW_KERN_PUB "zfs",
4081 	    SE_SLEEP);
4082 
4083 	value.value_type = SE_DATA_TYPE_STRING;
4084 	value.value.sv_string = spa_name(spa);
4085 	if (sysevent_add_attr(&attr, ZFS_EV_POOL_NAME, &value, SE_SLEEP) != 0)
4086 		goto done;
4087 
4088 	value.value_type = SE_DATA_TYPE_UINT64;
4089 	value.value.sv_uint64 = spa_guid(spa);
4090 	if (sysevent_add_attr(&attr, ZFS_EV_POOL_GUID, &value, SE_SLEEP) != 0)
4091 		goto done;
4092 
4093 	if (vd) {
4094 		value.value_type = SE_DATA_TYPE_UINT64;
4095 		value.value.sv_uint64 = vd->vdev_guid;
4096 		if (sysevent_add_attr(&attr, ZFS_EV_VDEV_GUID, &value,
4097 		    SE_SLEEP) != 0)
4098 			goto done;
4099 
4100 		if (vd->vdev_path) {
4101 			value.value_type = SE_DATA_TYPE_STRING;
4102 			value.value.sv_string = vd->vdev_path;
4103 			if (sysevent_add_attr(&attr, ZFS_EV_VDEV_PATH,
4104 			    &value, SE_SLEEP) != 0)
4105 				goto done;
4106 		}
4107 	}
4108 
4109 	if (sysevent_attach_attributes(ev, attr) != 0)
4110 		goto done;
4111 	attr = NULL;
4112 
4113 	(void) log_sysevent(ev, SE_SLEEP, &eid);
4114 
4115 done:
4116 	if (attr)
4117 		sysevent_free_attr(attr);
4118 	sysevent_free(ev);
4119 #endif
4120 }
4121