spa.c revision 0a48a24e663a04e34e2ed4e55390ad96f178dbea
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
68int zio_taskq_threads = 8;
69
70static 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 */
81static void
82spa_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 */
103static void
104spa_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 */
155int
156spa_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);
248out:
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 */
262static int
263spa_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
403int
404spa_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 */
418void
419spa_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
435static int
436spa_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 */
457void
458spa_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 */
476static void
477spa_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 */
516static void
517spa_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 */
563static int
564spa_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 */
602static void
603spa_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 */
679static void
680spa_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 */
792static void
793spa_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);
910out:
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
917static int
918load_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 */
943static void
944spa_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 */
961static int
962spa_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;
1367out:
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 */
1389static int
1390spa_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
1477int
1478spa_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 */
1487spa_t *
1488spa_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
1503void
1504spa_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 */
1514static void
1515spa_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 */
1560static void
1561spa_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
1613int
1614spa_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 */
1661static int
1662spa_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
1731out:
1732	sav->sav_pending = NULL;
1733	sav->sav_npending = 0;
1734	return (error);
1735}
1736
1737static int
1738spa_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
1753static void
1754spa_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 */
1802void
1803spa_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 */
1830int
1831spa_create(const char *pool, nvlist_t *nvroot, nvlist_t *props,
1832    const char *history_str, nvlist_t *zplprops)
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, zplprops, 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 */
2027static int
2028spa_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 */
2172static void
2173spa_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 */
2209extern nvlist_t *vdev_disk_read_rootlabel(char *, char *);
2210
2211int
2212spa_check_rootconf(char *devpath, char *devid, 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, devid)) == NULL)
2219		return (-1);
2220
2221	VERIFY(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG, &txg) == 0);
2222
2223	if (bestconf != NULL)
2224		*bestconf = config;
2225	*besttxg = txg;
2226	return (0);
2227}
2228
2229boolean_t
2230spa_rootdev_validate(nvlist_t *nv)
2231{
2232	uint64_t ival;
2233
2234	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_OFFLINE, &ival) == 0 ||
2235	    nvlist_lookup_uint64(nv, ZPOOL_CONFIG_FAULTED, &ival) == 0 ||
2236	    nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVED, &ival) == 0)
2237		return (B_FALSE);
2238
2239	return (B_TRUE);
2240}
2241
2242
2243/*
2244 * Given the boot device's physical path or devid, check if the device
2245 * is in a valid state.  If so, return the configuration from the vdev
2246 * label.
2247 */
2248int
2249spa_get_rootconf(char *devpath, char *devid, nvlist_t **bestconf)
2250{
2251	nvlist_t *conf = NULL;
2252	uint64_t txg = 0;
2253	nvlist_t *nvtop, **child;
2254	char *type;
2255	char *bootpath = NULL;
2256	uint_t children, c;
2257	char *tmp;
2258
2259	if (devpath && ((tmp = strchr(devpath, ' ')) != NULL))
2260		*tmp = '\0';
2261	if (spa_check_rootconf(devpath, devid, &conf, &txg) < 0) {
2262		cmn_err(CE_NOTE, "error reading device label");
2263		nvlist_free(conf);
2264		return (EINVAL);
2265	}
2266	if (txg == 0) {
2267		cmn_err(CE_NOTE, "this device is detached");
2268		nvlist_free(conf);
2269		return (EINVAL);
2270	}
2271
2272	VERIFY(nvlist_lookup_nvlist(conf, ZPOOL_CONFIG_VDEV_TREE,
2273	    &nvtop) == 0);
2274	VERIFY(nvlist_lookup_string(nvtop, ZPOOL_CONFIG_TYPE, &type) == 0);
2275
2276	if (strcmp(type, VDEV_TYPE_DISK) == 0) {
2277		if (spa_rootdev_validate(nvtop)) {
2278			goto out;
2279		} else {
2280			nvlist_free(conf);
2281			return (EINVAL);
2282		}
2283	}
2284
2285	ASSERT(strcmp(type, VDEV_TYPE_MIRROR) == 0);
2286
2287	VERIFY(nvlist_lookup_nvlist_array(nvtop, ZPOOL_CONFIG_CHILDREN,
2288	    &child, &children) == 0);
2289
2290	/*
2291	 * Go thru vdevs in the mirror to see if the given device
2292	 * has the most recent txg. Only the device with the most
2293	 * recent txg has valid information and should be booted.
2294	 */
2295	for (c = 0; c < children; c++) {
2296		char *cdevid, *cpath;
2297		uint64_t tmptxg;
2298
2299		if (nvlist_lookup_string(child[c], ZPOOL_CONFIG_PHYS_PATH,
2300		    &cpath) != 0)
2301			return (EINVAL);
2302		if (nvlist_lookup_string(child[c], ZPOOL_CONFIG_DEVID,
2303		    &cdevid) != 0)
2304			return (EINVAL);
2305		if ((spa_check_rootconf(cpath, cdevid, NULL,
2306		    &tmptxg) == 0) && (tmptxg > txg)) {
2307			txg = tmptxg;
2308			VERIFY(nvlist_lookup_string(child[c],
2309			    ZPOOL_CONFIG_PATH, &bootpath) == 0);
2310		}
2311	}
2312
2313	/* Does the best device match the one we've booted from? */
2314	if (bootpath) {
2315		cmn_err(CE_NOTE, "try booting from '%s'", bootpath);
2316		return (EINVAL);
2317	}
2318out:
2319	*bestconf = conf;
2320	return (0);
2321}
2322
2323/*
2324 * Import a root pool.
2325 *
2326 * For x86. devpath_list will consist of devid and/or physpath name of
2327 * the vdev (e.g. "id1,sd@SSEAGATE..." or "/pci@1f,0/ide@d/disk@0,0:a").
2328 * The GRUB "findroot" command will return the vdev we should boot.
2329 *
2330 * For Sparc, devpath_list consists the physpath name of the booting device
2331 * no matter the rootpool is a single device pool or a mirrored pool.
2332 * e.g.
2333 *	"/pci@1f,0/ide@d/disk@0,0:a"
2334 */
2335int
2336spa_import_rootpool(char *devpath, char *devid)
2337{
2338	nvlist_t *conf = NULL;
2339	char *pname;
2340	int error;
2341
2342	/*
2343	 * Get the vdev pathname and configuation from the most
2344	 * recently updated vdev (highest txg).
2345	 */
2346	if (error = spa_get_rootconf(devpath, devid, &conf))
2347		goto msg_out;
2348
2349	/*
2350	 * Add type "root" vdev to the config.
2351	 */
2352	spa_build_rootpool_config(conf);
2353
2354	VERIFY(nvlist_lookup_string(conf, ZPOOL_CONFIG_POOL_NAME, &pname) == 0);
2355
2356	/*
2357	 * We specify 'allowfaulted' for this to be treated like spa_open()
2358	 * instead of spa_import().  This prevents us from marking vdevs as
2359	 * persistently unavailable, and generates FMA ereports as if it were a
2360	 * pool open, not import.
2361	 */
2362	error = spa_import_common(pname, conf, NULL, B_TRUE, B_TRUE);
2363	if (error == EEXIST)
2364		error = 0;
2365
2366	nvlist_free(conf);
2367	return (error);
2368
2369msg_out:
2370	cmn_err(CE_NOTE, "\n"
2371	    "  ***************************************************  \n"
2372	    "  *  This device is not bootable!                   *  \n"
2373	    "  *  It is either offlined or detached or faulted.  *  \n"
2374	    "  *  Please try to boot from a different device.    *  \n"
2375	    "  ***************************************************  ");
2376
2377	return (error);
2378}
2379#endif
2380
2381/*
2382 * Import a non-root pool into the system.
2383 */
2384int
2385spa_import(const char *pool, nvlist_t *config, nvlist_t *props)
2386{
2387	return (spa_import_common(pool, config, props, B_FALSE, B_FALSE));
2388}
2389
2390int
2391spa_import_faulted(const char *pool, nvlist_t *config, nvlist_t *props)
2392{
2393	return (spa_import_common(pool, config, props, B_FALSE, B_TRUE));
2394}
2395
2396
2397/*
2398 * This (illegal) pool name is used when temporarily importing a spa_t in order
2399 * to get the vdev stats associated with the imported devices.
2400 */
2401#define	TRYIMPORT_NAME	"$import"
2402
2403nvlist_t *
2404spa_tryimport(nvlist_t *tryconfig)
2405{
2406	nvlist_t *config = NULL;
2407	char *poolname;
2408	spa_t *spa;
2409	uint64_t state;
2410
2411	if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname))
2412		return (NULL);
2413
2414	if (nvlist_lookup_uint64(tryconfig, ZPOOL_CONFIG_POOL_STATE, &state))
2415		return (NULL);
2416
2417	/*
2418	 * Create and initialize the spa structure.
2419	 */
2420	mutex_enter(&spa_namespace_lock);
2421	spa = spa_add(TRYIMPORT_NAME, NULL);
2422	spa_activate(spa);
2423
2424	/*
2425	 * Pass off the heavy lifting to spa_load().
2426	 * Pass TRUE for mosconfig because the user-supplied config
2427	 * is actually the one to trust when doing an import.
2428	 */
2429	(void) spa_load(spa, tryconfig, SPA_LOAD_TRYIMPORT, B_TRUE);
2430
2431	/*
2432	 * If 'tryconfig' was at least parsable, return the current config.
2433	 */
2434	if (spa->spa_root_vdev != NULL) {
2435		spa_config_enter(spa, RW_READER, FTAG);
2436		config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
2437		spa_config_exit(spa, FTAG);
2438		VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME,
2439		    poolname) == 0);
2440		VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE,
2441		    state) == 0);
2442		VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_TIMESTAMP,
2443		    spa->spa_uberblock.ub_timestamp) == 0);
2444
2445		/*
2446		 * If the bootfs property exists on this pool then we
2447		 * copy it out so that external consumers can tell which
2448		 * pools are bootable.
2449		 */
2450		if (spa->spa_bootfs) {
2451			char *tmpname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2452
2453			/*
2454			 * We have to play games with the name since the
2455			 * pool was opened as TRYIMPORT_NAME.
2456			 */
2457			if (dsl_dsobj_to_dsname(spa->spa_name,
2458			    spa->spa_bootfs, tmpname) == 0) {
2459				char *cp;
2460				char *dsname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2461
2462				cp = strchr(tmpname, '/');
2463				if (cp == NULL) {
2464					(void) strlcpy(dsname, tmpname,
2465					    MAXPATHLEN);
2466				} else {
2467					(void) snprintf(dsname, MAXPATHLEN,
2468					    "%s/%s", poolname, ++cp);
2469				}
2470				VERIFY(nvlist_add_string(config,
2471				    ZPOOL_CONFIG_BOOTFS, dsname) == 0);
2472				kmem_free(dsname, MAXPATHLEN);
2473			}
2474			kmem_free(tmpname, MAXPATHLEN);
2475		}
2476
2477		/*
2478		 * Add the list of hot spares and level 2 cache devices.
2479		 */
2480		spa_add_spares(spa, config);
2481		spa_add_l2cache(spa, config);
2482	}
2483
2484	spa_unload(spa);
2485	spa_deactivate(spa);
2486	spa_remove(spa);
2487	mutex_exit(&spa_namespace_lock);
2488
2489	return (config);
2490}
2491
2492/*
2493 * Pool export/destroy
2494 *
2495 * The act of destroying or exporting a pool is very simple.  We make sure there
2496 * is no more pending I/O and any references to the pool are gone.  Then, we
2497 * update the pool state and sync all the labels to disk, removing the
2498 * configuration from the cache afterwards.
2499 */
2500static int
2501spa_export_common(char *pool, int new_state, nvlist_t **oldconfig)
2502{
2503	spa_t *spa;
2504
2505	if (oldconfig)
2506		*oldconfig = NULL;
2507
2508	if (!(spa_mode & FWRITE))
2509		return (EROFS);
2510
2511	mutex_enter(&spa_namespace_lock);
2512	if ((spa = spa_lookup(pool)) == NULL) {
2513		mutex_exit(&spa_namespace_lock);
2514		return (ENOENT);
2515	}
2516
2517	/*
2518	 * Put a hold on the pool, drop the namespace lock, stop async tasks,
2519	 * reacquire the namespace lock, and see if we can export.
2520	 */
2521	spa_open_ref(spa, FTAG);
2522	mutex_exit(&spa_namespace_lock);
2523	spa_async_suspend(spa);
2524	mutex_enter(&spa_namespace_lock);
2525	spa_close(spa, FTAG);
2526
2527	/*
2528	 * The pool will be in core if it's openable,
2529	 * in which case we can modify its state.
2530	 */
2531	if (spa->spa_state != POOL_STATE_UNINITIALIZED && spa->spa_sync_on) {
2532		/*
2533		 * Objsets may be open only because they're dirty, so we
2534		 * have to force it to sync before checking spa_refcnt.
2535		 */
2536		txg_wait_synced(spa->spa_dsl_pool, 0);
2537
2538		/*
2539		 * A pool cannot be exported or destroyed if there are active
2540		 * references.  If we are resetting a pool, allow references by
2541		 * fault injection handlers.
2542		 */
2543		if (!spa_refcount_zero(spa) ||
2544		    (spa->spa_inject_ref != 0 &&
2545		    new_state != POOL_STATE_UNINITIALIZED)) {
2546			spa_async_resume(spa);
2547			mutex_exit(&spa_namespace_lock);
2548			return (EBUSY);
2549		}
2550
2551		/*
2552		 * We want this to be reflected on every label,
2553		 * so mark them all dirty.  spa_unload() will do the
2554		 * final sync that pushes these changes out.
2555		 */
2556		if (new_state != POOL_STATE_UNINITIALIZED) {
2557			spa_config_enter(spa, RW_WRITER, FTAG);
2558			spa->spa_state = new_state;
2559			spa->spa_final_txg = spa_last_synced_txg(spa) + 1;
2560			vdev_config_dirty(spa->spa_root_vdev);
2561			spa_config_exit(spa, FTAG);
2562		}
2563	}
2564
2565	spa_event_notify(spa, NULL, ESC_ZFS_POOL_DESTROY);
2566
2567	if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
2568		spa_unload(spa);
2569		spa_deactivate(spa);
2570	}
2571
2572	if (oldconfig && spa->spa_config)
2573		VERIFY(nvlist_dup(spa->spa_config, oldconfig, 0) == 0);
2574
2575	if (new_state != POOL_STATE_UNINITIALIZED) {
2576		spa_config_sync(spa, B_TRUE, B_TRUE);
2577		spa_remove(spa);
2578	}
2579	mutex_exit(&spa_namespace_lock);
2580
2581	return (0);
2582}
2583
2584/*
2585 * Destroy a storage pool.
2586 */
2587int
2588spa_destroy(char *pool)
2589{
2590	return (spa_export_common(pool, POOL_STATE_DESTROYED, NULL));
2591}
2592
2593/*
2594 * Export a storage pool.
2595 */
2596int
2597spa_export(char *pool, nvlist_t **oldconfig)
2598{
2599	return (spa_export_common(pool, POOL_STATE_EXPORTED, oldconfig));
2600}
2601
2602/*
2603 * Similar to spa_export(), this unloads the spa_t without actually removing it
2604 * from the namespace in any way.
2605 */
2606int
2607spa_reset(char *pool)
2608{
2609	return (spa_export_common(pool, POOL_STATE_UNINITIALIZED, NULL));
2610}
2611
2612/*
2613 * ==========================================================================
2614 * Device manipulation
2615 * ==========================================================================
2616 */
2617
2618/*
2619 * Add a device to a storage pool.
2620 */
2621int
2622spa_vdev_add(spa_t *spa, nvlist_t *nvroot)
2623{
2624	uint64_t txg;
2625	int c, error;
2626	vdev_t *rvd = spa->spa_root_vdev;
2627	vdev_t *vd, *tvd;
2628	nvlist_t **spares, **l2cache;
2629	uint_t nspares, nl2cache;
2630
2631	txg = spa_vdev_enter(spa);
2632
2633	if ((error = spa_config_parse(spa, &vd, nvroot, NULL, 0,
2634	    VDEV_ALLOC_ADD)) != 0)
2635		return (spa_vdev_exit(spa, NULL, txg, error));
2636
2637	spa->spa_pending_vdev = vd;
2638
2639	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, &spares,
2640	    &nspares) != 0)
2641		nspares = 0;
2642
2643	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, &l2cache,
2644	    &nl2cache) != 0)
2645		nl2cache = 0;
2646
2647	if (vd->vdev_children == 0 && nspares == 0 && nl2cache == 0) {
2648		spa->spa_pending_vdev = NULL;
2649		return (spa_vdev_exit(spa, vd, txg, EINVAL));
2650	}
2651
2652	if (vd->vdev_children != 0) {
2653		if ((error = vdev_create(vd, txg, B_FALSE)) != 0) {
2654			spa->spa_pending_vdev = NULL;
2655			return (spa_vdev_exit(spa, vd, txg, error));
2656		}
2657	}
2658
2659	/*
2660	 * We must validate the spares and l2cache devices after checking the
2661	 * children.  Otherwise, vdev_inuse() will blindly overwrite the spare.
2662	 */
2663	if ((error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) != 0) {
2664		spa->spa_pending_vdev = NULL;
2665		return (spa_vdev_exit(spa, vd, txg, error));
2666	}
2667
2668	spa->spa_pending_vdev = NULL;
2669
2670	/*
2671	 * Transfer each new top-level vdev from vd to rvd.
2672	 */
2673	for (c = 0; c < vd->vdev_children; c++) {
2674		tvd = vd->vdev_child[c];
2675		vdev_remove_child(vd, tvd);
2676		tvd->vdev_id = rvd->vdev_children;
2677		vdev_add_child(rvd, tvd);
2678		vdev_config_dirty(tvd);
2679	}
2680
2681	if (nspares != 0) {
2682		spa_set_aux_vdevs(&spa->spa_spares, spares, nspares,
2683		    ZPOOL_CONFIG_SPARES);
2684		spa_load_spares(spa);
2685		spa->spa_spares.sav_sync = B_TRUE;
2686	}
2687
2688	if (nl2cache != 0) {
2689		spa_set_aux_vdevs(&spa->spa_l2cache, l2cache, nl2cache,
2690		    ZPOOL_CONFIG_L2CACHE);
2691		spa_load_l2cache(spa);
2692		spa->spa_l2cache.sav_sync = B_TRUE;
2693	}
2694
2695	/*
2696	 * We have to be careful when adding new vdevs to an existing pool.
2697	 * If other threads start allocating from these vdevs before we
2698	 * sync the config cache, and we lose power, then upon reboot we may
2699	 * fail to open the pool because there are DVAs that the config cache
2700	 * can't translate.  Therefore, we first add the vdevs without
2701	 * initializing metaslabs; sync the config cache (via spa_vdev_exit());
2702	 * and then let spa_config_update() initialize the new metaslabs.
2703	 *
2704	 * spa_load() checks for added-but-not-initialized vdevs, so that
2705	 * if we lose power at any point in this sequence, the remaining
2706	 * steps will be completed the next time we load the pool.
2707	 */
2708	(void) spa_vdev_exit(spa, vd, txg, 0);
2709
2710	mutex_enter(&spa_namespace_lock);
2711	spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
2712	mutex_exit(&spa_namespace_lock);
2713
2714	return (0);
2715}
2716
2717/*
2718 * Attach a device to a mirror.  The arguments are the path to any device
2719 * in the mirror, and the nvroot for the new device.  If the path specifies
2720 * a device that is not mirrored, we automatically insert the mirror vdev.
2721 *
2722 * If 'replacing' is specified, the new device is intended to replace the
2723 * existing device; in this case the two devices are made into their own
2724 * mirror using the 'replacing' vdev, which is functionally identical to
2725 * the mirror vdev (it actually reuses all the same ops) but has a few
2726 * extra rules: you can't attach to it after it's been created, and upon
2727 * completion of resilvering, the first disk (the one being replaced)
2728 * is automatically detached.
2729 */
2730int
2731spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot, int replacing)
2732{
2733	uint64_t txg, open_txg;
2734	int error;
2735	vdev_t *rvd = spa->spa_root_vdev;
2736	vdev_t *oldvd, *newvd, *newrootvd, *pvd, *tvd;
2737	vdev_ops_t *pvops;
2738	int is_log;
2739
2740	txg = spa_vdev_enter(spa);
2741
2742	oldvd = spa_lookup_by_guid(spa, guid, B_FALSE);
2743
2744	if (oldvd == NULL)
2745		return (spa_vdev_exit(spa, NULL, txg, ENODEV));
2746
2747	if (!oldvd->vdev_ops->vdev_op_leaf)
2748		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
2749
2750	pvd = oldvd->vdev_parent;
2751
2752	if ((error = spa_config_parse(spa, &newrootvd, nvroot, NULL, 0,
2753	    VDEV_ALLOC_ADD)) != 0)
2754		return (spa_vdev_exit(spa, NULL, txg, EINVAL));
2755
2756	if (newrootvd->vdev_children != 1)
2757		return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));
2758
2759	newvd = newrootvd->vdev_child[0];
2760
2761	if (!newvd->vdev_ops->vdev_op_leaf)
2762		return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));
2763
2764	if ((error = vdev_create(newrootvd, txg, replacing)) != 0)
2765		return (spa_vdev_exit(spa, newrootvd, txg, error));
2766
2767	/*
2768	 * Spares can't replace logs
2769	 */
2770	is_log = oldvd->vdev_islog;
2771	if (is_log && newvd->vdev_isspare)
2772		return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2773
2774	if (!replacing) {
2775		/*
2776		 * For attach, the only allowable parent is a mirror or the root
2777		 * vdev.
2778		 */
2779		if (pvd->vdev_ops != &vdev_mirror_ops &&
2780		    pvd->vdev_ops != &vdev_root_ops)
2781			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2782
2783		pvops = &vdev_mirror_ops;
2784	} else {
2785		/*
2786		 * Active hot spares can only be replaced by inactive hot
2787		 * spares.
2788		 */
2789		if (pvd->vdev_ops == &vdev_spare_ops &&
2790		    pvd->vdev_child[1] == oldvd &&
2791		    !spa_has_spare(spa, newvd->vdev_guid))
2792			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2793
2794		/*
2795		 * If the source is a hot spare, and the parent isn't already a
2796		 * spare, then we want to create a new hot spare.  Otherwise, we
2797		 * want to create a replacing vdev.  The user is not allowed to
2798		 * attach to a spared vdev child unless the 'isspare' state is
2799		 * the same (spare replaces spare, non-spare replaces
2800		 * non-spare).
2801		 */
2802		if (pvd->vdev_ops == &vdev_replacing_ops)
2803			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2804		else if (pvd->vdev_ops == &vdev_spare_ops &&
2805		    newvd->vdev_isspare != oldvd->vdev_isspare)
2806			return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
2807		else if (pvd->vdev_ops != &vdev_spare_ops &&
2808		    newvd->vdev_isspare)
2809			pvops = &vdev_spare_ops;
2810		else
2811			pvops = &vdev_replacing_ops;
2812	}
2813
2814	/*
2815	 * Compare the new device size with the replaceable/attachable
2816	 * device size.
2817	 */
2818	if (newvd->vdev_psize < vdev_get_rsize(oldvd))
2819		return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW));
2820
2821	/*
2822	 * The new device cannot have a higher alignment requirement
2823	 * than the top-level vdev.
2824	 */
2825	if (newvd->vdev_ashift > oldvd->vdev_top->vdev_ashift)
2826		return (spa_vdev_exit(spa, newrootvd, txg, EDOM));
2827
2828	/*
2829	 * If this is an in-place replacement, update oldvd's path and devid
2830	 * to make it distinguishable from newvd, and unopenable from now on.
2831	 */
2832	if (strcmp(oldvd->vdev_path, newvd->vdev_path) == 0) {
2833		spa_strfree(oldvd->vdev_path);
2834		oldvd->vdev_path = kmem_alloc(strlen(newvd->vdev_path) + 5,
2835		    KM_SLEEP);
2836		(void) sprintf(oldvd->vdev_path, "%s/%s",
2837		    newvd->vdev_path, "old");
2838		if (oldvd->vdev_devid != NULL) {
2839			spa_strfree(oldvd->vdev_devid);
2840			oldvd->vdev_devid = NULL;
2841		}
2842	}
2843
2844	/*
2845	 * If the parent is not a mirror, or if we're replacing, insert the new
2846	 * mirror/replacing/spare vdev above oldvd.
2847	 */
2848	if (pvd->vdev_ops != pvops)
2849		pvd = vdev_add_parent(oldvd, pvops);
2850
2851	ASSERT(pvd->vdev_top->vdev_parent == rvd);
2852	ASSERT(pvd->vdev_ops == pvops);
2853	ASSERT(oldvd->vdev_parent == pvd);
2854
2855	/*
2856	 * Extract the new device from its root and add it to pvd.
2857	 */
2858	vdev_remove_child(newrootvd, newvd);
2859	newvd->vdev_id = pvd->vdev_children;
2860	vdev_add_child(pvd, newvd);
2861
2862	/*
2863	 * If newvd is smaller than oldvd, but larger than its rsize,
2864	 * the addition of newvd may have decreased our parent's asize.
2865	 */
2866	pvd->vdev_asize = MIN(pvd->vdev_asize, newvd->vdev_asize);
2867
2868	tvd = newvd->vdev_top;
2869	ASSERT(pvd->vdev_top == tvd);
2870	ASSERT(tvd->vdev_parent == rvd);
2871
2872	vdev_config_dirty(tvd);
2873
2874	/*
2875	 * Set newvd's DTL to [TXG_INITIAL, open_txg].  It will propagate
2876	 * upward when spa_vdev_exit() calls vdev_dtl_reassess().
2877	 */
2878	open_txg = txg + TXG_CONCURRENT_STATES - 1;
2879
2880	mutex_enter(&newvd->vdev_dtl_lock);
2881	space_map_add(&newvd->vdev_dtl_map, TXG_INITIAL,
2882	    open_txg - TXG_INITIAL + 1);
2883	mutex_exit(&newvd->vdev_dtl_lock);
2884
2885	if (newvd->vdev_isspare)
2886		spa_spare_activate(newvd);
2887
2888	/*
2889	 * Mark newvd's DTL dirty in this txg.
2890	 */
2891	vdev_dirty(tvd, VDD_DTL, newvd, txg);
2892
2893	(void) spa_vdev_exit(spa, newrootvd, open_txg, 0);
2894
2895	/*
2896	 * Kick off a resilver to update newvd.
2897	 */
2898	VERIFY3U(spa_scrub(spa, POOL_SCRUB_RESILVER), ==, 0);
2899
2900	return (0);
2901}
2902
2903/*
2904 * Detach a device from a mirror or replacing vdev.
2905 * If 'replace_done' is specified, only detach if the parent
2906 * is a replacing vdev.
2907 */
2908int
2909spa_vdev_detach(spa_t *spa, uint64_t guid, int replace_done)
2910{
2911	uint64_t txg;
2912	int c, t, error;
2913	vdev_t *rvd = spa->spa_root_vdev;
2914	vdev_t *vd, *pvd, *cvd, *tvd;
2915	boolean_t unspare = B_FALSE;
2916	uint64_t unspare_guid;
2917	size_t len;
2918
2919	txg = spa_vdev_enter(spa);
2920
2921	vd = spa_lookup_by_guid(spa, guid, B_FALSE);
2922
2923	if (vd == NULL)
2924		return (spa_vdev_exit(spa, NULL, txg, ENODEV));
2925
2926	if (!vd->vdev_ops->vdev_op_leaf)
2927		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
2928
2929	pvd = vd->vdev_parent;
2930
2931	/*
2932	 * If replace_done is specified, only remove this device if it's
2933	 * the first child of a replacing vdev.  For the 'spare' vdev, either
2934	 * disk can be removed.
2935	 */
2936	if (replace_done) {
2937		if (pvd->vdev_ops == &vdev_replacing_ops) {
2938			if (vd->vdev_id != 0)
2939				return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
2940		} else if (pvd->vdev_ops != &vdev_spare_ops) {
2941			return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
2942		}
2943	}
2944
2945	ASSERT(pvd->vdev_ops != &vdev_spare_ops ||
2946	    spa_version(spa) >= SPA_VERSION_SPARES);
2947
2948	/*
2949	 * Only mirror, replacing, and spare vdevs support detach.
2950	 */
2951	if (pvd->vdev_ops != &vdev_replacing_ops &&
2952	    pvd->vdev_ops != &vdev_mirror_ops &&
2953	    pvd->vdev_ops != &vdev_spare_ops)
2954		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
2955
2956	/*
2957	 * If there's only one replica, you can't detach it.
2958	 */
2959	if (pvd->vdev_children <= 1)
2960		return (spa_vdev_exit(spa, NULL, txg, EBUSY));
2961
2962	/*
2963	 * If all siblings have non-empty DTLs, this device may have the only
2964	 * valid copy of the data, which means we cannot safely detach it.
2965	 *
2966	 * XXX -- as in the vdev_offline() case, we really want a more
2967	 * precise DTL check.
2968	 */
2969	for (c = 0; c < pvd->vdev_children; c++) {
2970		uint64_t dirty;
2971
2972		cvd = pvd->vdev_child[c];
2973		if (cvd == vd)
2974			continue;
2975		if (vdev_is_dead(cvd))
2976			continue;
2977		mutex_enter(&cvd->vdev_dtl_lock);
2978		dirty = cvd->vdev_dtl_map.sm_space |
2979		    cvd->vdev_dtl_scrub.sm_space;
2980		mutex_exit(&cvd->vdev_dtl_lock);
2981		if (!dirty)
2982			break;
2983	}
2984
2985	/*
2986	 * If we are a replacing or spare vdev, then we can always detach the
2987	 * latter child, as that is how one cancels the operation.
2988	 */
2989	if ((pvd->vdev_ops == &vdev_mirror_ops || vd->vdev_id != 1) &&
2990	    c == pvd->vdev_children)
2991		return (spa_vdev_exit(spa, NULL, txg, EBUSY));
2992
2993	/*
2994	 * If we are detaching the second disk from a replacing vdev, then
2995	 * check to see if we changed the original vdev's path to have "/old"
2996	 * at the end in spa_vdev_attach().  If so, undo that change now.
2997	 */
2998	if (pvd->vdev_ops == &vdev_replacing_ops && vd->vdev_id == 1 &&
2999	    pvd->vdev_child[0]->vdev_path != NULL &&
3000	    pvd->vdev_child[1]->vdev_path != NULL) {
3001		ASSERT(pvd->vdev_child[1] == vd);
3002		cvd = pvd->vdev_child[0];
3003		len = strlen(vd->vdev_path);
3004		if (strncmp(cvd->vdev_path, vd->vdev_path, len) == 0 &&
3005		    strcmp(cvd->vdev_path + len, "/old") == 0) {
3006			spa_strfree(cvd->vdev_path);
3007			cvd->vdev_path = spa_strdup(vd->vdev_path);
3008		}
3009	}
3010
3011	/*
3012	 * If we are detaching the original disk from a spare, then it implies
3013	 * that the spare should become a real disk, and be removed from the
3014	 * active spare list for the pool.
3015	 */
3016	if (pvd->vdev_ops == &vdev_spare_ops &&
3017	    vd->vdev_id == 0)
3018		unspare = B_TRUE;
3019
3020	/*
3021	 * Erase the disk labels so the disk can be used for other things.
3022	 * This must be done after all other error cases are handled,
3023	 * but before we disembowel vd (so we can still do I/O to it).
3024	 * But if we can't do it, don't treat the error as fatal --
3025	 * it may be that the unwritability of the disk is the reason
3026	 * it's being detached!
3027	 */
3028	error = vdev_label_init(vd, 0, VDEV_LABEL_REMOVE);
3029
3030	/*
3031	 * Remove vd from its parent and compact the parent's children.
3032	 */
3033	vdev_remove_child(pvd, vd);
3034	vdev_compact_children(pvd);
3035
3036	/*
3037	 * Remember one of the remaining children so we can get tvd below.
3038	 */
3039	cvd = pvd->vdev_child[0];
3040
3041	/*
3042	 * If we need to remove the remaining child from the list of hot spares,
3043	 * do it now, marking the vdev as no longer a spare in the process.  We
3044	 * must do this before vdev_remove_parent(), because that can change the
3045	 * GUID if it creates a new toplevel GUID.
3046	 */
3047	if (unspare) {
3048		ASSERT(cvd->vdev_isspare);
3049		spa_spare_remove(cvd);
3050		unspare_guid = cvd->vdev_guid;
3051	}
3052
3053	/*
3054	 * If the parent mirror/replacing vdev only has one child,
3055	 * the parent is no longer needed.  Remove it from the tree.
3056	 */
3057	if (pvd->vdev_children == 1)
3058		vdev_remove_parent(cvd);
3059
3060	/*
3061	 * We don't set tvd until now because the parent we just removed
3062	 * may have been the previous top-level vdev.
3063	 */
3064	tvd = cvd->vdev_top;
3065	ASSERT(tvd->vdev_parent == rvd);
3066
3067	/*
3068	 * Reevaluate the parent vdev state.
3069	 */
3070	vdev_propagate_state(cvd);
3071
3072	/*
3073	 * If the device we just detached was smaller than the others, it may be
3074	 * possible to add metaslabs (i.e. grow the pool).  vdev_metaslab_init()
3075	 * can't fail because the existing metaslabs are already in core, so
3076	 * there's nothing to read from disk.
3077	 */
3078	VERIFY(vdev_metaslab_init(tvd, txg) == 0);
3079
3080	vdev_config_dirty(tvd);
3081
3082	/*
3083	 * Mark vd's DTL as dirty in this txg.  vdev_dtl_sync() will see that
3084	 * vd->vdev_detached is set and free vd's DTL object in syncing context.
3085	 * But first make sure we're not on any *other* txg's DTL list, to
3086	 * prevent vd from being accessed after it's freed.
3087	 */
3088	for (t = 0; t < TXG_SIZE; t++)
3089		(void) txg_list_remove_this(&tvd->vdev_dtl_list, vd, t);
3090	vd->vdev_detached = B_TRUE;
3091	vdev_dirty(tvd, VDD_DTL, vd, txg);
3092
3093	spa_event_notify(spa, vd, ESC_ZFS_VDEV_REMOVE);
3094
3095	error = spa_vdev_exit(spa, vd, txg, 0);
3096
3097	/*
3098	 * If this was the removal of the original device in a hot spare vdev,
3099	 * then we want to go through and remove the device from the hot spare
3100	 * list of every other pool.
3101	 */
3102	if (unspare) {
3103		spa = NULL;
3104		mutex_enter(&spa_namespace_lock);
3105		while ((spa = spa_next(spa)) != NULL) {
3106			if (spa->spa_state != POOL_STATE_ACTIVE)
3107				continue;
3108
3109			(void) spa_vdev_remove(spa, unspare_guid, B_TRUE);
3110		}
3111		mutex_exit(&spa_namespace_lock);
3112	}
3113
3114	return (error);
3115}
3116
3117/*
3118 * Remove a spares vdev from the nvlist config.
3119 */
3120static int
3121spa_remove_spares(spa_aux_vdev_t *sav, uint64_t guid, boolean_t unspare,
3122    nvlist_t **spares, int nspares, vdev_t *vd)
3123{
3124	nvlist_t *nv, **newspares;
3125	int i, j;
3126
3127	nv = NULL;
3128	for (i = 0; i < nspares; i++) {
3129		uint64_t theguid;
3130
3131		VERIFY(nvlist_lookup_uint64(spares[i],
3132		    ZPOOL_CONFIG_GUID, &theguid) == 0);
3133		if (theguid == guid) {
3134			nv = spares[i];
3135			break;
3136		}
3137	}
3138
3139	/*
3140	 * Only remove the hot spare if it's not currently in use in this pool.
3141	 */
3142	if (nv == NULL && vd == NULL)
3143		return (ENOENT);
3144
3145	if (nv == NULL && vd != NULL)
3146		return (ENOTSUP);
3147
3148	if (!unspare && nv != NULL && vd != NULL)
3149		return (EBUSY);
3150
3151	if (nspares == 1) {
3152		newspares = NULL;
3153	} else {
3154		newspares = kmem_alloc((nspares - 1) * sizeof (void *),
3155		    KM_SLEEP);
3156		for (i = 0, j = 0; i < nspares; i++) {
3157			if (spares[i] != nv)
3158				VERIFY(nvlist_dup(spares[i],
3159				    &newspares[j++], KM_SLEEP) == 0);
3160		}
3161	}
3162
3163	VERIFY(nvlist_remove(sav->sav_config, ZPOOL_CONFIG_SPARES,
3164	    DATA_TYPE_NVLIST_ARRAY) == 0);
3165	VERIFY(nvlist_add_nvlist_array(sav->sav_config,
3166	    ZPOOL_CONFIG_SPARES, newspares, nspares - 1) == 0);
3167	for (i = 0; i < nspares - 1; i++)
3168		nvlist_free(newspares[i]);
3169	kmem_free(newspares, (nspares - 1) * sizeof (void *));
3170
3171	return (0);
3172}
3173
3174/*
3175 * Remove an l2cache vdev from the nvlist config.
3176 */
3177static int
3178spa_remove_l2cache(spa_aux_vdev_t *sav, uint64_t guid, nvlist_t **l2cache,
3179    int nl2cache, vdev_t *vd)
3180{
3181	nvlist_t *nv, **newl2cache;
3182	int i, j;
3183
3184	nv = NULL;
3185	for (i = 0; i < nl2cache; i++) {
3186		uint64_t theguid;
3187
3188		VERIFY(nvlist_lookup_uint64(l2cache[i],
3189		    ZPOOL_CONFIG_GUID, &theguid) == 0);
3190		if (theguid == guid) {
3191			nv = l2cache[i];
3192			break;
3193		}
3194	}
3195
3196	if (vd == NULL) {
3197		for (i = 0; i < nl2cache; i++) {
3198			if (sav->sav_vdevs[i]->vdev_guid == guid) {
3199				vd = sav->sav_vdevs[i];
3200				break;
3201			}
3202		}
3203	}
3204
3205	if (nv == NULL && vd == NULL)
3206		return (ENOENT);
3207
3208	if (nv == NULL && vd != NULL)
3209		return (ENOTSUP);
3210
3211	if (nl2cache == 1) {
3212		newl2cache = NULL;
3213	} else {
3214		newl2cache = kmem_alloc((nl2cache - 1) * sizeof (void *),
3215		    KM_SLEEP);
3216		for (i = 0, j = 0; i < nl2cache; i++) {
3217			if (l2cache[i] != nv)
3218				VERIFY(nvlist_dup(l2cache[i],
3219				    &newl2cache[j++], KM_SLEEP) == 0);
3220		}
3221	}
3222
3223	VERIFY(nvlist_remove(sav->sav_config, ZPOOL_CONFIG_L2CACHE,
3224	    DATA_TYPE_NVLIST_ARRAY) == 0);
3225	VERIFY(nvlist_add_nvlist_array(sav->sav_config,
3226	    ZPOOL_CONFIG_L2CACHE, newl2cache, nl2cache - 1) == 0);
3227	for (i = 0; i < nl2cache - 1; i++)
3228		nvlist_free(newl2cache[i]);
3229	kmem_free(newl2cache, (nl2cache - 1) * sizeof (void *));
3230
3231	return (0);
3232}
3233
3234/*
3235 * Remove a device from the pool.  Currently, this supports removing only hot
3236 * spares and level 2 ARC devices.
3237 */
3238int
3239spa_vdev_remove(spa_t *spa, uint64_t guid, boolean_t unspare)
3240{
3241	vdev_t *vd;
3242	nvlist_t **spares, **l2cache;
3243	uint_t nspares, nl2cache;
3244	int error = 0;
3245
3246	spa_config_enter(spa, RW_WRITER, FTAG);
3247
3248	vd = spa_lookup_by_guid(spa, guid, B_FALSE);
3249
3250	if (spa->spa_spares.sav_vdevs != NULL &&
3251	    nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
3252	    ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0) {
3253		if ((error = spa_remove_spares(&spa->spa_spares, guid, unspare,
3254		    spares, nspares, vd)) != 0)
3255			goto out;
3256		spa_load_spares(spa);
3257		spa->spa_spares.sav_sync = B_TRUE;
3258		goto out;
3259	}
3260
3261	if (spa->spa_l2cache.sav_vdevs != NULL &&
3262	    nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config,
3263	    ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0) {
3264		if ((error = spa_remove_l2cache(&spa->spa_l2cache, guid,
3265		    l2cache, nl2cache, vd)) != 0)
3266			goto out;
3267		spa_load_l2cache(spa);
3268		spa->spa_l2cache.sav_sync = B_TRUE;
3269	}
3270
3271out:
3272	spa_config_exit(spa, FTAG);
3273	return (error);
3274}
3275
3276/*
3277 * Find any device that's done replacing, or a vdev marked 'unspare' that's
3278 * current spared, so we can detach it.
3279 */
3280static vdev_t *
3281spa_vdev_resilver_done_hunt(vdev_t *vd)
3282{
3283	vdev_t *newvd, *oldvd;
3284	int c;
3285
3286	for (c = 0; c < vd->vdev_children; c++) {
3287		oldvd = spa_vdev_resilver_done_hunt(vd->vdev_child[c]);
3288		if (oldvd != NULL)
3289			return (oldvd);
3290	}
3291
3292	/*
3293	 * Check for a completed replacement.
3294	 */
3295	if (vd->vdev_ops == &vdev_replacing_ops && vd->vdev_children == 2) {
3296		oldvd = vd->vdev_child[0];
3297		newvd = vd->vdev_child[1];
3298
3299		mutex_enter(&newvd->vdev_dtl_lock);
3300		if (newvd->vdev_dtl_map.sm_space == 0 &&
3301		    newvd->vdev_dtl_scrub.sm_space == 0) {
3302			mutex_exit(&newvd->vdev_dtl_lock);
3303			return (oldvd);
3304		}
3305		mutex_exit(&newvd->vdev_dtl_lock);
3306	}
3307
3308	/*
3309	 * Check for a completed resilver with the 'unspare' flag set.
3310	 */
3311	if (vd->vdev_ops == &vdev_spare_ops && vd->vdev_children == 2) {
3312		newvd = vd->vdev_child[0];
3313		oldvd = vd->vdev_child[1];
3314
3315		mutex_enter(&newvd->vdev_dtl_lock);
3316		if (newvd->vdev_unspare &&
3317		    newvd->vdev_dtl_map.sm_space == 0 &&
3318		    newvd->vdev_dtl_scrub.sm_space == 0) {
3319			newvd->vdev_unspare = 0;
3320			mutex_exit(&newvd->vdev_dtl_lock);
3321			return (oldvd);
3322		}
3323		mutex_exit(&newvd->vdev_dtl_lock);
3324	}
3325
3326	return (NULL);
3327}
3328
3329static void
3330spa_vdev_resilver_done(spa_t *spa)
3331{
3332	vdev_t *vd;
3333	vdev_t *pvd;
3334	uint64_t guid;
3335	uint64_t pguid = 0;
3336
3337	spa_config_enter(spa, RW_READER, FTAG);
3338
3339	while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) {
3340		guid = vd->vdev_guid;
3341		/*
3342		 * If we have just finished replacing a hot spared device, then
3343		 * we need to detach the parent's first child (the original hot
3344		 * spare) as well.
3345		 */
3346		pvd = vd->vdev_parent;
3347		if (pvd->vdev_parent->vdev_ops == &vdev_spare_ops &&
3348		    pvd->vdev_id == 0) {
3349			ASSERT(pvd->vdev_ops == &vdev_replacing_ops);
3350			ASSERT(pvd->vdev_parent->vdev_children == 2);
3351			pguid = pvd->vdev_parent->vdev_child[1]->vdev_guid;
3352		}
3353		spa_config_exit(spa, FTAG);
3354		if (spa_vdev_detach(spa, guid, B_TRUE) != 0)
3355			return;
3356		if (pguid != 0 && spa_vdev_detach(spa, pguid, B_TRUE) != 0)
3357			return;
3358		spa_config_enter(spa, RW_READER, FTAG);
3359	}
3360
3361	spa_config_exit(spa, FTAG);
3362}
3363
3364/*
3365 * Update the stored path for this vdev.  Dirty the vdev configuration, relying
3366 * on spa_vdev_enter/exit() to synchronize the labels and cache.
3367 */
3368int
3369spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath)
3370{
3371	vdev_t *vd;
3372	uint64_t txg;
3373
3374	txg = spa_vdev_enter(spa);
3375
3376	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL) {
3377		/*
3378		 * Determine if this is a reference to a hot spare device.  If
3379		 * it is, update the path manually as there is no associated
3380		 * vdev_t that can be synced to disk.
3381		 */
3382		nvlist_t **spares;
3383		uint_t i, nspares;
3384
3385		if (spa->spa_spares.sav_config != NULL) {
3386			VERIFY(nvlist_lookup_nvlist_array(
3387			    spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES,
3388			    &spares, &nspares) == 0);
3389			for (i = 0; i < nspares; i++) {
3390				uint64_t theguid;
3391				VERIFY(nvlist_lookup_uint64(spares[i],
3392				    ZPOOL_CONFIG_GUID, &theguid) == 0);
3393				if (theguid == guid) {
3394					VERIFY(nvlist_add_string(spares[i],
3395					    ZPOOL_CONFIG_PATH, newpath) == 0);
3396					spa_load_spares(spa);
3397					spa->spa_spares.sav_sync = B_TRUE;
3398					return (spa_vdev_exit(spa, NULL, txg,
3399					    0));
3400				}
3401			}
3402		}
3403
3404		return (spa_vdev_exit(spa, NULL, txg, ENOENT));
3405	}
3406
3407	if (!vd->vdev_ops->vdev_op_leaf)
3408		return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));
3409
3410	spa_strfree(vd->vdev_path);
3411	vd->vdev_path = spa_strdup(newpath);
3412
3413	vdev_config_dirty(vd->vdev_top);
3414
3415	return (spa_vdev_exit(spa, NULL, txg, 0));
3416}
3417
3418/*
3419 * ==========================================================================
3420 * SPA Scrubbing
3421 * ==========================================================================
3422 */
3423
3424int
3425spa_scrub(spa_t *spa, pool_scrub_type_t type)
3426{
3427	ASSERT(!spa_config_held(spa, RW_WRITER));
3428
3429	if ((uint_t)type >= POOL_SCRUB_TYPES)
3430		return (ENOTSUP);
3431
3432	/*
3433	 * If a resilver was requested, but there is no DTL on a
3434	 * writeable leaf device, we have nothing to do.
3435	 */
3436	if (type == POOL_SCRUB_RESILVER &&
3437	    !vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) {
3438		spa_async_request(spa, SPA_ASYNC_RESILVER_DONE);
3439		return (0);
3440	}
3441
3442	if (type == POOL_SCRUB_EVERYTHING &&
3443	    spa->spa_dsl_pool->dp_scrub_func != SCRUB_FUNC_NONE &&
3444	    spa->spa_dsl_pool->dp_scrub_isresilver)
3445		return (EBUSY);
3446
3447	if (type == POOL_SCRUB_EVERYTHING || type == POOL_SCRUB_RESILVER) {
3448		return (dsl_pool_scrub_clean(spa->spa_dsl_pool));
3449	} else if (type == POOL_SCRUB_NONE) {
3450		return (dsl_pool_scrub_cancel(spa->spa_dsl_pool));
3451	} else {
3452		return (EINVAL);
3453	}
3454}
3455
3456/*
3457 * ==========================================================================
3458 * SPA async task processing
3459 * ==========================================================================
3460 */
3461
3462static void
3463spa_async_remove(spa_t *spa, vdev_t *vd)
3464{
3465	vdev_t *tvd;
3466	int c;
3467
3468	for (c = 0; c < vd->vdev_children; c++) {
3469		tvd = vd->vdev_child[c];
3470		if (tvd->vdev_remove_wanted) {
3471			tvd->vdev_remove_wanted = 0;
3472			vdev_set_state(tvd, B_FALSE, VDEV_STATE_REMOVED,
3473			    VDEV_AUX_NONE);
3474			vdev_clear(spa, tvd, B_TRUE);
3475			vdev_config_dirty(tvd->vdev_top);
3476		}
3477		spa_async_remove(spa, tvd);
3478	}
3479}
3480
3481static void
3482spa_async_thread(spa_t *spa)
3483{
3484	int tasks;
3485	uint64_t txg;
3486
3487	ASSERT(spa->spa_sync_on);
3488
3489	mutex_enter(&spa->spa_async_lock);
3490	tasks = spa->spa_async_tasks;
3491	spa->spa_async_tasks = 0;
3492	mutex_exit(&spa->spa_async_lock);
3493
3494	/*
3495	 * See if the config needs to be updated.
3496	 */
3497	if (tasks & SPA_ASYNC_CONFIG_UPDATE) {
3498		mutex_enter(&spa_namespace_lock);
3499		spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
3500		mutex_exit(&spa_namespace_lock);
3501	}
3502
3503	/*
3504	 * See if any devices need to be marked REMOVED.
3505	 *
3506	 * XXX - We avoid doing this when we are in
3507	 * I/O failure state since spa_vdev_enter() grabs
3508	 * the namespace lock and would not be able to obtain
3509	 * the writer config lock.
3510	 */
3511	if (tasks & SPA_ASYNC_REMOVE &&
3512	    spa_state(spa) != POOL_STATE_IO_FAILURE) {
3513		txg = spa_vdev_enter(spa);
3514		spa_async_remove(spa, spa->spa_root_vdev);
3515		(void) spa_vdev_exit(spa, NULL, txg, 0);
3516	}
3517
3518	/*
3519	 * If any devices are done replacing, detach them.
3520	 */
3521	if (tasks & SPA_ASYNC_RESILVER_DONE)
3522		spa_vdev_resilver_done(spa);
3523
3524	/*
3525	 * Kick off a resilver.
3526	 */
3527	if (tasks & SPA_ASYNC_RESILVER)
3528		VERIFY(spa_scrub(spa, POOL_SCRUB_RESILVER) == 0);
3529
3530	/*
3531	 * Let the world know that we're done.
3532	 */
3533	mutex_enter(&spa->spa_async_lock);
3534	spa->spa_async_thread = NULL;
3535	cv_broadcast(&spa->spa_async_cv);
3536	mutex_exit(&spa->spa_async_lock);
3537	thread_exit();
3538}
3539
3540void
3541spa_async_suspend(spa_t *spa)
3542{
3543	mutex_enter(&spa->spa_async_lock);
3544	spa->spa_async_suspended++;
3545	while (spa->spa_async_thread != NULL)
3546		cv_wait(&spa->spa_async_cv, &spa->spa_async_lock);
3547	mutex_exit(&spa->spa_async_lock);
3548}
3549
3550void
3551spa_async_resume(spa_t *spa)
3552{
3553	mutex_enter(&spa->spa_async_lock);
3554	ASSERT(spa->spa_async_suspended != 0);
3555	spa->spa_async_suspended--;
3556	mutex_exit(&spa->spa_async_lock);
3557}
3558
3559static void
3560spa_async_dispatch(spa_t *spa)
3561{
3562	mutex_enter(&spa->spa_async_lock);
3563	if (spa->spa_async_tasks && !spa->spa_async_suspended &&
3564	    spa->spa_async_thread == NULL &&
3565	    rootdir != NULL && !vn_is_readonly(rootdir))
3566		spa->spa_async_thread = thread_create(NULL, 0,
3567		    spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri);
3568	mutex_exit(&spa->spa_async_lock);
3569}
3570
3571void
3572spa_async_request(spa_t *spa, int task)
3573{
3574	mutex_enter(&spa->spa_async_lock);
3575	spa->spa_async_tasks |= task;
3576	mutex_exit(&spa->spa_async_lock);
3577}
3578
3579/*
3580 * ==========================================================================
3581 * SPA syncing routines
3582 * ==========================================================================
3583 */
3584
3585static void
3586spa_sync_deferred_frees(spa_t *spa, uint64_t txg)
3587{
3588	bplist_t *bpl = &spa->spa_sync_bplist;
3589	dmu_tx_t *tx;
3590	blkptr_t blk;
3591	uint64_t itor = 0;
3592	zio_t *zio;
3593	int error;
3594	uint8_t c = 1;
3595
3596	zio = zio_root(spa, NULL, NULL, ZIO_FLAG_CONFIG_HELD);
3597
3598	while (bplist_iterate(bpl, &itor, &blk) == 0)
3599		zio_nowait(zio_free(zio, spa, txg, &blk, NULL, NULL));
3600
3601	error = zio_wait(zio);
3602	ASSERT3U(error, ==, 0);
3603
3604	tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg);
3605	bplist_vacate(bpl, tx);
3606
3607	/*
3608	 * Pre-dirty the first block so we sync to convergence faster.
3609	 * (Usually only the first block is needed.)
3610	 */
3611	dmu_write(spa->spa_meta_objset, spa->spa_sync_bplist_obj, 0, 1, &c, tx);
3612	dmu_tx_commit(tx);
3613}
3614
3615static void
3616spa_sync_nvlist(spa_t *spa, uint64_t obj, nvlist_t *nv, dmu_tx_t *tx)
3617{
3618	char *packed = NULL;
3619	size_t nvsize = 0;
3620	dmu_buf_t *db;
3621
3622	VERIFY(nvlist_size(nv, &nvsize, NV_ENCODE_XDR) == 0);
3623
3624	packed = kmem_alloc(nvsize, KM_SLEEP);
3625
3626	VERIFY(nvlist_pack(nv, &packed, &nvsize, NV_ENCODE_XDR,
3627	    KM_SLEEP) == 0);
3628
3629	dmu_write(spa->spa_meta_objset, obj, 0, nvsize, packed, tx);
3630
3631	kmem_free(packed, nvsize);
3632
3633	VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db));
3634	dmu_buf_will_dirty(db, tx);
3635	*(uint64_t *)db->db_data = nvsize;
3636	dmu_buf_rele(db, FTAG);
3637}
3638
3639static void
3640spa_sync_aux_dev(spa_t *spa, spa_aux_vdev_t *sav, dmu_tx_t *tx,
3641    const char *config, const char *entry)
3642{
3643	nvlist_t *nvroot;
3644	nvlist_t **list;
3645	int i;
3646
3647	if (!sav->sav_sync)
3648		return;
3649
3650	/*
3651	 * Update the MOS nvlist describing the list of available devices.
3652	 * spa_validate_aux() will have already made sure this nvlist is
3653	 * valid and the vdevs are labeled appropriately.
3654	 */
3655	if (sav->sav_object == 0) {
3656		sav->sav_object = dmu_object_alloc(spa->spa_meta_objset,
3657		    DMU_OT_PACKED_NVLIST, 1 << 14, DMU_OT_PACKED_NVLIST_SIZE,
3658		    sizeof (uint64_t), tx);
3659		VERIFY(zap_update(spa->spa_meta_objset,
3660		    DMU_POOL_DIRECTORY_OBJECT, entry, sizeof (uint64_t), 1,
3661		    &sav->sav_object, tx) == 0);
3662	}
3663
3664	VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0);
3665	if (sav->sav_count == 0) {
3666		VERIFY(nvlist_add_nvlist_array(nvroot, config, NULL, 0) == 0);
3667	} else {
3668		list = kmem_alloc(sav->sav_count * sizeof (void *), KM_SLEEP);
3669		for (i = 0; i < sav->sav_count; i++)
3670			list[i] = vdev_config_generate(spa, sav->sav_vdevs[i],
3671			    B_FALSE, B_FALSE, B_TRUE);
3672		VERIFY(nvlist_add_nvlist_array(nvroot, config, list,
3673		    sav->sav_count) == 0);
3674		for (i = 0; i < sav->sav_count; i++)
3675			nvlist_free(list[i]);
3676		kmem_free(list, sav->sav_count * sizeof (void *));
3677	}
3678
3679	spa_sync_nvlist(spa, sav->sav_object, nvroot, tx);
3680	nvlist_free(nvroot);
3681
3682	sav->sav_sync = B_FALSE;
3683}
3684
3685static void
3686spa_sync_config_object(spa_t *spa, dmu_tx_t *tx)
3687{
3688	nvlist_t *config;
3689
3690	if (list_is_empty(&spa->spa_dirty_list))
3691		return;
3692
3693	config = spa_config_generate(spa, NULL, dmu_tx_get_txg(tx), B_FALSE);
3694
3695	if (spa->spa_config_syncing)
3696		nvlist_free(spa->spa_config_syncing);
3697	spa->spa_config_syncing = config;
3698
3699	spa_sync_nvlist(spa, spa->spa_config_object, config, tx);
3700}
3701
3702/*
3703 * Set zpool properties.
3704 */
3705static void
3706spa_sync_props(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)
3707{
3708	spa_t *spa = arg1;
3709	objset_t *mos = spa->spa_meta_objset;
3710	nvlist_t *nvp = arg2;
3711	nvpair_t *elem;
3712	uint64_t intval;
3713	char *strval;
3714	zpool_prop_t prop;
3715	const char *propname;
3716	zprop_type_t proptype;
3717	spa_config_dirent_t *dp;
3718
3719	elem = NULL;
3720	while ((elem = nvlist_next_nvpair(nvp, elem))) {
3721		switch (prop = zpool_name_to_prop(nvpair_name(elem))) {
3722		case ZPOOL_PROP_VERSION:
3723			/*
3724			 * Only set version for non-zpool-creation cases
3725			 * (set/import). spa_create() needs special care
3726			 * for version setting.
3727			 */
3728			if (tx->tx_txg != TXG_INITIAL) {
3729				VERIFY(nvpair_value_uint64(elem,
3730				    &intval) == 0);
3731				ASSERT(intval <= SPA_VERSION);
3732				ASSERT(intval >= spa_version(spa));
3733				spa->spa_uberblock.ub_version = intval;
3734				vdev_config_dirty(spa->spa_root_vdev);
3735			}
3736			break;
3737
3738		case ZPOOL_PROP_ALTROOT:
3739			/*
3740			 * 'altroot' is a non-persistent property. It should
3741			 * have been set temporarily at creation or import time.
3742			 */
3743			ASSERT(spa->spa_root != NULL);
3744			break;
3745
3746		case ZPOOL_PROP_CACHEFILE:
3747			/*
3748			 * 'cachefile' is a non-persistent property, but note
3749			 * an async request that the config cache needs to be
3750			 * udpated.
3751			 */
3752			VERIFY(nvpair_value_string(elem, &strval) == 0);
3753
3754			dp = kmem_alloc(sizeof (spa_config_dirent_t),
3755			    KM_SLEEP);
3756
3757			if (strval[0] == '\0')
3758				dp->scd_path = spa_strdup(spa_config_path);
3759			else if (strcmp(strval, "none") == 0)
3760				dp->scd_path = NULL;
3761			else
3762				dp->scd_path = spa_strdup(strval);
3763
3764			list_insert_head(&spa->spa_config_list, dp);
3765			spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
3766			break;
3767		default:
3768			/*
3769			 * Set pool property values in the poolprops mos object.
3770			 */
3771			mutex_enter(&spa->spa_props_lock);
3772			if (spa->spa_pool_props_object == 0) {
3773				objset_t *mos = spa->spa_meta_objset;
3774
3775				VERIFY((spa->spa_pool_props_object =
3776				    zap_create(mos, DMU_OT_POOL_PROPS,
3777				    DMU_OT_NONE, 0, tx)) > 0);
3778
3779				VERIFY(zap_update(mos,
3780				    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_PROPS,
3781				    8, 1, &spa->spa_pool_props_object, tx)
3782				    == 0);
3783			}
3784			mutex_exit(&spa->spa_props_lock);
3785
3786			/* normalize the property name */
3787			propname = zpool_prop_to_name(prop);
3788			proptype = zpool_prop_get_type(prop);
3789
3790			if (nvpair_type(elem) == DATA_TYPE_STRING) {
3791				ASSERT(proptype == PROP_TYPE_STRING);
3792				VERIFY(nvpair_value_string(elem, &strval) == 0);
3793				VERIFY(zap_update(mos,
3794				    spa->spa_pool_props_object, propname,
3795				    1, strlen(strval) + 1, strval, tx) == 0);
3796
3797			} else if (nvpair_type(elem) == DATA_TYPE_UINT64) {
3798				VERIFY(nvpair_value_uint64(elem, &intval) == 0);
3799
3800				if (proptype == PROP_TYPE_INDEX) {
3801					const char *unused;
3802					VERIFY(zpool_prop_index_to_string(
3803					    prop, intval, &unused) == 0);
3804				}
3805				VERIFY(zap_update(mos,
3806				    spa->spa_pool_props_object, propname,
3807				    8, 1, &intval, tx) == 0);
3808			} else {
3809				ASSERT(0); /* not allowed */
3810			}
3811
3812			switch (prop) {
3813			case ZPOOL_PROP_DELEGATION:
3814				spa->spa_delegation = intval;
3815				break;
3816			case ZPOOL_PROP_BOOTFS:
3817				spa->spa_bootfs = intval;
3818				break;
3819			case ZPOOL_PROP_FAILUREMODE:
3820				spa->spa_failmode = intval;
3821				break;
3822			default:
3823				break;
3824			}
3825		}
3826
3827		/* log internal history if this is not a zpool create */
3828		if (spa_version(spa) >= SPA_VERSION_ZPOOL_HISTORY &&
3829		    tx->tx_txg != TXG_INITIAL) {
3830			spa_history_internal_log(LOG_POOL_PROPSET,
3831			    spa, tx, cr, "%s %lld %s",
3832			    nvpair_name(elem), intval, spa->spa_name);
3833		}
3834	}
3835}
3836
3837/*
3838 * Sync the specified transaction group.  New blocks may be dirtied as
3839 * part of the process, so we iterate until it converges.
3840 */
3841void
3842spa_sync(spa_t *spa, uint64_t txg)
3843{
3844	dsl_pool_t *dp = spa->spa_dsl_pool;
3845	objset_t *mos = spa->spa_meta_objset;
3846	bplist_t *bpl = &spa->spa_sync_bplist;
3847	vdev_t *rvd = spa->spa_root_vdev;
3848	vdev_t *vd;
3849	dmu_tx_t *tx;
3850	int dirty_vdevs;
3851
3852	/*
3853	 * Lock out configuration changes.
3854	 */
3855	spa_config_enter(spa, RW_READER, FTAG);
3856
3857	spa->spa_syncing_txg = txg;
3858	spa->spa_sync_pass = 0;
3859
3860	VERIFY(0 == bplist_open(bpl, mos, spa->spa_sync_bplist_obj));
3861
3862	tx = dmu_tx_create_assigned(dp, txg);
3863
3864	/*
3865	 * If we are upgrading to SPA_VERSION_RAIDZ_DEFLATE this txg,
3866	 * set spa_deflate if we have no raid-z vdevs.
3867	 */
3868	if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE &&
3869	    spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) {
3870		int i;
3871
3872		for (i = 0; i < rvd->vdev_children; i++) {
3873			vd = rvd->vdev_child[i];
3874			if (vd->vdev_deflate_ratio != SPA_MINBLOCKSIZE)
3875				break;
3876		}
3877		if (i == rvd->vdev_children) {
3878			spa->spa_deflate = TRUE;
3879			VERIFY(0 == zap_add(spa->spa_meta_objset,
3880			    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE,
3881			    sizeof (uint64_t), 1, &spa->spa_deflate, tx));
3882		}
3883	}
3884
3885	if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN &&
3886	    spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) {
3887		dsl_pool_create_origin(dp, tx);
3888
3889		/* Keeping the origin open increases spa_minref */
3890		spa->spa_minref += 3;
3891	}
3892
3893	if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES &&
3894	    spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) {
3895		dsl_pool_upgrade_clones(dp, tx);
3896	}
3897
3898	/*
3899	 * If anything has changed in this txg, push the deferred frees
3900	 * from the previous txg.  If not, leave them alone so that we
3901	 * don't generate work on an otherwise idle system.
3902	 */
3903	if (!txg_list_empty(&dp->dp_dirty_datasets, txg) ||
3904	    !txg_list_empty(&dp->dp_dirty_dirs, txg) ||
3905	    !txg_list_empty(&dp->dp_sync_tasks, txg))
3906		spa_sync_deferred_frees(spa, txg);
3907
3908	/*
3909	 * Iterate to convergence.
3910	 */
3911	do {
3912		spa->spa_sync_pass++;
3913
3914		spa_sync_config_object(spa, tx);
3915		spa_sync_aux_dev(spa, &spa->spa_spares, tx,
3916		    ZPOOL_CONFIG_SPARES, DMU_POOL_SPARES);
3917		spa_sync_aux_dev(spa, &spa->spa_l2cache, tx,
3918		    ZPOOL_CONFIG_L2CACHE, DMU_POOL_L2CACHE);
3919		spa_errlog_sync(spa, txg);
3920		dsl_pool_sync(dp, txg);
3921
3922		dirty_vdevs = 0;
3923		while (vd = txg_list_remove(&spa->spa_vdev_txg_list, txg)) {
3924			vdev_sync(vd, txg);
3925			dirty_vdevs++;
3926		}
3927
3928		bplist_sync(bpl, tx);
3929	} while (dirty_vdevs);
3930
3931	bplist_close(bpl);
3932
3933	dprintf("txg %llu passes %d\n", txg, spa->spa_sync_pass);
3934
3935	/*
3936	 * Rewrite the vdev configuration (which includes the uberblock)
3937	 * to commit the transaction group.
3938	 *
3939	 * If there are no dirty vdevs, we sync the uberblock to a few
3940	 * random top-level vdevs that are known to be visible in the
3941	 * config cache (see spa_vdev_add() for details).  If there *are*
3942	 * dirty vdevs -- or if the sync to our random subset fails --
3943	 * then sync the uberblock to all vdevs.
3944	 */
3945	if (list_is_empty(&spa->spa_dirty_list)) {
3946		vdev_t *svd[SPA_DVAS_PER_BP];
3947		int svdcount = 0;
3948		int children = rvd->vdev_children;
3949		int c0 = spa_get_random(children);
3950		int c;
3951
3952		for (c = 0; c < children; c++) {
3953			vd = rvd->vdev_child[(c0 + c) % children];
3954			if (vd->vdev_ms_array == 0 || vd->vdev_islog)
3955				continue;
3956			svd[svdcount++] = vd;
3957			if (svdcount == SPA_DVAS_PER_BP)
3958				break;
3959		}
3960		vdev_config_sync(svd, svdcount, txg);
3961	} else {
3962		vdev_config_sync(rvd->vdev_child, rvd->vdev_children, txg);
3963	}
3964	dmu_tx_commit(tx);
3965
3966	/*
3967	 * Clear the dirty config list.
3968	 */
3969	while ((vd = list_head(&spa->spa_dirty_list)) != NULL)
3970		vdev_config_clean(vd);
3971
3972	/*
3973	 * Now that the new config has synced transactionally,
3974	 * let it become visible to the config cache.
3975	 */
3976	if (spa->spa_config_syncing != NULL) {
3977		spa_config_set(spa, spa->spa_config_syncing);
3978		spa->spa_config_txg = txg;
3979		spa->spa_config_syncing = NULL;
3980	}
3981
3982	spa->spa_traverse_wanted = B_TRUE;
3983	rw_enter(&spa->spa_traverse_lock, RW_WRITER);
3984	spa->spa_traverse_wanted = B_FALSE;
3985	spa->spa_ubsync = spa->spa_uberblock;
3986	rw_exit(&spa->spa_traverse_lock);
3987
3988	/*
3989	 * Clean up the ZIL records for the synced txg.
3990	 */
3991	dsl_pool_zil_clean(dp);
3992
3993	/*
3994	 * Update usable space statistics.
3995	 */
3996	while (vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)))
3997		vdev_sync_done(vd, txg);
3998
3999	/*
4000	 * It had better be the case that we didn't dirty anything
4001	 * since vdev_config_sync().
4002	 */
4003	ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg));
4004	ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg));
4005	ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg));
4006	ASSERT(bpl->bpl_queue == NULL);
4007
4008	spa_config_exit(spa, FTAG);
4009
4010	/*
4011	 * If any async tasks have been requested, kick them off.
4012	 */
4013	spa_async_dispatch(spa);
4014}
4015
4016/*
4017 * Sync all pools.  We don't want to hold the namespace lock across these
4018 * operations, so we take a reference on the spa_t and drop the lock during the
4019 * sync.
4020 */
4021void
4022spa_sync_allpools(void)
4023{
4024	spa_t *spa = NULL;
4025	mutex_enter(&spa_namespace_lock);
4026	while ((spa = spa_next(spa)) != NULL) {
4027		if (spa_state(spa) != POOL_STATE_ACTIVE)
4028			continue;
4029		spa_open_ref(spa, FTAG);
4030		mutex_exit(&spa_namespace_lock);
4031		txg_wait_synced(spa_get_dsl(spa), 0);
4032		mutex_enter(&spa_namespace_lock);
4033		spa_close(spa, FTAG);
4034	}
4035	mutex_exit(&spa_namespace_lock);
4036}
4037
4038/*
4039 * ==========================================================================
4040 * Miscellaneous routines
4041 * ==========================================================================
4042 */
4043
4044/*
4045 * Remove all pools in the system.
4046 */
4047void
4048spa_evict_all(void)
4049{
4050	spa_t *spa;
4051
4052	/*
4053	 * Remove all cached state.  All pools should be closed now,
4054	 * so every spa in the AVL tree should be unreferenced.
4055	 */
4056	mutex_enter(&spa_namespace_lock);
4057	while ((spa = spa_next(NULL)) != NULL) {
4058		/*
4059		 * Stop async tasks.  The async thread may need to detach
4060		 * a device that's been replaced, which requires grabbing
4061		 * spa_namespace_lock, so we must drop it here.
4062		 */
4063		spa_open_ref(spa, FTAG);
4064		mutex_exit(&spa_namespace_lock);
4065		spa_async_suspend(spa);
4066		mutex_enter(&spa_namespace_lock);
4067		spa_close(spa, FTAG);
4068
4069		if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
4070			spa_unload(spa);
4071			spa_deactivate(spa);
4072		}
4073		spa_remove(spa);
4074	}
4075	mutex_exit(&spa_namespace_lock);
4076}
4077
4078vdev_t *
4079spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t l2cache)
4080{
4081	vdev_t *vd;
4082	int i;
4083
4084	if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL)
4085		return (vd);
4086
4087	if (l2cache) {
4088		for (i = 0; i < spa->spa_l2cache.sav_count; i++) {
4089			vd = spa->spa_l2cache.sav_vdevs[i];
4090			if (vd->vdev_guid == guid)
4091				return (vd);
4092		}
4093	}
4094
4095	return (NULL);
4096}
4097
4098void
4099spa_upgrade(spa_t *spa, uint64_t version)
4100{
4101	spa_config_enter(spa, RW_WRITER, FTAG);
4102
4103	/*
4104	 * This should only be called for a non-faulted pool, and since a
4105	 * future version would result in an unopenable pool, this shouldn't be
4106	 * possible.
4107	 */
4108	ASSERT(spa->spa_uberblock.ub_version <= SPA_VERSION);
4109	ASSERT(version >= spa->spa_uberblock.ub_version);
4110
4111	spa->spa_uberblock.ub_version = version;
4112	vdev_config_dirty(spa->spa_root_vdev);
4113
4114	spa_config_exit(spa, FTAG);
4115
4116	txg_wait_synced(spa_get_dsl(spa), 0);
4117}
4118
4119boolean_t
4120spa_has_spare(spa_t *spa, uint64_t guid)
4121{
4122	int i;
4123	uint64_t spareguid;
4124	spa_aux_vdev_t *sav = &spa->spa_spares;
4125
4126	for (i = 0; i < sav->sav_count; i++)
4127		if (sav->sav_vdevs[i]->vdev_guid == guid)
4128			return (B_TRUE);
4129
4130	for (i = 0; i < sav->sav_npending; i++) {
4131		if (nvlist_lookup_uint64(sav->sav_pending[i], ZPOOL_CONFIG_GUID,
4132		    &spareguid) == 0 && spareguid == guid)
4133			return (B_TRUE);
4134	}
4135
4136	return (B_FALSE);
4137}
4138
4139/*
4140 * Post a sysevent corresponding to the given event.  The 'name' must be one of
4141 * the event definitions in sys/sysevent/eventdefs.h.  The payload will be
4142 * filled in from the spa and (optionally) the vdev.  This doesn't do anything
4143 * in the userland libzpool, as we don't want consumers to misinterpret ztest
4144 * or zdb as real changes.
4145 */
4146void
4147spa_event_notify(spa_t *spa, vdev_t *vd, const char *name)
4148{
4149#ifdef _KERNEL
4150	sysevent_t		*ev;
4151	sysevent_attr_list_t	*attr = NULL;
4152	sysevent_value_t	value;
4153	sysevent_id_t		eid;
4154
4155	ev = sysevent_alloc(EC_ZFS, (char *)name, SUNW_KERN_PUB "zfs",
4156	    SE_SLEEP);
4157
4158	value.value_type = SE_DATA_TYPE_STRING;
4159	value.value.sv_string = spa_name(spa);
4160	if (sysevent_add_attr(&attr, ZFS_EV_POOL_NAME, &value, SE_SLEEP) != 0)
4161		goto done;
4162
4163	value.value_type = SE_DATA_TYPE_UINT64;
4164	value.value.sv_uint64 = spa_guid(spa);
4165	if (sysevent_add_attr(&attr, ZFS_EV_POOL_GUID, &value, SE_SLEEP) != 0)
4166		goto done;
4167
4168	if (vd) {
4169		value.value_type = SE_DATA_TYPE_UINT64;
4170		value.value.sv_uint64 = vd->vdev_guid;
4171		if (sysevent_add_attr(&attr, ZFS_EV_VDEV_GUID, &value,
4172		    SE_SLEEP) != 0)
4173			goto done;
4174
4175		if (vd->vdev_path) {
4176			value.value_type = SE_DATA_TYPE_STRING;
4177			value.value.sv_string = vd->vdev_path;
4178			if (sysevent_add_attr(&attr, ZFS_EV_VDEV_PATH,
4179			    &value, SE_SLEEP) != 0)
4180				goto done;
4181		}
4182	}
4183
4184	if (sysevent_attach_attributes(ev, attr) != 0)
4185		goto done;
4186	attr = NULL;
4187
4188	(void) log_sysevent(ev, SE_SLEEP, &eid);
4189
4190done:
4191	if (attr)
4192		sysevent_free_attr(attr);
4193	sysevent_free(ev);
4194#endif
4195}
4196