xref: /illumos-gate/usr/src/uts/common/fs/zfs/vdev.c (revision 8b33d774c03f9e486579a2665839f9833a9d90bc)
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 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include <sys/zfs_context.h>
28 #include <sys/fm/fs/zfs.h>
29 #include <sys/spa.h>
30 #include <sys/spa_impl.h>
31 #include <sys/dmu.h>
32 #include <sys/dmu_tx.h>
33 #include <sys/vdev_impl.h>
34 #include <sys/uberblock_impl.h>
35 #include <sys/metaslab.h>
36 #include <sys/metaslab_impl.h>
37 #include <sys/space_map.h>
38 #include <sys/zio.h>
39 #include <sys/zap.h>
40 #include <sys/fs/zfs.h>
41 #include <sys/arc.h>
42 
43 /*
44  * Virtual device management.
45  */
46 
47 static vdev_ops_t *vdev_ops_table[] = {
48 	&vdev_root_ops,
49 	&vdev_raidz_ops,
50 	&vdev_mirror_ops,
51 	&vdev_replacing_ops,
52 	&vdev_spare_ops,
53 	&vdev_disk_ops,
54 	&vdev_file_ops,
55 	&vdev_missing_ops,
56 	NULL
57 };
58 
59 /* maximum scrub/resilver I/O queue per leaf vdev */
60 int zfs_scrub_limit = 10;
61 
62 /*
63  * Given a vdev type, return the appropriate ops vector.
64  */
65 static vdev_ops_t *
66 vdev_getops(const char *type)
67 {
68 	vdev_ops_t *ops, **opspp;
69 
70 	for (opspp = vdev_ops_table; (ops = *opspp) != NULL; opspp++)
71 		if (strcmp(ops->vdev_op_type, type) == 0)
72 			break;
73 
74 	return (ops);
75 }
76 
77 /*
78  * Default asize function: return the MAX of psize with the asize of
79  * all children.  This is what's used by anything other than RAID-Z.
80  */
81 uint64_t
82 vdev_default_asize(vdev_t *vd, uint64_t psize)
83 {
84 	uint64_t asize = P2ROUNDUP(psize, 1ULL << vd->vdev_top->vdev_ashift);
85 	uint64_t csize;
86 	uint64_t c;
87 
88 	for (c = 0; c < vd->vdev_children; c++) {
89 		csize = vdev_psize_to_asize(vd->vdev_child[c], psize);
90 		asize = MAX(asize, csize);
91 	}
92 
93 	return (asize);
94 }
95 
96 /*
97  * Get the replaceable or attachable device size.
98  * If the parent is a mirror or raidz, the replaceable size is the minimum
99  * psize of all its children. For the rest, just return our own psize.
100  *
101  * e.g.
102  *			psize	rsize
103  * root			-	-
104  *	mirror/raidz	-	-
105  *	    disk1	20g	20g
106  *	    disk2 	40g	20g
107  *	disk3 		80g	80g
108  */
109 uint64_t
110 vdev_get_rsize(vdev_t *vd)
111 {
112 	vdev_t *pvd, *cvd;
113 	uint64_t c, rsize;
114 
115 	pvd = vd->vdev_parent;
116 
117 	/*
118 	 * If our parent is NULL or the root, just return our own psize.
119 	 */
120 	if (pvd == NULL || pvd->vdev_parent == NULL)
121 		return (vd->vdev_psize);
122 
123 	rsize = 0;
124 
125 	for (c = 0; c < pvd->vdev_children; c++) {
126 		cvd = pvd->vdev_child[c];
127 		rsize = MIN(rsize - 1, cvd->vdev_psize - 1) + 1;
128 	}
129 
130 	return (rsize);
131 }
132 
133 vdev_t *
134 vdev_lookup_top(spa_t *spa, uint64_t vdev)
135 {
136 	vdev_t *rvd = spa->spa_root_vdev;
137 
138 	ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0);
139 
140 	if (vdev < rvd->vdev_children) {
141 		ASSERT(rvd->vdev_child[vdev] != NULL);
142 		return (rvd->vdev_child[vdev]);
143 	}
144 
145 	return (NULL);
146 }
147 
148 vdev_t *
149 vdev_lookup_by_guid(vdev_t *vd, uint64_t guid)
150 {
151 	int c;
152 	vdev_t *mvd;
153 
154 	if (vd->vdev_guid == guid)
155 		return (vd);
156 
157 	for (c = 0; c < vd->vdev_children; c++)
158 		if ((mvd = vdev_lookup_by_guid(vd->vdev_child[c], guid)) !=
159 		    NULL)
160 			return (mvd);
161 
162 	return (NULL);
163 }
164 
165 void
166 vdev_add_child(vdev_t *pvd, vdev_t *cvd)
167 {
168 	size_t oldsize, newsize;
169 	uint64_t id = cvd->vdev_id;
170 	vdev_t **newchild;
171 
172 	ASSERT(spa_config_held(cvd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL);
173 	ASSERT(cvd->vdev_parent == NULL);
174 
175 	cvd->vdev_parent = pvd;
176 
177 	if (pvd == NULL)
178 		return;
179 
180 	ASSERT(id >= pvd->vdev_children || pvd->vdev_child[id] == NULL);
181 
182 	oldsize = pvd->vdev_children * sizeof (vdev_t *);
183 	pvd->vdev_children = MAX(pvd->vdev_children, id + 1);
184 	newsize = pvd->vdev_children * sizeof (vdev_t *);
185 
186 	newchild = kmem_zalloc(newsize, KM_SLEEP);
187 	if (pvd->vdev_child != NULL) {
188 		bcopy(pvd->vdev_child, newchild, oldsize);
189 		kmem_free(pvd->vdev_child, oldsize);
190 	}
191 
192 	pvd->vdev_child = newchild;
193 	pvd->vdev_child[id] = cvd;
194 
195 	cvd->vdev_top = (pvd->vdev_top ? pvd->vdev_top: cvd);
196 	ASSERT(cvd->vdev_top->vdev_parent->vdev_parent == NULL);
197 
198 	/*
199 	 * Walk up all ancestors to update guid sum.
200 	 */
201 	for (; pvd != NULL; pvd = pvd->vdev_parent)
202 		pvd->vdev_guid_sum += cvd->vdev_guid_sum;
203 
204 	if (cvd->vdev_ops->vdev_op_leaf)
205 		cvd->vdev_spa->spa_scrub_maxinflight += zfs_scrub_limit;
206 }
207 
208 void
209 vdev_remove_child(vdev_t *pvd, vdev_t *cvd)
210 {
211 	int c;
212 	uint_t id = cvd->vdev_id;
213 
214 	ASSERT(cvd->vdev_parent == pvd);
215 
216 	if (pvd == NULL)
217 		return;
218 
219 	ASSERT(id < pvd->vdev_children);
220 	ASSERT(pvd->vdev_child[id] == cvd);
221 
222 	pvd->vdev_child[id] = NULL;
223 	cvd->vdev_parent = NULL;
224 
225 	for (c = 0; c < pvd->vdev_children; c++)
226 		if (pvd->vdev_child[c])
227 			break;
228 
229 	if (c == pvd->vdev_children) {
230 		kmem_free(pvd->vdev_child, c * sizeof (vdev_t *));
231 		pvd->vdev_child = NULL;
232 		pvd->vdev_children = 0;
233 	}
234 
235 	/*
236 	 * Walk up all ancestors to update guid sum.
237 	 */
238 	for (; pvd != NULL; pvd = pvd->vdev_parent)
239 		pvd->vdev_guid_sum -= cvd->vdev_guid_sum;
240 
241 	if (cvd->vdev_ops->vdev_op_leaf)
242 		cvd->vdev_spa->spa_scrub_maxinflight -= zfs_scrub_limit;
243 }
244 
245 /*
246  * Remove any holes in the child array.
247  */
248 void
249 vdev_compact_children(vdev_t *pvd)
250 {
251 	vdev_t **newchild, *cvd;
252 	int oldc = pvd->vdev_children;
253 	int newc, c;
254 
255 	ASSERT(spa_config_held(pvd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL);
256 
257 	for (c = newc = 0; c < oldc; c++)
258 		if (pvd->vdev_child[c])
259 			newc++;
260 
261 	newchild = kmem_alloc(newc * sizeof (vdev_t *), KM_SLEEP);
262 
263 	for (c = newc = 0; c < oldc; c++) {
264 		if ((cvd = pvd->vdev_child[c]) != NULL) {
265 			newchild[newc] = cvd;
266 			cvd->vdev_id = newc++;
267 		}
268 	}
269 
270 	kmem_free(pvd->vdev_child, oldc * sizeof (vdev_t *));
271 	pvd->vdev_child = newchild;
272 	pvd->vdev_children = newc;
273 }
274 
275 /*
276  * Allocate and minimally initialize a vdev_t.
277  */
278 static vdev_t *
279 vdev_alloc_common(spa_t *spa, uint_t id, uint64_t guid, vdev_ops_t *ops)
280 {
281 	vdev_t *vd;
282 
283 	vd = kmem_zalloc(sizeof (vdev_t), KM_SLEEP);
284 
285 	if (spa->spa_root_vdev == NULL) {
286 		ASSERT(ops == &vdev_root_ops);
287 		spa->spa_root_vdev = vd;
288 	}
289 
290 	if (guid == 0) {
291 		if (spa->spa_root_vdev == vd) {
292 			/*
293 			 * The root vdev's guid will also be the pool guid,
294 			 * which must be unique among all pools.
295 			 */
296 			while (guid == 0 || spa_guid_exists(guid, 0))
297 				guid = spa_get_random(-1ULL);
298 		} else {
299 			/*
300 			 * Any other vdev's guid must be unique within the pool.
301 			 */
302 			while (guid == 0 ||
303 			    spa_guid_exists(spa_guid(spa), guid))
304 				guid = spa_get_random(-1ULL);
305 		}
306 		ASSERT(!spa_guid_exists(spa_guid(spa), guid));
307 	}
308 
309 	vd->vdev_spa = spa;
310 	vd->vdev_id = id;
311 	vd->vdev_guid = guid;
312 	vd->vdev_guid_sum = guid;
313 	vd->vdev_ops = ops;
314 	vd->vdev_state = VDEV_STATE_CLOSED;
315 
316 	mutex_init(&vd->vdev_dtl_lock, NULL, MUTEX_DEFAULT, NULL);
317 	mutex_init(&vd->vdev_stat_lock, NULL, MUTEX_DEFAULT, NULL);
318 	mutex_init(&vd->vdev_probe_lock, NULL, MUTEX_DEFAULT, NULL);
319 	for (int t = 0; t < DTL_TYPES; t++) {
320 		space_map_create(&vd->vdev_dtl[t], 0, -1ULL, 0,
321 		    &vd->vdev_dtl_lock);
322 	}
323 	txg_list_create(&vd->vdev_ms_list,
324 	    offsetof(struct metaslab, ms_txg_node));
325 	txg_list_create(&vd->vdev_dtl_list,
326 	    offsetof(struct vdev, vdev_dtl_node));
327 	vd->vdev_stat.vs_timestamp = gethrtime();
328 	vdev_queue_init(vd);
329 	vdev_cache_init(vd);
330 
331 	return (vd);
332 }
333 
334 /*
335  * Allocate a new vdev.  The 'alloctype' is used to control whether we are
336  * creating a new vdev or loading an existing one - the behavior is slightly
337  * different for each case.
338  */
339 int
340 vdev_alloc(spa_t *spa, vdev_t **vdp, nvlist_t *nv, vdev_t *parent, uint_t id,
341     int alloctype)
342 {
343 	vdev_ops_t *ops;
344 	char *type;
345 	uint64_t guid = 0, islog, nparity;
346 	vdev_t *vd;
347 
348 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
349 
350 	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) != 0)
351 		return (EINVAL);
352 
353 	if ((ops = vdev_getops(type)) == NULL)
354 		return (EINVAL);
355 
356 	/*
357 	 * If this is a load, get the vdev guid from the nvlist.
358 	 * Otherwise, vdev_alloc_common() will generate one for us.
359 	 */
360 	if (alloctype == VDEV_ALLOC_LOAD) {
361 		uint64_t label_id;
362 
363 		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID, &label_id) ||
364 		    label_id != id)
365 			return (EINVAL);
366 
367 		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0)
368 			return (EINVAL);
369 	} else if (alloctype == VDEV_ALLOC_SPARE) {
370 		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0)
371 			return (EINVAL);
372 	} else if (alloctype == VDEV_ALLOC_L2CACHE) {
373 		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0)
374 			return (EINVAL);
375 	}
376 
377 	/*
378 	 * The first allocated vdev must be of type 'root'.
379 	 */
380 	if (ops != &vdev_root_ops && spa->spa_root_vdev == NULL)
381 		return (EINVAL);
382 
383 	/*
384 	 * Determine whether we're a log vdev.
385 	 */
386 	islog = 0;
387 	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG, &islog);
388 	if (islog && spa_version(spa) < SPA_VERSION_SLOGS)
389 		return (ENOTSUP);
390 
391 	/*
392 	 * Set the nparity property for RAID-Z vdevs.
393 	 */
394 	nparity = -1ULL;
395 	if (ops == &vdev_raidz_ops) {
396 		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY,
397 		    &nparity) == 0) {
398 			/*
399 			 * Currently, we can only support 2 parity devices.
400 			 */
401 			if (nparity == 0 || nparity > 2)
402 				return (EINVAL);
403 			/*
404 			 * Older versions can only support 1 parity device.
405 			 */
406 			if (nparity == 2 &&
407 			    spa_version(spa) < SPA_VERSION_RAID6)
408 				return (ENOTSUP);
409 		} else {
410 			/*
411 			 * We require the parity to be specified for SPAs that
412 			 * support multiple parity levels.
413 			 */
414 			if (spa_version(spa) >= SPA_VERSION_RAID6)
415 				return (EINVAL);
416 			/*
417 			 * Otherwise, we default to 1 parity device for RAID-Z.
418 			 */
419 			nparity = 1;
420 		}
421 	} else {
422 		nparity = 0;
423 	}
424 	ASSERT(nparity != -1ULL);
425 
426 	vd = vdev_alloc_common(spa, id, guid, ops);
427 
428 	vd->vdev_islog = islog;
429 	vd->vdev_nparity = nparity;
430 
431 	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &vd->vdev_path) == 0)
432 		vd->vdev_path = spa_strdup(vd->vdev_path);
433 	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_DEVID, &vd->vdev_devid) == 0)
434 		vd->vdev_devid = spa_strdup(vd->vdev_devid);
435 	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PHYS_PATH,
436 	    &vd->vdev_physpath) == 0)
437 		vd->vdev_physpath = spa_strdup(vd->vdev_physpath);
438 	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_FRU, &vd->vdev_fru) == 0)
439 		vd->vdev_fru = spa_strdup(vd->vdev_fru);
440 
441 	/*
442 	 * Set the whole_disk property.  If it's not specified, leave the value
443 	 * as -1.
444 	 */
445 	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
446 	    &vd->vdev_wholedisk) != 0)
447 		vd->vdev_wholedisk = -1ULL;
448 
449 	/*
450 	 * Look for the 'not present' flag.  This will only be set if the device
451 	 * was not present at the time of import.
452 	 */
453 	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT,
454 	    &vd->vdev_not_present);
455 
456 	/*
457 	 * Get the alignment requirement.
458 	 */
459 	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASHIFT, &vd->vdev_ashift);
460 
461 	/*
462 	 * If we're a top-level vdev, try to load the allocation parameters.
463 	 */
464 	if (parent && !parent->vdev_parent && alloctype == VDEV_ALLOC_LOAD) {
465 		(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_METASLAB_ARRAY,
466 		    &vd->vdev_ms_array);
467 		(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_METASLAB_SHIFT,
468 		    &vd->vdev_ms_shift);
469 		(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASIZE,
470 		    &vd->vdev_asize);
471 	}
472 
473 	/*
474 	 * If we're a leaf vdev, try to load the DTL object and other state.
475 	 */
476 	if (vd->vdev_ops->vdev_op_leaf &&
477 	    (alloctype == VDEV_ALLOC_LOAD || alloctype == VDEV_ALLOC_L2CACHE)) {
478 		if (alloctype == VDEV_ALLOC_LOAD) {
479 			(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DTL,
480 			    &vd->vdev_dtl_smo.smo_object);
481 			(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_UNSPARE,
482 			    &vd->vdev_unspare);
483 		}
484 		(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_OFFLINE,
485 		    &vd->vdev_offline);
486 
487 		/*
488 		 * When importing a pool, we want to ignore the persistent fault
489 		 * state, as the diagnosis made on another system may not be
490 		 * valid in the current context.
491 		 */
492 		if (spa->spa_load_state == SPA_LOAD_OPEN) {
493 			(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_FAULTED,
494 			    &vd->vdev_faulted);
495 			(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DEGRADED,
496 			    &vd->vdev_degraded);
497 			(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVED,
498 			    &vd->vdev_removed);
499 		}
500 	}
501 
502 	/*
503 	 * Add ourselves to the parent's list of children.
504 	 */
505 	vdev_add_child(parent, vd);
506 
507 	*vdp = vd;
508 
509 	return (0);
510 }
511 
512 void
513 vdev_free(vdev_t *vd)
514 {
515 	int c;
516 	spa_t *spa = vd->vdev_spa;
517 
518 	/*
519 	 * vdev_free() implies closing the vdev first.  This is simpler than
520 	 * trying to ensure complicated semantics for all callers.
521 	 */
522 	vdev_close(vd);
523 
524 	ASSERT(!list_link_active(&vd->vdev_config_dirty_node));
525 
526 	/*
527 	 * Free all children.
528 	 */
529 	for (c = 0; c < vd->vdev_children; c++)
530 		vdev_free(vd->vdev_child[c]);
531 
532 	ASSERT(vd->vdev_child == NULL);
533 	ASSERT(vd->vdev_guid_sum == vd->vdev_guid);
534 
535 	/*
536 	 * Discard allocation state.
537 	 */
538 	if (vd == vd->vdev_top)
539 		vdev_metaslab_fini(vd);
540 
541 	ASSERT3U(vd->vdev_stat.vs_space, ==, 0);
542 	ASSERT3U(vd->vdev_stat.vs_dspace, ==, 0);
543 	ASSERT3U(vd->vdev_stat.vs_alloc, ==, 0);
544 
545 	/*
546 	 * Remove this vdev from its parent's child list.
547 	 */
548 	vdev_remove_child(vd->vdev_parent, vd);
549 
550 	ASSERT(vd->vdev_parent == NULL);
551 
552 	/*
553 	 * Clean up vdev structure.
554 	 */
555 	vdev_queue_fini(vd);
556 	vdev_cache_fini(vd);
557 
558 	if (vd->vdev_path)
559 		spa_strfree(vd->vdev_path);
560 	if (vd->vdev_devid)
561 		spa_strfree(vd->vdev_devid);
562 	if (vd->vdev_physpath)
563 		spa_strfree(vd->vdev_physpath);
564 	if (vd->vdev_fru)
565 		spa_strfree(vd->vdev_fru);
566 
567 	if (vd->vdev_isspare)
568 		spa_spare_remove(vd);
569 	if (vd->vdev_isl2cache)
570 		spa_l2cache_remove(vd);
571 
572 	txg_list_destroy(&vd->vdev_ms_list);
573 	txg_list_destroy(&vd->vdev_dtl_list);
574 
575 	mutex_enter(&vd->vdev_dtl_lock);
576 	for (int t = 0; t < DTL_TYPES; t++) {
577 		space_map_unload(&vd->vdev_dtl[t]);
578 		space_map_destroy(&vd->vdev_dtl[t]);
579 	}
580 	mutex_exit(&vd->vdev_dtl_lock);
581 
582 	mutex_destroy(&vd->vdev_dtl_lock);
583 	mutex_destroy(&vd->vdev_stat_lock);
584 	mutex_destroy(&vd->vdev_probe_lock);
585 
586 	if (vd == spa->spa_root_vdev)
587 		spa->spa_root_vdev = NULL;
588 
589 	kmem_free(vd, sizeof (vdev_t));
590 }
591 
592 /*
593  * Transfer top-level vdev state from svd to tvd.
594  */
595 static void
596 vdev_top_transfer(vdev_t *svd, vdev_t *tvd)
597 {
598 	spa_t *spa = svd->vdev_spa;
599 	metaslab_t *msp;
600 	vdev_t *vd;
601 	int t;
602 
603 	ASSERT(tvd == tvd->vdev_top);
604 
605 	tvd->vdev_ms_array = svd->vdev_ms_array;
606 	tvd->vdev_ms_shift = svd->vdev_ms_shift;
607 	tvd->vdev_ms_count = svd->vdev_ms_count;
608 
609 	svd->vdev_ms_array = 0;
610 	svd->vdev_ms_shift = 0;
611 	svd->vdev_ms_count = 0;
612 
613 	tvd->vdev_mg = svd->vdev_mg;
614 	tvd->vdev_ms = svd->vdev_ms;
615 
616 	svd->vdev_mg = NULL;
617 	svd->vdev_ms = NULL;
618 
619 	if (tvd->vdev_mg != NULL)
620 		tvd->vdev_mg->mg_vd = tvd;
621 
622 	tvd->vdev_stat.vs_alloc = svd->vdev_stat.vs_alloc;
623 	tvd->vdev_stat.vs_space = svd->vdev_stat.vs_space;
624 	tvd->vdev_stat.vs_dspace = svd->vdev_stat.vs_dspace;
625 
626 	svd->vdev_stat.vs_alloc = 0;
627 	svd->vdev_stat.vs_space = 0;
628 	svd->vdev_stat.vs_dspace = 0;
629 
630 	for (t = 0; t < TXG_SIZE; t++) {
631 		while ((msp = txg_list_remove(&svd->vdev_ms_list, t)) != NULL)
632 			(void) txg_list_add(&tvd->vdev_ms_list, msp, t);
633 		while ((vd = txg_list_remove(&svd->vdev_dtl_list, t)) != NULL)
634 			(void) txg_list_add(&tvd->vdev_dtl_list, vd, t);
635 		if (txg_list_remove_this(&spa->spa_vdev_txg_list, svd, t))
636 			(void) txg_list_add(&spa->spa_vdev_txg_list, tvd, t);
637 	}
638 
639 	if (list_link_active(&svd->vdev_config_dirty_node)) {
640 		vdev_config_clean(svd);
641 		vdev_config_dirty(tvd);
642 	}
643 
644 	if (list_link_active(&svd->vdev_state_dirty_node)) {
645 		vdev_state_clean(svd);
646 		vdev_state_dirty(tvd);
647 	}
648 
649 	tvd->vdev_deflate_ratio = svd->vdev_deflate_ratio;
650 	svd->vdev_deflate_ratio = 0;
651 
652 	tvd->vdev_islog = svd->vdev_islog;
653 	svd->vdev_islog = 0;
654 }
655 
656 static void
657 vdev_top_update(vdev_t *tvd, vdev_t *vd)
658 {
659 	int c;
660 
661 	if (vd == NULL)
662 		return;
663 
664 	vd->vdev_top = tvd;
665 
666 	for (c = 0; c < vd->vdev_children; c++)
667 		vdev_top_update(tvd, vd->vdev_child[c]);
668 }
669 
670 /*
671  * Add a mirror/replacing vdev above an existing vdev.
672  */
673 vdev_t *
674 vdev_add_parent(vdev_t *cvd, vdev_ops_t *ops)
675 {
676 	spa_t *spa = cvd->vdev_spa;
677 	vdev_t *pvd = cvd->vdev_parent;
678 	vdev_t *mvd;
679 
680 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
681 
682 	mvd = vdev_alloc_common(spa, cvd->vdev_id, 0, ops);
683 
684 	mvd->vdev_asize = cvd->vdev_asize;
685 	mvd->vdev_ashift = cvd->vdev_ashift;
686 	mvd->vdev_state = cvd->vdev_state;
687 
688 	vdev_remove_child(pvd, cvd);
689 	vdev_add_child(pvd, mvd);
690 	cvd->vdev_id = mvd->vdev_children;
691 	vdev_add_child(mvd, cvd);
692 	vdev_top_update(cvd->vdev_top, cvd->vdev_top);
693 
694 	if (mvd == mvd->vdev_top)
695 		vdev_top_transfer(cvd, mvd);
696 
697 	return (mvd);
698 }
699 
700 /*
701  * Remove a 1-way mirror/replacing vdev from the tree.
702  */
703 void
704 vdev_remove_parent(vdev_t *cvd)
705 {
706 	vdev_t *mvd = cvd->vdev_parent;
707 	vdev_t *pvd = mvd->vdev_parent;
708 
709 	ASSERT(spa_config_held(cvd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL);
710 
711 	ASSERT(mvd->vdev_children == 1);
712 	ASSERT(mvd->vdev_ops == &vdev_mirror_ops ||
713 	    mvd->vdev_ops == &vdev_replacing_ops ||
714 	    mvd->vdev_ops == &vdev_spare_ops);
715 	cvd->vdev_ashift = mvd->vdev_ashift;
716 
717 	vdev_remove_child(mvd, cvd);
718 	vdev_remove_child(pvd, mvd);
719 
720 	/*
721 	 * If cvd will replace mvd as a top-level vdev, preserve mvd's guid.
722 	 * Otherwise, we could have detached an offline device, and when we
723 	 * go to import the pool we'll think we have two top-level vdevs,
724 	 * instead of a different version of the same top-level vdev.
725 	 */
726 	if (mvd->vdev_top == mvd) {
727 		uint64_t guid_delta = mvd->vdev_guid - cvd->vdev_guid;
728 		cvd->vdev_guid += guid_delta;
729 		cvd->vdev_guid_sum += guid_delta;
730 	}
731 	cvd->vdev_id = mvd->vdev_id;
732 	vdev_add_child(pvd, cvd);
733 	vdev_top_update(cvd->vdev_top, cvd->vdev_top);
734 
735 	if (cvd == cvd->vdev_top)
736 		vdev_top_transfer(mvd, cvd);
737 
738 	ASSERT(mvd->vdev_children == 0);
739 	vdev_free(mvd);
740 }
741 
742 int
743 vdev_metaslab_init(vdev_t *vd, uint64_t txg)
744 {
745 	spa_t *spa = vd->vdev_spa;
746 	objset_t *mos = spa->spa_meta_objset;
747 	metaslab_class_t *mc;
748 	uint64_t m;
749 	uint64_t oldc = vd->vdev_ms_count;
750 	uint64_t newc = vd->vdev_asize >> vd->vdev_ms_shift;
751 	metaslab_t **mspp;
752 	int error;
753 
754 	if (vd->vdev_ms_shift == 0)	/* not being allocated from yet */
755 		return (0);
756 
757 	ASSERT(oldc <= newc);
758 
759 	if (vd->vdev_islog)
760 		mc = spa->spa_log_class;
761 	else
762 		mc = spa->spa_normal_class;
763 
764 	if (vd->vdev_mg == NULL)
765 		vd->vdev_mg = metaslab_group_create(mc, vd);
766 
767 	mspp = kmem_zalloc(newc * sizeof (*mspp), KM_SLEEP);
768 
769 	if (oldc != 0) {
770 		bcopy(vd->vdev_ms, mspp, oldc * sizeof (*mspp));
771 		kmem_free(vd->vdev_ms, oldc * sizeof (*mspp));
772 	}
773 
774 	vd->vdev_ms = mspp;
775 	vd->vdev_ms_count = newc;
776 
777 	for (m = oldc; m < newc; m++) {
778 		space_map_obj_t smo = { 0, 0, 0 };
779 		if (txg == 0) {
780 			uint64_t object = 0;
781 			error = dmu_read(mos, vd->vdev_ms_array,
782 			    m * sizeof (uint64_t), sizeof (uint64_t), &object,
783 			    DMU_READ_PREFETCH);
784 			if (error)
785 				return (error);
786 			if (object != 0) {
787 				dmu_buf_t *db;
788 				error = dmu_bonus_hold(mos, object, FTAG, &db);
789 				if (error)
790 					return (error);
791 				ASSERT3U(db->db_size, >=, sizeof (smo));
792 				bcopy(db->db_data, &smo, sizeof (smo));
793 				ASSERT3U(smo.smo_object, ==, object);
794 				dmu_buf_rele(db, FTAG);
795 			}
796 		}
797 		vd->vdev_ms[m] = metaslab_init(vd->vdev_mg, &smo,
798 		    m << vd->vdev_ms_shift, 1ULL << vd->vdev_ms_shift, txg);
799 	}
800 
801 	return (0);
802 }
803 
804 void
805 vdev_metaslab_fini(vdev_t *vd)
806 {
807 	uint64_t m;
808 	uint64_t count = vd->vdev_ms_count;
809 
810 	if (vd->vdev_ms != NULL) {
811 		for (m = 0; m < count; m++)
812 			if (vd->vdev_ms[m] != NULL)
813 				metaslab_fini(vd->vdev_ms[m]);
814 		kmem_free(vd->vdev_ms, count * sizeof (metaslab_t *));
815 		vd->vdev_ms = NULL;
816 	}
817 }
818 
819 typedef struct vdev_probe_stats {
820 	boolean_t	vps_readable;
821 	boolean_t	vps_writeable;
822 	int		vps_flags;
823 } vdev_probe_stats_t;
824 
825 static void
826 vdev_probe_done(zio_t *zio)
827 {
828 	spa_t *spa = zio->io_spa;
829 	vdev_t *vd = zio->io_vd;
830 	vdev_probe_stats_t *vps = zio->io_private;
831 
832 	ASSERT(vd->vdev_probe_zio != NULL);
833 
834 	if (zio->io_type == ZIO_TYPE_READ) {
835 		if (zio->io_error == 0)
836 			vps->vps_readable = 1;
837 		if (zio->io_error == 0 && spa_writeable(spa)) {
838 			zio_nowait(zio_write_phys(vd->vdev_probe_zio, vd,
839 			    zio->io_offset, zio->io_size, zio->io_data,
840 			    ZIO_CHECKSUM_OFF, vdev_probe_done, vps,
841 			    ZIO_PRIORITY_SYNC_WRITE, vps->vps_flags, B_TRUE));
842 		} else {
843 			zio_buf_free(zio->io_data, zio->io_size);
844 		}
845 	} else if (zio->io_type == ZIO_TYPE_WRITE) {
846 		if (zio->io_error == 0)
847 			vps->vps_writeable = 1;
848 		zio_buf_free(zio->io_data, zio->io_size);
849 	} else if (zio->io_type == ZIO_TYPE_NULL) {
850 		zio_t *pio;
851 
852 		vd->vdev_cant_read |= !vps->vps_readable;
853 		vd->vdev_cant_write |= !vps->vps_writeable;
854 
855 		if (vdev_readable(vd) &&
856 		    (vdev_writeable(vd) || !spa_writeable(spa))) {
857 			zio->io_error = 0;
858 		} else {
859 			ASSERT(zio->io_error != 0);
860 			zfs_ereport_post(FM_EREPORT_ZFS_PROBE_FAILURE,
861 			    spa, vd, NULL, 0, 0);
862 			zio->io_error = ENXIO;
863 		}
864 
865 		mutex_enter(&vd->vdev_probe_lock);
866 		ASSERT(vd->vdev_probe_zio == zio);
867 		vd->vdev_probe_zio = NULL;
868 		mutex_exit(&vd->vdev_probe_lock);
869 
870 		while ((pio = zio_walk_parents(zio)) != NULL)
871 			if (!vdev_accessible(vd, pio))
872 				pio->io_error = ENXIO;
873 
874 		kmem_free(vps, sizeof (*vps));
875 	}
876 }
877 
878 /*
879  * Determine whether this device is accessible by reading and writing
880  * to several known locations: the pad regions of each vdev label
881  * but the first (which we leave alone in case it contains a VTOC).
882  */
883 zio_t *
884 vdev_probe(vdev_t *vd, zio_t *zio)
885 {
886 	spa_t *spa = vd->vdev_spa;
887 	vdev_probe_stats_t *vps = NULL;
888 	zio_t *pio;
889 
890 	ASSERT(vd->vdev_ops->vdev_op_leaf);
891 
892 	/*
893 	 * Don't probe the probe.
894 	 */
895 	if (zio && (zio->io_flags & ZIO_FLAG_PROBE))
896 		return (NULL);
897 
898 	/*
899 	 * To prevent 'probe storms' when a device fails, we create
900 	 * just one probe i/o at a time.  All zios that want to probe
901 	 * this vdev will become parents of the probe io.
902 	 */
903 	mutex_enter(&vd->vdev_probe_lock);
904 
905 	if ((pio = vd->vdev_probe_zio) == NULL) {
906 		vps = kmem_zalloc(sizeof (*vps), KM_SLEEP);
907 
908 		vps->vps_flags = ZIO_FLAG_CANFAIL | ZIO_FLAG_PROBE |
909 		    ZIO_FLAG_DONT_CACHE | ZIO_FLAG_DONT_AGGREGATE |
910 		    ZIO_FLAG_DONT_RETRY;
911 
912 		if (spa_config_held(spa, SCL_ZIO, RW_WRITER)) {
913 			/*
914 			 * vdev_cant_read and vdev_cant_write can only
915 			 * transition from TRUE to FALSE when we have the
916 			 * SCL_ZIO lock as writer; otherwise they can only
917 			 * transition from FALSE to TRUE.  This ensures that
918 			 * any zio looking at these values can assume that
919 			 * failures persist for the life of the I/O.  That's
920 			 * important because when a device has intermittent
921 			 * connectivity problems, we want to ensure that
922 			 * they're ascribed to the device (ENXIO) and not
923 			 * the zio (EIO).
924 			 *
925 			 * Since we hold SCL_ZIO as writer here, clear both
926 			 * values so the probe can reevaluate from first
927 			 * principles.
928 			 */
929 			vps->vps_flags |= ZIO_FLAG_CONFIG_WRITER;
930 			vd->vdev_cant_read = B_FALSE;
931 			vd->vdev_cant_write = B_FALSE;
932 		}
933 
934 		vd->vdev_probe_zio = pio = zio_null(NULL, spa, vd,
935 		    vdev_probe_done, vps,
936 		    vps->vps_flags | ZIO_FLAG_DONT_PROPAGATE);
937 
938 		if (zio != NULL) {
939 			vd->vdev_probe_wanted = B_TRUE;
940 			spa_async_request(spa, SPA_ASYNC_PROBE);
941 		}
942 	}
943 
944 	if (zio != NULL)
945 		zio_add_child(zio, pio);
946 
947 	mutex_exit(&vd->vdev_probe_lock);
948 
949 	if (vps == NULL) {
950 		ASSERT(zio != NULL);
951 		return (NULL);
952 	}
953 
954 	for (int l = 1; l < VDEV_LABELS; l++) {
955 		zio_nowait(zio_read_phys(pio, vd,
956 		    vdev_label_offset(vd->vdev_psize, l,
957 		    offsetof(vdev_label_t, vl_pad2)),
958 		    VDEV_PAD_SIZE, zio_buf_alloc(VDEV_PAD_SIZE),
959 		    ZIO_CHECKSUM_OFF, vdev_probe_done, vps,
960 		    ZIO_PRIORITY_SYNC_READ, vps->vps_flags, B_TRUE));
961 	}
962 
963 	if (zio == NULL)
964 		return (pio);
965 
966 	zio_nowait(pio);
967 	return (NULL);
968 }
969 
970 /*
971  * Prepare a virtual device for access.
972  */
973 int
974 vdev_open(vdev_t *vd)
975 {
976 	spa_t *spa = vd->vdev_spa;
977 	int error;
978 	int c;
979 	uint64_t osize = 0;
980 	uint64_t asize, psize;
981 	uint64_t ashift = 0;
982 
983 	ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);
984 
985 	ASSERT(vd->vdev_state == VDEV_STATE_CLOSED ||
986 	    vd->vdev_state == VDEV_STATE_CANT_OPEN ||
987 	    vd->vdev_state == VDEV_STATE_OFFLINE);
988 
989 	vd->vdev_stat.vs_aux = VDEV_AUX_NONE;
990 
991 	if (!vd->vdev_removed && vd->vdev_faulted) {
992 		ASSERT(vd->vdev_children == 0);
993 		vdev_set_state(vd, B_TRUE, VDEV_STATE_FAULTED,
994 		    VDEV_AUX_ERR_EXCEEDED);
995 		return (ENXIO);
996 	} else if (vd->vdev_offline) {
997 		ASSERT(vd->vdev_children == 0);
998 		vdev_set_state(vd, B_TRUE, VDEV_STATE_OFFLINE, VDEV_AUX_NONE);
999 		return (ENXIO);
1000 	}
1001 
1002 	error = vd->vdev_ops->vdev_op_open(vd, &osize, &ashift);
1003 
1004 	if (zio_injection_enabled && error == 0)
1005 		error = zio_handle_device_injection(vd, ENXIO);
1006 
1007 	if (error) {
1008 		if (vd->vdev_removed &&
1009 		    vd->vdev_stat.vs_aux != VDEV_AUX_OPEN_FAILED)
1010 			vd->vdev_removed = B_FALSE;
1011 
1012 		vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1013 		    vd->vdev_stat.vs_aux);
1014 		return (error);
1015 	}
1016 
1017 	vd->vdev_removed = B_FALSE;
1018 
1019 	if (vd->vdev_degraded) {
1020 		ASSERT(vd->vdev_children == 0);
1021 		vdev_set_state(vd, B_TRUE, VDEV_STATE_DEGRADED,
1022 		    VDEV_AUX_ERR_EXCEEDED);
1023 	} else {
1024 		vd->vdev_state = VDEV_STATE_HEALTHY;
1025 	}
1026 
1027 	for (c = 0; c < vd->vdev_children; c++)
1028 		if (vd->vdev_child[c]->vdev_state != VDEV_STATE_HEALTHY) {
1029 			vdev_set_state(vd, B_TRUE, VDEV_STATE_DEGRADED,
1030 			    VDEV_AUX_NONE);
1031 			break;
1032 		}
1033 
1034 	osize = P2ALIGN(osize, (uint64_t)sizeof (vdev_label_t));
1035 
1036 	if (vd->vdev_children == 0) {
1037 		if (osize < SPA_MINDEVSIZE) {
1038 			vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1039 			    VDEV_AUX_TOO_SMALL);
1040 			return (EOVERFLOW);
1041 		}
1042 		psize = osize;
1043 		asize = osize - (VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE);
1044 	} else {
1045 		if (vd->vdev_parent != NULL && osize < SPA_MINDEVSIZE -
1046 		    (VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE)) {
1047 			vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1048 			    VDEV_AUX_TOO_SMALL);
1049 			return (EOVERFLOW);
1050 		}
1051 		psize = 0;
1052 		asize = osize;
1053 	}
1054 
1055 	vd->vdev_psize = psize;
1056 
1057 	if (vd->vdev_asize == 0) {
1058 		/*
1059 		 * This is the first-ever open, so use the computed values.
1060 		 * For testing purposes, a higher ashift can be requested.
1061 		 */
1062 		vd->vdev_asize = asize;
1063 		vd->vdev_ashift = MAX(ashift, vd->vdev_ashift);
1064 	} else {
1065 		/*
1066 		 * Make sure the alignment requirement hasn't increased.
1067 		 */
1068 		if (ashift > vd->vdev_top->vdev_ashift) {
1069 			vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1070 			    VDEV_AUX_BAD_LABEL);
1071 			return (EINVAL);
1072 		}
1073 
1074 		/*
1075 		 * Make sure the device hasn't shrunk.
1076 		 */
1077 		if (asize < vd->vdev_asize) {
1078 			vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1079 			    VDEV_AUX_BAD_LABEL);
1080 			return (EINVAL);
1081 		}
1082 
1083 		/*
1084 		 * If all children are healthy and the asize has increased,
1085 		 * then we've experienced dynamic LUN growth.
1086 		 */
1087 		if (vd->vdev_state == VDEV_STATE_HEALTHY &&
1088 		    asize > vd->vdev_asize) {
1089 			vd->vdev_asize = asize;
1090 		}
1091 	}
1092 
1093 	/*
1094 	 * Ensure we can issue some IO before declaring the
1095 	 * vdev open for business.
1096 	 */
1097 	if (vd->vdev_ops->vdev_op_leaf &&
1098 	    (error = zio_wait(vdev_probe(vd, NULL))) != 0) {
1099 		vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1100 		    VDEV_AUX_IO_FAILURE);
1101 		return (error);
1102 	}
1103 
1104 	/*
1105 	 * If this is a top-level vdev, compute the raidz-deflation
1106 	 * ratio.  Note, we hard-code in 128k (1<<17) because it is the
1107 	 * current "typical" blocksize.  Even if SPA_MAXBLOCKSIZE
1108 	 * changes, this algorithm must never change, or we will
1109 	 * inconsistently account for existing bp's.
1110 	 */
1111 	if (vd->vdev_top == vd) {
1112 		vd->vdev_deflate_ratio = (1<<17) /
1113 		    (vdev_psize_to_asize(vd, 1<<17) >> SPA_MINBLOCKSHIFT);
1114 	}
1115 
1116 	/*
1117 	 * If a leaf vdev has a DTL, and seems healthy, then kick off a
1118 	 * resilver.  But don't do this if we are doing a reopen for a scrub,
1119 	 * since this would just restart the scrub we are already doing.
1120 	 */
1121 	if (vd->vdev_ops->vdev_op_leaf && !spa->spa_scrub_reopen &&
1122 	    vdev_resilver_needed(vd, NULL, NULL))
1123 		spa_async_request(spa, SPA_ASYNC_RESILVER);
1124 
1125 	return (0);
1126 }
1127 
1128 /*
1129  * Called once the vdevs are all opened, this routine validates the label
1130  * contents.  This needs to be done before vdev_load() so that we don't
1131  * inadvertently do repair I/Os to the wrong device.
1132  *
1133  * This function will only return failure if one of the vdevs indicates that it
1134  * has since been destroyed or exported.  This is only possible if
1135  * /etc/zfs/zpool.cache was readonly at the time.  Otherwise, the vdev state
1136  * will be updated but the function will return 0.
1137  */
1138 int
1139 vdev_validate(vdev_t *vd)
1140 {
1141 	spa_t *spa = vd->vdev_spa;
1142 	int c;
1143 	nvlist_t *label;
1144 	uint64_t guid, top_guid;
1145 	uint64_t state;
1146 
1147 	for (c = 0; c < vd->vdev_children; c++)
1148 		if (vdev_validate(vd->vdev_child[c]) != 0)
1149 			return (EBADF);
1150 
1151 	/*
1152 	 * If the device has already failed, or was marked offline, don't do
1153 	 * any further validation.  Otherwise, label I/O will fail and we will
1154 	 * overwrite the previous state.
1155 	 */
1156 	if (vd->vdev_ops->vdev_op_leaf && vdev_readable(vd)) {
1157 
1158 		if ((label = vdev_label_read_config(vd)) == NULL) {
1159 			vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1160 			    VDEV_AUX_BAD_LABEL);
1161 			return (0);
1162 		}
1163 
1164 		if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_GUID,
1165 		    &guid) != 0 || guid != spa_guid(spa)) {
1166 			vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
1167 			    VDEV_AUX_CORRUPT_DATA);
1168 			nvlist_free(label);
1169 			return (0);
1170 		}
1171 
1172 		/*
1173 		 * If this vdev just became a top-level vdev because its
1174 		 * sibling was detached, it will have adopted the parent's
1175 		 * vdev guid -- but the label may or may not be on disk yet.
1176 		 * Fortunately, either version of the label will have the
1177 		 * same top guid, so if we're a top-level vdev, we can
1178 		 * safely compare to that instead.
1179 		 */
1180 		if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID,
1181 		    &guid) != 0 ||
1182 		    nvlist_lookup_uint64(label, ZPOOL_CONFIG_TOP_GUID,
1183 		    &top_guid) != 0 ||
1184 		    (vd->vdev_guid != guid &&
1185 		    (vd->vdev_guid != top_guid || vd != vd->vdev_top))) {
1186 			vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
1187 			    VDEV_AUX_CORRUPT_DATA);
1188 			nvlist_free(label);
1189 			return (0);
1190 		}
1191 
1192 		if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_STATE,
1193 		    &state) != 0) {
1194 			vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
1195 			    VDEV_AUX_CORRUPT_DATA);
1196 			nvlist_free(label);
1197 			return (0);
1198 		}
1199 
1200 		nvlist_free(label);
1201 
1202 		if (spa->spa_load_state == SPA_LOAD_OPEN &&
1203 		    state != POOL_STATE_ACTIVE)
1204 			return (EBADF);
1205 
1206 		/*
1207 		 * If we were able to open and validate a vdev that was
1208 		 * previously marked permanently unavailable, clear that state
1209 		 * now.
1210 		 */
1211 		if (vd->vdev_not_present)
1212 			vd->vdev_not_present = 0;
1213 	}
1214 
1215 	return (0);
1216 }
1217 
1218 /*
1219  * Close a virtual device.
1220  */
1221 void
1222 vdev_close(vdev_t *vd)
1223 {
1224 	spa_t *spa = vd->vdev_spa;
1225 
1226 	ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);
1227 
1228 	vd->vdev_ops->vdev_op_close(vd);
1229 
1230 	vdev_cache_purge(vd);
1231 
1232 	/*
1233 	 * We record the previous state before we close it, so  that if we are
1234 	 * doing a reopen(), we don't generate FMA ereports if we notice that
1235 	 * it's still faulted.
1236 	 */
1237 	vd->vdev_prevstate = vd->vdev_state;
1238 
1239 	if (vd->vdev_offline)
1240 		vd->vdev_state = VDEV_STATE_OFFLINE;
1241 	else
1242 		vd->vdev_state = VDEV_STATE_CLOSED;
1243 	vd->vdev_stat.vs_aux = VDEV_AUX_NONE;
1244 }
1245 
1246 void
1247 vdev_reopen(vdev_t *vd)
1248 {
1249 	spa_t *spa = vd->vdev_spa;
1250 
1251 	ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);
1252 
1253 	vdev_close(vd);
1254 	(void) vdev_open(vd);
1255 
1256 	/*
1257 	 * Call vdev_validate() here to make sure we have the same device.
1258 	 * Otherwise, a device with an invalid label could be successfully
1259 	 * opened in response to vdev_reopen().
1260 	 */
1261 	if (vd->vdev_aux) {
1262 		(void) vdev_validate_aux(vd);
1263 		if (vdev_readable(vd) && vdev_writeable(vd) &&
1264 		    vd->vdev_aux == &spa->spa_l2cache &&
1265 		    !l2arc_vdev_present(vd)) {
1266 			uint64_t size = vdev_get_rsize(vd);
1267 			l2arc_add_vdev(spa, vd,
1268 			    VDEV_LABEL_START_SIZE,
1269 			    size - VDEV_LABEL_START_SIZE);
1270 		}
1271 	} else {
1272 		(void) vdev_validate(vd);
1273 	}
1274 
1275 	/*
1276 	 * Reassess parent vdev's health.
1277 	 */
1278 	vdev_propagate_state(vd);
1279 }
1280 
1281 int
1282 vdev_create(vdev_t *vd, uint64_t txg, boolean_t isreplacing)
1283 {
1284 	int error;
1285 
1286 	/*
1287 	 * Normally, partial opens (e.g. of a mirror) are allowed.
1288 	 * For a create, however, we want to fail the request if
1289 	 * there are any components we can't open.
1290 	 */
1291 	error = vdev_open(vd);
1292 
1293 	if (error || vd->vdev_state != VDEV_STATE_HEALTHY) {
1294 		vdev_close(vd);
1295 		return (error ? error : ENXIO);
1296 	}
1297 
1298 	/*
1299 	 * Recursively initialize all labels.
1300 	 */
1301 	if ((error = vdev_label_init(vd, txg, isreplacing ?
1302 	    VDEV_LABEL_REPLACE : VDEV_LABEL_CREATE)) != 0) {
1303 		vdev_close(vd);
1304 		return (error);
1305 	}
1306 
1307 	return (0);
1308 }
1309 
1310 /*
1311  * The is the latter half of vdev_create().  It is distinct because it
1312  * involves initiating transactions in order to do metaslab creation.
1313  * For creation, we want to try to create all vdevs at once and then undo it
1314  * if anything fails; this is much harder if we have pending transactions.
1315  */
1316 void
1317 vdev_init(vdev_t *vd, uint64_t txg)
1318 {
1319 	/*
1320 	 * Aim for roughly 200 metaslabs per vdev.
1321 	 */
1322 	vd->vdev_ms_shift = highbit(vd->vdev_asize / 200);
1323 	vd->vdev_ms_shift = MAX(vd->vdev_ms_shift, SPA_MAXBLOCKSHIFT);
1324 
1325 	/*
1326 	 * Initialize the vdev's metaslabs.  This can't fail because
1327 	 * there's nothing to read when creating all new metaslabs.
1328 	 */
1329 	VERIFY(vdev_metaslab_init(vd, txg) == 0);
1330 }
1331 
1332 void
1333 vdev_dirty(vdev_t *vd, int flags, void *arg, uint64_t txg)
1334 {
1335 	ASSERT(vd == vd->vdev_top);
1336 	ASSERT(ISP2(flags));
1337 
1338 	if (flags & VDD_METASLAB)
1339 		(void) txg_list_add(&vd->vdev_ms_list, arg, txg);
1340 
1341 	if (flags & VDD_DTL)
1342 		(void) txg_list_add(&vd->vdev_dtl_list, arg, txg);
1343 
1344 	(void) txg_list_add(&vd->vdev_spa->spa_vdev_txg_list, vd, txg);
1345 }
1346 
1347 /*
1348  * DTLs.
1349  *
1350  * A vdev's DTL (dirty time log) is the set of transaction groups for which
1351  * the vdev has less than perfect replication.  There are three kinds of DTL:
1352  *
1353  * DTL_MISSING: txgs for which the vdev has no valid copies of the data
1354  *
1355  * DTL_PARTIAL: txgs for which data is available, but not fully replicated
1356  *
1357  * DTL_SCRUB: the txgs that could not be repaired by the last scrub; upon
1358  *	scrub completion, DTL_SCRUB replaces DTL_MISSING in the range of
1359  *	txgs that was scrubbed.
1360  *
1361  * DTL_OUTAGE: txgs which cannot currently be read, whether due to
1362  *	persistent errors or just some device being offline.
1363  *	Unlike the other three, the DTL_OUTAGE map is not generally
1364  *	maintained; it's only computed when needed, typically to
1365  *	determine whether a device can be detached.
1366  *
1367  * For leaf vdevs, DTL_MISSING and DTL_PARTIAL are identical: the device
1368  * either has the data or it doesn't.
1369  *
1370  * For interior vdevs such as mirror and RAID-Z the picture is more complex.
1371  * A vdev's DTL_PARTIAL is the union of its children's DTL_PARTIALs, because
1372  * if any child is less than fully replicated, then so is its parent.
1373  * A vdev's DTL_MISSING is a modified union of its children's DTL_MISSINGs,
1374  * comprising only those txgs which appear in 'maxfaults' or more children;
1375  * those are the txgs we don't have enough replication to read.  For example,
1376  * double-parity RAID-Z can tolerate up to two missing devices (maxfaults == 2);
1377  * thus, its DTL_MISSING consists of the set of txgs that appear in more than
1378  * two child DTL_MISSING maps.
1379  *
1380  * It should be clear from the above that to compute the DTLs and outage maps
1381  * for all vdevs, it suffices to know just the leaf vdevs' DTL_MISSING maps.
1382  * Therefore, that is all we keep on disk.  When loading the pool, or after
1383  * a configuration change, we generate all other DTLs from first principles.
1384  */
1385 void
1386 vdev_dtl_dirty(vdev_t *vd, vdev_dtl_type_t t, uint64_t txg, uint64_t size)
1387 {
1388 	space_map_t *sm = &vd->vdev_dtl[t];
1389 
1390 	ASSERT(t < DTL_TYPES);
1391 	ASSERT(vd != vd->vdev_spa->spa_root_vdev);
1392 
1393 	mutex_enter(sm->sm_lock);
1394 	if (!space_map_contains(sm, txg, size))
1395 		space_map_add(sm, txg, size);
1396 	mutex_exit(sm->sm_lock);
1397 }
1398 
1399 boolean_t
1400 vdev_dtl_contains(vdev_t *vd, vdev_dtl_type_t t, uint64_t txg, uint64_t size)
1401 {
1402 	space_map_t *sm = &vd->vdev_dtl[t];
1403 	boolean_t dirty = B_FALSE;
1404 
1405 	ASSERT(t < DTL_TYPES);
1406 	ASSERT(vd != vd->vdev_spa->spa_root_vdev);
1407 
1408 	mutex_enter(sm->sm_lock);
1409 	if (sm->sm_space != 0)
1410 		dirty = space_map_contains(sm, txg, size);
1411 	mutex_exit(sm->sm_lock);
1412 
1413 	return (dirty);
1414 }
1415 
1416 boolean_t
1417 vdev_dtl_empty(vdev_t *vd, vdev_dtl_type_t t)
1418 {
1419 	space_map_t *sm = &vd->vdev_dtl[t];
1420 	boolean_t empty;
1421 
1422 	mutex_enter(sm->sm_lock);
1423 	empty = (sm->sm_space == 0);
1424 	mutex_exit(sm->sm_lock);
1425 
1426 	return (empty);
1427 }
1428 
1429 /*
1430  * Reassess DTLs after a config change or scrub completion.
1431  */
1432 void
1433 vdev_dtl_reassess(vdev_t *vd, uint64_t txg, uint64_t scrub_txg, int scrub_done)
1434 {
1435 	spa_t *spa = vd->vdev_spa;
1436 	avl_tree_t reftree;
1437 	int minref;
1438 
1439 	ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0);
1440 
1441 	for (int c = 0; c < vd->vdev_children; c++)
1442 		vdev_dtl_reassess(vd->vdev_child[c], txg,
1443 		    scrub_txg, scrub_done);
1444 
1445 	if (vd == spa->spa_root_vdev)
1446 		return;
1447 
1448 	if (vd->vdev_ops->vdev_op_leaf) {
1449 		mutex_enter(&vd->vdev_dtl_lock);
1450 		if (scrub_txg != 0 &&
1451 		    (spa->spa_scrub_started || spa->spa_scrub_errors == 0)) {
1452 			/* XXX should check scrub_done? */
1453 			/*
1454 			 * We completed a scrub up to scrub_txg.  If we
1455 			 * did it without rebooting, then the scrub dtl
1456 			 * will be valid, so excise the old region and
1457 			 * fold in the scrub dtl.  Otherwise, leave the
1458 			 * dtl as-is if there was an error.
1459 			 *
1460 			 * There's little trick here: to excise the beginning
1461 			 * of the DTL_MISSING map, we put it into a reference
1462 			 * tree and then add a segment with refcnt -1 that
1463 			 * covers the range [0, scrub_txg).  This means
1464 			 * that each txg in that range has refcnt -1 or 0.
1465 			 * We then add DTL_SCRUB with a refcnt of 2, so that
1466 			 * entries in the range [0, scrub_txg) will have a
1467 			 * positive refcnt -- either 1 or 2.  We then convert
1468 			 * the reference tree into the new DTL_MISSING map.
1469 			 */
1470 			space_map_ref_create(&reftree);
1471 			space_map_ref_add_map(&reftree,
1472 			    &vd->vdev_dtl[DTL_MISSING], 1);
1473 			space_map_ref_add_seg(&reftree, 0, scrub_txg, -1);
1474 			space_map_ref_add_map(&reftree,
1475 			    &vd->vdev_dtl[DTL_SCRUB], 2);
1476 			space_map_ref_generate_map(&reftree,
1477 			    &vd->vdev_dtl[DTL_MISSING], 1);
1478 			space_map_ref_destroy(&reftree);
1479 		}
1480 		space_map_vacate(&vd->vdev_dtl[DTL_PARTIAL], NULL, NULL);
1481 		space_map_walk(&vd->vdev_dtl[DTL_MISSING],
1482 		    space_map_add, &vd->vdev_dtl[DTL_PARTIAL]);
1483 		if (scrub_done)
1484 			space_map_vacate(&vd->vdev_dtl[DTL_SCRUB], NULL, NULL);
1485 		space_map_vacate(&vd->vdev_dtl[DTL_OUTAGE], NULL, NULL);
1486 		if (!vdev_readable(vd))
1487 			space_map_add(&vd->vdev_dtl[DTL_OUTAGE], 0, -1ULL);
1488 		else
1489 			space_map_walk(&vd->vdev_dtl[DTL_MISSING],
1490 			    space_map_add, &vd->vdev_dtl[DTL_OUTAGE]);
1491 		mutex_exit(&vd->vdev_dtl_lock);
1492 
1493 		if (txg != 0)
1494 			vdev_dirty(vd->vdev_top, VDD_DTL, vd, txg);
1495 		return;
1496 	}
1497 
1498 	mutex_enter(&vd->vdev_dtl_lock);
1499 	for (int t = 0; t < DTL_TYPES; t++) {
1500 		if (t == DTL_SCRUB)
1501 			continue;			/* leaf vdevs only */
1502 		if (t == DTL_PARTIAL)
1503 			minref = 1;			/* i.e. non-zero */
1504 		else if (vd->vdev_nparity != 0)
1505 			minref = vd->vdev_nparity + 1;	/* RAID-Z */
1506 		else
1507 			minref = vd->vdev_children;	/* any kind of mirror */
1508 		space_map_ref_create(&reftree);
1509 		for (int c = 0; c < vd->vdev_children; c++) {
1510 			vdev_t *cvd = vd->vdev_child[c];
1511 			mutex_enter(&cvd->vdev_dtl_lock);
1512 			space_map_ref_add_map(&reftree, &cvd->vdev_dtl[t], 1);
1513 			mutex_exit(&cvd->vdev_dtl_lock);
1514 		}
1515 		space_map_ref_generate_map(&reftree, &vd->vdev_dtl[t], minref);
1516 		space_map_ref_destroy(&reftree);
1517 	}
1518 	mutex_exit(&vd->vdev_dtl_lock);
1519 }
1520 
1521 static int
1522 vdev_dtl_load(vdev_t *vd)
1523 {
1524 	spa_t *spa = vd->vdev_spa;
1525 	space_map_obj_t *smo = &vd->vdev_dtl_smo;
1526 	objset_t *mos = spa->spa_meta_objset;
1527 	dmu_buf_t *db;
1528 	int error;
1529 
1530 	ASSERT(vd->vdev_children == 0);
1531 
1532 	if (smo->smo_object == 0)
1533 		return (0);
1534 
1535 	if ((error = dmu_bonus_hold(mos, smo->smo_object, FTAG, &db)) != 0)
1536 		return (error);
1537 
1538 	ASSERT3U(db->db_size, >=, sizeof (*smo));
1539 	bcopy(db->db_data, smo, sizeof (*smo));
1540 	dmu_buf_rele(db, FTAG);
1541 
1542 	mutex_enter(&vd->vdev_dtl_lock);
1543 	error = space_map_load(&vd->vdev_dtl[DTL_MISSING],
1544 	    NULL, SM_ALLOC, smo, mos);
1545 	mutex_exit(&vd->vdev_dtl_lock);
1546 
1547 	return (error);
1548 }
1549 
1550 void
1551 vdev_dtl_sync(vdev_t *vd, uint64_t txg)
1552 {
1553 	spa_t *spa = vd->vdev_spa;
1554 	space_map_obj_t *smo = &vd->vdev_dtl_smo;
1555 	space_map_t *sm = &vd->vdev_dtl[DTL_MISSING];
1556 	objset_t *mos = spa->spa_meta_objset;
1557 	space_map_t smsync;
1558 	kmutex_t smlock;
1559 	dmu_buf_t *db;
1560 	dmu_tx_t *tx;
1561 
1562 	tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg);
1563 
1564 	if (vd->vdev_detached) {
1565 		if (smo->smo_object != 0) {
1566 			int err = dmu_object_free(mos, smo->smo_object, tx);
1567 			ASSERT3U(err, ==, 0);
1568 			smo->smo_object = 0;
1569 		}
1570 		dmu_tx_commit(tx);
1571 		return;
1572 	}
1573 
1574 	if (smo->smo_object == 0) {
1575 		ASSERT(smo->smo_objsize == 0);
1576 		ASSERT(smo->smo_alloc == 0);
1577 		smo->smo_object = dmu_object_alloc(mos,
1578 		    DMU_OT_SPACE_MAP, 1 << SPACE_MAP_BLOCKSHIFT,
1579 		    DMU_OT_SPACE_MAP_HEADER, sizeof (*smo), tx);
1580 		ASSERT(smo->smo_object != 0);
1581 		vdev_config_dirty(vd->vdev_top);
1582 	}
1583 
1584 	mutex_init(&smlock, NULL, MUTEX_DEFAULT, NULL);
1585 
1586 	space_map_create(&smsync, sm->sm_start, sm->sm_size, sm->sm_shift,
1587 	    &smlock);
1588 
1589 	mutex_enter(&smlock);
1590 
1591 	mutex_enter(&vd->vdev_dtl_lock);
1592 	space_map_walk(sm, space_map_add, &smsync);
1593 	mutex_exit(&vd->vdev_dtl_lock);
1594 
1595 	space_map_truncate(smo, mos, tx);
1596 	space_map_sync(&smsync, SM_ALLOC, smo, mos, tx);
1597 
1598 	space_map_destroy(&smsync);
1599 
1600 	mutex_exit(&smlock);
1601 	mutex_destroy(&smlock);
1602 
1603 	VERIFY(0 == dmu_bonus_hold(mos, smo->smo_object, FTAG, &db));
1604 	dmu_buf_will_dirty(db, tx);
1605 	ASSERT3U(db->db_size, >=, sizeof (*smo));
1606 	bcopy(smo, db->db_data, sizeof (*smo));
1607 	dmu_buf_rele(db, FTAG);
1608 
1609 	dmu_tx_commit(tx);
1610 }
1611 
1612 /*
1613  * Determine whether the specified vdev can be offlined/detached/removed
1614  * without losing data.
1615  */
1616 boolean_t
1617 vdev_dtl_required(vdev_t *vd)
1618 {
1619 	spa_t *spa = vd->vdev_spa;
1620 	vdev_t *tvd = vd->vdev_top;
1621 	uint8_t cant_read = vd->vdev_cant_read;
1622 	boolean_t required;
1623 
1624 	ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);
1625 
1626 	if (vd == spa->spa_root_vdev || vd == tvd)
1627 		return (B_TRUE);
1628 
1629 	/*
1630 	 * Temporarily mark the device as unreadable, and then determine
1631 	 * whether this results in any DTL outages in the top-level vdev.
1632 	 * If not, we can safely offline/detach/remove the device.
1633 	 */
1634 	vd->vdev_cant_read = B_TRUE;
1635 	vdev_dtl_reassess(tvd, 0, 0, B_FALSE);
1636 	required = !vdev_dtl_empty(tvd, DTL_OUTAGE);
1637 	vd->vdev_cant_read = cant_read;
1638 	vdev_dtl_reassess(tvd, 0, 0, B_FALSE);
1639 
1640 	return (required);
1641 }
1642 
1643 /*
1644  * Determine if resilver is needed, and if so the txg range.
1645  */
1646 boolean_t
1647 vdev_resilver_needed(vdev_t *vd, uint64_t *minp, uint64_t *maxp)
1648 {
1649 	boolean_t needed = B_FALSE;
1650 	uint64_t thismin = UINT64_MAX;
1651 	uint64_t thismax = 0;
1652 
1653 	if (vd->vdev_children == 0) {
1654 		mutex_enter(&vd->vdev_dtl_lock);
1655 		if (vd->vdev_dtl[DTL_MISSING].sm_space != 0 &&
1656 		    vdev_writeable(vd)) {
1657 			space_seg_t *ss;
1658 
1659 			ss = avl_first(&vd->vdev_dtl[DTL_MISSING].sm_root);
1660 			thismin = ss->ss_start - 1;
1661 			ss = avl_last(&vd->vdev_dtl[DTL_MISSING].sm_root);
1662 			thismax = ss->ss_end;
1663 			needed = B_TRUE;
1664 		}
1665 		mutex_exit(&vd->vdev_dtl_lock);
1666 	} else {
1667 		for (int c = 0; c < vd->vdev_children; c++) {
1668 			vdev_t *cvd = vd->vdev_child[c];
1669 			uint64_t cmin, cmax;
1670 
1671 			if (vdev_resilver_needed(cvd, &cmin, &cmax)) {
1672 				thismin = MIN(thismin, cmin);
1673 				thismax = MAX(thismax, cmax);
1674 				needed = B_TRUE;
1675 			}
1676 		}
1677 	}
1678 
1679 	if (needed && minp) {
1680 		*minp = thismin;
1681 		*maxp = thismax;
1682 	}
1683 	return (needed);
1684 }
1685 
1686 void
1687 vdev_load(vdev_t *vd)
1688 {
1689 	/*
1690 	 * Recursively load all children.
1691 	 */
1692 	for (int c = 0; c < vd->vdev_children; c++)
1693 		vdev_load(vd->vdev_child[c]);
1694 
1695 	/*
1696 	 * If this is a top-level vdev, initialize its metaslabs.
1697 	 */
1698 	if (vd == vd->vdev_top &&
1699 	    (vd->vdev_ashift == 0 || vd->vdev_asize == 0 ||
1700 	    vdev_metaslab_init(vd, 0) != 0))
1701 		vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
1702 		    VDEV_AUX_CORRUPT_DATA);
1703 
1704 	/*
1705 	 * If this is a leaf vdev, load its DTL.
1706 	 */
1707 	if (vd->vdev_ops->vdev_op_leaf && vdev_dtl_load(vd) != 0)
1708 		vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
1709 		    VDEV_AUX_CORRUPT_DATA);
1710 }
1711 
1712 /*
1713  * The special vdev case is used for hot spares and l2cache devices.  Its
1714  * sole purpose it to set the vdev state for the associated vdev.  To do this,
1715  * we make sure that we can open the underlying device, then try to read the
1716  * label, and make sure that the label is sane and that it hasn't been
1717  * repurposed to another pool.
1718  */
1719 int
1720 vdev_validate_aux(vdev_t *vd)
1721 {
1722 	nvlist_t *label;
1723 	uint64_t guid, version;
1724 	uint64_t state;
1725 
1726 	if (!vdev_readable(vd))
1727 		return (0);
1728 
1729 	if ((label = vdev_label_read_config(vd)) == NULL) {
1730 		vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1731 		    VDEV_AUX_CORRUPT_DATA);
1732 		return (-1);
1733 	}
1734 
1735 	if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_VERSION, &version) != 0 ||
1736 	    version > SPA_VERSION ||
1737 	    nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID, &guid) != 0 ||
1738 	    guid != vd->vdev_guid ||
1739 	    nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_STATE, &state) != 0) {
1740 		vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
1741 		    VDEV_AUX_CORRUPT_DATA);
1742 		nvlist_free(label);
1743 		return (-1);
1744 	}
1745 
1746 	/*
1747 	 * We don't actually check the pool state here.  If it's in fact in
1748 	 * use by another pool, we update this fact on the fly when requested.
1749 	 */
1750 	nvlist_free(label);
1751 	return (0);
1752 }
1753 
1754 void
1755 vdev_sync_done(vdev_t *vd, uint64_t txg)
1756 {
1757 	metaslab_t *msp;
1758 
1759 	while (msp = txg_list_remove(&vd->vdev_ms_list, TXG_CLEAN(txg)))
1760 		metaslab_sync_done(msp, txg);
1761 }
1762 
1763 void
1764 vdev_sync(vdev_t *vd, uint64_t txg)
1765 {
1766 	spa_t *spa = vd->vdev_spa;
1767 	vdev_t *lvd;
1768 	metaslab_t *msp;
1769 	dmu_tx_t *tx;
1770 
1771 	if (vd->vdev_ms_array == 0 && vd->vdev_ms_shift != 0) {
1772 		ASSERT(vd == vd->vdev_top);
1773 		tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg);
1774 		vd->vdev_ms_array = dmu_object_alloc(spa->spa_meta_objset,
1775 		    DMU_OT_OBJECT_ARRAY, 0, DMU_OT_NONE, 0, tx);
1776 		ASSERT(vd->vdev_ms_array != 0);
1777 		vdev_config_dirty(vd);
1778 		dmu_tx_commit(tx);
1779 	}
1780 
1781 	while ((msp = txg_list_remove(&vd->vdev_ms_list, txg)) != NULL) {
1782 		metaslab_sync(msp, txg);
1783 		(void) txg_list_add(&vd->vdev_ms_list, msp, TXG_CLEAN(txg));
1784 	}
1785 
1786 	while ((lvd = txg_list_remove(&vd->vdev_dtl_list, txg)) != NULL)
1787 		vdev_dtl_sync(lvd, txg);
1788 
1789 	(void) txg_list_add(&spa->spa_vdev_txg_list, vd, TXG_CLEAN(txg));
1790 }
1791 
1792 uint64_t
1793 vdev_psize_to_asize(vdev_t *vd, uint64_t psize)
1794 {
1795 	return (vd->vdev_ops->vdev_op_asize(vd, psize));
1796 }
1797 
1798 /*
1799  * Mark the given vdev faulted.  A faulted vdev behaves as if the device could
1800  * not be opened, and no I/O is attempted.
1801  */
1802 int
1803 vdev_fault(spa_t *spa, uint64_t guid)
1804 {
1805 	vdev_t *vd;
1806 
1807 	spa_vdev_state_enter(spa);
1808 
1809 	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
1810 		return (spa_vdev_state_exit(spa, NULL, ENODEV));
1811 
1812 	if (!vd->vdev_ops->vdev_op_leaf)
1813 		return (spa_vdev_state_exit(spa, NULL, ENOTSUP));
1814 
1815 	/*
1816 	 * Faulted state takes precedence over degraded.
1817 	 */
1818 	vd->vdev_faulted = 1ULL;
1819 	vd->vdev_degraded = 0ULL;
1820 	vdev_set_state(vd, B_FALSE, VDEV_STATE_FAULTED, VDEV_AUX_ERR_EXCEEDED);
1821 
1822 	/*
1823 	 * If marking the vdev as faulted cause the top-level vdev to become
1824 	 * unavailable, then back off and simply mark the vdev as degraded
1825 	 * instead.
1826 	 */
1827 	if (vdev_is_dead(vd->vdev_top) && vd->vdev_aux == NULL) {
1828 		vd->vdev_degraded = 1ULL;
1829 		vd->vdev_faulted = 0ULL;
1830 
1831 		/*
1832 		 * If we reopen the device and it's not dead, only then do we
1833 		 * mark it degraded.
1834 		 */
1835 		vdev_reopen(vd);
1836 
1837 		if (vdev_readable(vd)) {
1838 			vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED,
1839 			    VDEV_AUX_ERR_EXCEEDED);
1840 		}
1841 	}
1842 
1843 	return (spa_vdev_state_exit(spa, vd, 0));
1844 }
1845 
1846 /*
1847  * Mark the given vdev degraded.  A degraded vdev is purely an indication to the
1848  * user that something is wrong.  The vdev continues to operate as normal as far
1849  * as I/O is concerned.
1850  */
1851 int
1852 vdev_degrade(spa_t *spa, uint64_t guid)
1853 {
1854 	vdev_t *vd;
1855 
1856 	spa_vdev_state_enter(spa);
1857 
1858 	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
1859 		return (spa_vdev_state_exit(spa, NULL, ENODEV));
1860 
1861 	if (!vd->vdev_ops->vdev_op_leaf)
1862 		return (spa_vdev_state_exit(spa, NULL, ENOTSUP));
1863 
1864 	/*
1865 	 * If the vdev is already faulted, then don't do anything.
1866 	 */
1867 	if (vd->vdev_faulted || vd->vdev_degraded)
1868 		return (spa_vdev_state_exit(spa, NULL, 0));
1869 
1870 	vd->vdev_degraded = 1ULL;
1871 	if (!vdev_is_dead(vd))
1872 		vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED,
1873 		    VDEV_AUX_ERR_EXCEEDED);
1874 
1875 	return (spa_vdev_state_exit(spa, vd, 0));
1876 }
1877 
1878 /*
1879  * Online the given vdev.  If 'unspare' is set, it implies two things.  First,
1880  * any attached spare device should be detached when the device finishes
1881  * resilvering.  Second, the online should be treated like a 'test' online case,
1882  * so no FMA events are generated if the device fails to open.
1883  */
1884 int
1885 vdev_online(spa_t *spa, uint64_t guid, uint64_t flags, vdev_state_t *newstate)
1886 {
1887 	vdev_t *vd;
1888 
1889 	spa_vdev_state_enter(spa);
1890 
1891 	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
1892 		return (spa_vdev_state_exit(spa, NULL, ENODEV));
1893 
1894 	if (!vd->vdev_ops->vdev_op_leaf)
1895 		return (spa_vdev_state_exit(spa, NULL, ENOTSUP));
1896 
1897 	vd->vdev_offline = B_FALSE;
1898 	vd->vdev_tmpoffline = B_FALSE;
1899 	vd->vdev_checkremove = !!(flags & ZFS_ONLINE_CHECKREMOVE);
1900 	vd->vdev_forcefault = !!(flags & ZFS_ONLINE_FORCEFAULT);
1901 	vdev_reopen(vd->vdev_top);
1902 	vd->vdev_checkremove = vd->vdev_forcefault = B_FALSE;
1903 
1904 	if (newstate)
1905 		*newstate = vd->vdev_state;
1906 	if ((flags & ZFS_ONLINE_UNSPARE) &&
1907 	    !vdev_is_dead(vd) && vd->vdev_parent &&
1908 	    vd->vdev_parent->vdev_ops == &vdev_spare_ops &&
1909 	    vd->vdev_parent->vdev_child[0] == vd)
1910 		vd->vdev_unspare = B_TRUE;
1911 
1912 	return (spa_vdev_state_exit(spa, vd, 0));
1913 }
1914 
1915 int
1916 vdev_offline(spa_t *spa, uint64_t guid, uint64_t flags)
1917 {
1918 	vdev_t *vd;
1919 
1920 	spa_vdev_state_enter(spa);
1921 
1922 	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
1923 		return (spa_vdev_state_exit(spa, NULL, ENODEV));
1924 
1925 	if (!vd->vdev_ops->vdev_op_leaf)
1926 		return (spa_vdev_state_exit(spa, NULL, ENOTSUP));
1927 
1928 	/*
1929 	 * If the device isn't already offline, try to offline it.
1930 	 */
1931 	if (!vd->vdev_offline) {
1932 		/*
1933 		 * If this device has the only valid copy of some data,
1934 		 * don't allow it to be offlined.
1935 		 */
1936 		if (vd->vdev_aux == NULL && vdev_dtl_required(vd))
1937 			return (spa_vdev_state_exit(spa, NULL, EBUSY));
1938 
1939 		/*
1940 		 * Offline this device and reopen its top-level vdev.
1941 		 * If this action results in the top-level vdev becoming
1942 		 * unusable, undo it and fail the request.
1943 		 */
1944 		vd->vdev_offline = B_TRUE;
1945 		vdev_reopen(vd->vdev_top);
1946 		if (vd->vdev_aux == NULL && vdev_is_dead(vd->vdev_top)) {
1947 			vd->vdev_offline = B_FALSE;
1948 			vdev_reopen(vd->vdev_top);
1949 			return (spa_vdev_state_exit(spa, NULL, EBUSY));
1950 		}
1951 	}
1952 
1953 	vd->vdev_tmpoffline = !!(flags & ZFS_OFFLINE_TEMPORARY);
1954 
1955 	return (spa_vdev_state_exit(spa, vd, 0));
1956 }
1957 
1958 /*
1959  * Clear the error counts associated with this vdev.  Unlike vdev_online() and
1960  * vdev_offline(), we assume the spa config is locked.  We also clear all
1961  * children.  If 'vd' is NULL, then the user wants to clear all vdevs.
1962  */
1963 void
1964 vdev_clear(spa_t *spa, vdev_t *vd)
1965 {
1966 	vdev_t *rvd = spa->spa_root_vdev;
1967 
1968 	ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);
1969 
1970 	if (vd == NULL)
1971 		vd = rvd;
1972 
1973 	vd->vdev_stat.vs_read_errors = 0;
1974 	vd->vdev_stat.vs_write_errors = 0;
1975 	vd->vdev_stat.vs_checksum_errors = 0;
1976 
1977 	for (int c = 0; c < vd->vdev_children; c++)
1978 		vdev_clear(spa, vd->vdev_child[c]);
1979 
1980 	/*
1981 	 * If we're in the FAULTED state or have experienced failed I/O, then
1982 	 * clear the persistent state and attempt to reopen the device.  We
1983 	 * also mark the vdev config dirty, so that the new faulted state is
1984 	 * written out to disk.
1985 	 */
1986 	if (vd->vdev_faulted || vd->vdev_degraded ||
1987 	    !vdev_readable(vd) || !vdev_writeable(vd)) {
1988 
1989 		vd->vdev_faulted = vd->vdev_degraded = 0;
1990 		vd->vdev_cant_read = B_FALSE;
1991 		vd->vdev_cant_write = B_FALSE;
1992 
1993 		vdev_reopen(vd);
1994 
1995 		if (vd != rvd)
1996 			vdev_state_dirty(vd->vdev_top);
1997 
1998 		if (vd->vdev_aux == NULL && !vdev_is_dead(vd))
1999 			spa_async_request(spa, SPA_ASYNC_RESILVER);
2000 
2001 		spa_event_notify(spa, vd, ESC_ZFS_VDEV_CLEAR);
2002 	}
2003 }
2004 
2005 boolean_t
2006 vdev_is_dead(vdev_t *vd)
2007 {
2008 	return (vd->vdev_state < VDEV_STATE_DEGRADED);
2009 }
2010 
2011 boolean_t
2012 vdev_readable(vdev_t *vd)
2013 {
2014 	return (!vdev_is_dead(vd) && !vd->vdev_cant_read);
2015 }
2016 
2017 boolean_t
2018 vdev_writeable(vdev_t *vd)
2019 {
2020 	return (!vdev_is_dead(vd) && !vd->vdev_cant_write);
2021 }
2022 
2023 boolean_t
2024 vdev_allocatable(vdev_t *vd)
2025 {
2026 	uint64_t state = vd->vdev_state;
2027 
2028 	/*
2029 	 * We currently allow allocations from vdevs which may be in the
2030 	 * process of reopening (i.e. VDEV_STATE_CLOSED). If the device
2031 	 * fails to reopen then we'll catch it later when we're holding
2032 	 * the proper locks.  Note that we have to get the vdev state
2033 	 * in a local variable because although it changes atomically,
2034 	 * we're asking two separate questions about it.
2035 	 */
2036 	return (!(state < VDEV_STATE_DEGRADED && state != VDEV_STATE_CLOSED) &&
2037 	    !vd->vdev_cant_write);
2038 }
2039 
2040 boolean_t
2041 vdev_accessible(vdev_t *vd, zio_t *zio)
2042 {
2043 	ASSERT(zio->io_vd == vd);
2044 
2045 	if (vdev_is_dead(vd) || vd->vdev_remove_wanted)
2046 		return (B_FALSE);
2047 
2048 	if (zio->io_type == ZIO_TYPE_READ)
2049 		return (!vd->vdev_cant_read);
2050 
2051 	if (zio->io_type == ZIO_TYPE_WRITE)
2052 		return (!vd->vdev_cant_write);
2053 
2054 	return (B_TRUE);
2055 }
2056 
2057 /*
2058  * Get statistics for the given vdev.
2059  */
2060 void
2061 vdev_get_stats(vdev_t *vd, vdev_stat_t *vs)
2062 {
2063 	vdev_t *rvd = vd->vdev_spa->spa_root_vdev;
2064 
2065 	mutex_enter(&vd->vdev_stat_lock);
2066 	bcopy(&vd->vdev_stat, vs, sizeof (*vs));
2067 	vs->vs_scrub_errors = vd->vdev_spa->spa_scrub_errors;
2068 	vs->vs_timestamp = gethrtime() - vs->vs_timestamp;
2069 	vs->vs_state = vd->vdev_state;
2070 	vs->vs_rsize = vdev_get_rsize(vd);
2071 	mutex_exit(&vd->vdev_stat_lock);
2072 
2073 	/*
2074 	 * If we're getting stats on the root vdev, aggregate the I/O counts
2075 	 * over all top-level vdevs (i.e. the direct children of the root).
2076 	 */
2077 	if (vd == rvd) {
2078 		for (int c = 0; c < rvd->vdev_children; c++) {
2079 			vdev_t *cvd = rvd->vdev_child[c];
2080 			vdev_stat_t *cvs = &cvd->vdev_stat;
2081 
2082 			mutex_enter(&vd->vdev_stat_lock);
2083 			for (int t = 0; t < ZIO_TYPES; t++) {
2084 				vs->vs_ops[t] += cvs->vs_ops[t];
2085 				vs->vs_bytes[t] += cvs->vs_bytes[t];
2086 			}
2087 			vs->vs_scrub_examined += cvs->vs_scrub_examined;
2088 			mutex_exit(&vd->vdev_stat_lock);
2089 		}
2090 	}
2091 }
2092 
2093 void
2094 vdev_clear_stats(vdev_t *vd)
2095 {
2096 	mutex_enter(&vd->vdev_stat_lock);
2097 	vd->vdev_stat.vs_space = 0;
2098 	vd->vdev_stat.vs_dspace = 0;
2099 	vd->vdev_stat.vs_alloc = 0;
2100 	mutex_exit(&vd->vdev_stat_lock);
2101 }
2102 
2103 void
2104 vdev_stat_update(zio_t *zio, uint64_t psize)
2105 {
2106 	spa_t *spa = zio->io_spa;
2107 	vdev_t *rvd = spa->spa_root_vdev;
2108 	vdev_t *vd = zio->io_vd ? zio->io_vd : rvd;
2109 	vdev_t *pvd;
2110 	uint64_t txg = zio->io_txg;
2111 	vdev_stat_t *vs = &vd->vdev_stat;
2112 	zio_type_t type = zio->io_type;
2113 	int flags = zio->io_flags;
2114 
2115 	/*
2116 	 * If this i/o is a gang leader, it didn't do any actual work.
2117 	 */
2118 	if (zio->io_gang_tree)
2119 		return;
2120 
2121 	if (zio->io_error == 0) {
2122 		/*
2123 		 * If this is a root i/o, don't count it -- we've already
2124 		 * counted the top-level vdevs, and vdev_get_stats() will
2125 		 * aggregate them when asked.  This reduces contention on
2126 		 * the root vdev_stat_lock and implicitly handles blocks
2127 		 * that compress away to holes, for which there is no i/o.
2128 		 * (Holes never create vdev children, so all the counters
2129 		 * remain zero, which is what we want.)
2130 		 *
2131 		 * Note: this only applies to successful i/o (io_error == 0)
2132 		 * because unlike i/o counts, errors are not additive.
2133 		 * When reading a ditto block, for example, failure of
2134 		 * one top-level vdev does not imply a root-level error.
2135 		 */
2136 		if (vd == rvd)
2137 			return;
2138 
2139 		ASSERT(vd == zio->io_vd);
2140 
2141 		if (flags & ZIO_FLAG_IO_BYPASS)
2142 			return;
2143 
2144 		mutex_enter(&vd->vdev_stat_lock);
2145 
2146 		if (flags & ZIO_FLAG_IO_REPAIR) {
2147 			if (flags & ZIO_FLAG_SCRUB_THREAD)
2148 				vs->vs_scrub_repaired += psize;
2149 			if (flags & ZIO_FLAG_SELF_HEAL)
2150 				vs->vs_self_healed += psize;
2151 		}
2152 
2153 		vs->vs_ops[type]++;
2154 		vs->vs_bytes[type] += psize;
2155 
2156 		mutex_exit(&vd->vdev_stat_lock);
2157 		return;
2158 	}
2159 
2160 	if (flags & ZIO_FLAG_SPECULATIVE)
2161 		return;
2162 
2163 	mutex_enter(&vd->vdev_stat_lock);
2164 	if (type == ZIO_TYPE_READ && !vdev_is_dead(vd)) {
2165 		if (zio->io_error == ECKSUM)
2166 			vs->vs_checksum_errors++;
2167 		else
2168 			vs->vs_read_errors++;
2169 	}
2170 	if (type == ZIO_TYPE_WRITE && !vdev_is_dead(vd))
2171 		vs->vs_write_errors++;
2172 	mutex_exit(&vd->vdev_stat_lock);
2173 
2174 	if (type == ZIO_TYPE_WRITE && txg != 0 &&
2175 	    (!(flags & ZIO_FLAG_IO_REPAIR) ||
2176 	    (flags & ZIO_FLAG_SCRUB_THREAD))) {
2177 		/*
2178 		 * This is either a normal write (not a repair), or it's a
2179 		 * repair induced by the scrub thread.  In the normal case,
2180 		 * we commit the DTL change in the same txg as the block
2181 		 * was born.  In the scrub-induced repair case, we know that
2182 		 * scrubs run in first-pass syncing context, so we commit
2183 		 * the DTL change in spa->spa_syncing_txg.
2184 		 *
2185 		 * We currently do not make DTL entries for failed spontaneous
2186 		 * self-healing writes triggered by normal (non-scrubbing)
2187 		 * reads, because we have no transactional context in which to
2188 		 * do so -- and it's not clear that it'd be desirable anyway.
2189 		 */
2190 		if (vd->vdev_ops->vdev_op_leaf) {
2191 			uint64_t commit_txg = txg;
2192 			if (flags & ZIO_FLAG_SCRUB_THREAD) {
2193 				ASSERT(flags & ZIO_FLAG_IO_REPAIR);
2194 				ASSERT(spa_sync_pass(spa) == 1);
2195 				vdev_dtl_dirty(vd, DTL_SCRUB, txg, 1);
2196 				commit_txg = spa->spa_syncing_txg;
2197 			}
2198 			ASSERT(commit_txg >= spa->spa_syncing_txg);
2199 			if (vdev_dtl_contains(vd, DTL_MISSING, txg, 1))
2200 				return;
2201 			for (pvd = vd; pvd != rvd; pvd = pvd->vdev_parent)
2202 				vdev_dtl_dirty(pvd, DTL_PARTIAL, txg, 1);
2203 			vdev_dirty(vd->vdev_top, VDD_DTL, vd, commit_txg);
2204 		}
2205 		if (vd != rvd)
2206 			vdev_dtl_dirty(vd, DTL_MISSING, txg, 1);
2207 	}
2208 }
2209 
2210 void
2211 vdev_scrub_stat_update(vdev_t *vd, pool_scrub_type_t type, boolean_t complete)
2212 {
2213 	int c;
2214 	vdev_stat_t *vs = &vd->vdev_stat;
2215 
2216 	for (c = 0; c < vd->vdev_children; c++)
2217 		vdev_scrub_stat_update(vd->vdev_child[c], type, complete);
2218 
2219 	mutex_enter(&vd->vdev_stat_lock);
2220 
2221 	if (type == POOL_SCRUB_NONE) {
2222 		/*
2223 		 * Update completion and end time.  Leave everything else alone
2224 		 * so we can report what happened during the previous scrub.
2225 		 */
2226 		vs->vs_scrub_complete = complete;
2227 		vs->vs_scrub_end = gethrestime_sec();
2228 	} else {
2229 		vs->vs_scrub_type = type;
2230 		vs->vs_scrub_complete = 0;
2231 		vs->vs_scrub_examined = 0;
2232 		vs->vs_scrub_repaired = 0;
2233 		vs->vs_scrub_start = gethrestime_sec();
2234 		vs->vs_scrub_end = 0;
2235 	}
2236 
2237 	mutex_exit(&vd->vdev_stat_lock);
2238 }
2239 
2240 /*
2241  * Update the in-core space usage stats for this vdev and the root vdev.
2242  */
2243 void
2244 vdev_space_update(vdev_t *vd, int64_t space_delta, int64_t alloc_delta,
2245     boolean_t update_root)
2246 {
2247 	int64_t dspace_delta = space_delta;
2248 	spa_t *spa = vd->vdev_spa;
2249 	vdev_t *rvd = spa->spa_root_vdev;
2250 
2251 	ASSERT(vd == vd->vdev_top);
2252 
2253 	/*
2254 	 * Apply the inverse of the psize-to-asize (ie. RAID-Z) space-expansion
2255 	 * factor.  We must calculate this here and not at the root vdev
2256 	 * because the root vdev's psize-to-asize is simply the max of its
2257 	 * childrens', thus not accurate enough for us.
2258 	 */
2259 	ASSERT((dspace_delta & (SPA_MINBLOCKSIZE-1)) == 0);
2260 	dspace_delta = (dspace_delta >> SPA_MINBLOCKSHIFT) *
2261 	    vd->vdev_deflate_ratio;
2262 
2263 	mutex_enter(&vd->vdev_stat_lock);
2264 	vd->vdev_stat.vs_space += space_delta;
2265 	vd->vdev_stat.vs_alloc += alloc_delta;
2266 	vd->vdev_stat.vs_dspace += dspace_delta;
2267 	mutex_exit(&vd->vdev_stat_lock);
2268 
2269 	if (update_root) {
2270 		ASSERT(rvd == vd->vdev_parent);
2271 		ASSERT(vd->vdev_ms_count != 0);
2272 
2273 		/*
2274 		 * Don't count non-normal (e.g. intent log) space as part of
2275 		 * the pool's capacity.
2276 		 */
2277 		if (vd->vdev_mg->mg_class != spa->spa_normal_class)
2278 			return;
2279 
2280 		mutex_enter(&rvd->vdev_stat_lock);
2281 		rvd->vdev_stat.vs_space += space_delta;
2282 		rvd->vdev_stat.vs_alloc += alloc_delta;
2283 		rvd->vdev_stat.vs_dspace += dspace_delta;
2284 		mutex_exit(&rvd->vdev_stat_lock);
2285 	}
2286 }
2287 
2288 /*
2289  * Mark a top-level vdev's config as dirty, placing it on the dirty list
2290  * so that it will be written out next time the vdev configuration is synced.
2291  * If the root vdev is specified (vdev_top == NULL), dirty all top-level vdevs.
2292  */
2293 void
2294 vdev_config_dirty(vdev_t *vd)
2295 {
2296 	spa_t *spa = vd->vdev_spa;
2297 	vdev_t *rvd = spa->spa_root_vdev;
2298 	int c;
2299 
2300 	/*
2301 	 * If this is an aux vdev (as with l2cache and spare devices), then we
2302 	 * update the vdev config manually and set the sync flag.
2303 	 */
2304 	if (vd->vdev_aux != NULL) {
2305 		spa_aux_vdev_t *sav = vd->vdev_aux;
2306 		nvlist_t **aux;
2307 		uint_t naux;
2308 
2309 		for (c = 0; c < sav->sav_count; c++) {
2310 			if (sav->sav_vdevs[c] == vd)
2311 				break;
2312 		}
2313 
2314 		if (c == sav->sav_count) {
2315 			/*
2316 			 * We're being removed.  There's nothing more to do.
2317 			 */
2318 			ASSERT(sav->sav_sync == B_TRUE);
2319 			return;
2320 		}
2321 
2322 		sav->sav_sync = B_TRUE;
2323 
2324 		if (nvlist_lookup_nvlist_array(sav->sav_config,
2325 		    ZPOOL_CONFIG_L2CACHE, &aux, &naux) != 0) {
2326 			VERIFY(nvlist_lookup_nvlist_array(sav->sav_config,
2327 			    ZPOOL_CONFIG_SPARES, &aux, &naux) == 0);
2328 		}
2329 
2330 		ASSERT(c < naux);
2331 
2332 		/*
2333 		 * Setting the nvlist in the middle if the array is a little
2334 		 * sketchy, but it will work.
2335 		 */
2336 		nvlist_free(aux[c]);
2337 		aux[c] = vdev_config_generate(spa, vd, B_TRUE, B_FALSE, B_TRUE);
2338 
2339 		return;
2340 	}
2341 
2342 	/*
2343 	 * The dirty list is protected by the SCL_CONFIG lock.  The caller
2344 	 * must either hold SCL_CONFIG as writer, or must be the sync thread
2345 	 * (which holds SCL_CONFIG as reader).  There's only one sync thread,
2346 	 * so this is sufficient to ensure mutual exclusion.
2347 	 */
2348 	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_WRITER) ||
2349 	    (dsl_pool_sync_context(spa_get_dsl(spa)) &&
2350 	    spa_config_held(spa, SCL_CONFIG, RW_READER)));
2351 
2352 	if (vd == rvd) {
2353 		for (c = 0; c < rvd->vdev_children; c++)
2354 			vdev_config_dirty(rvd->vdev_child[c]);
2355 	} else {
2356 		ASSERT(vd == vd->vdev_top);
2357 
2358 		if (!list_link_active(&vd->vdev_config_dirty_node))
2359 			list_insert_head(&spa->spa_config_dirty_list, vd);
2360 	}
2361 }
2362 
2363 void
2364 vdev_config_clean(vdev_t *vd)
2365 {
2366 	spa_t *spa = vd->vdev_spa;
2367 
2368 	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_WRITER) ||
2369 	    (dsl_pool_sync_context(spa_get_dsl(spa)) &&
2370 	    spa_config_held(spa, SCL_CONFIG, RW_READER)));
2371 
2372 	ASSERT(list_link_active(&vd->vdev_config_dirty_node));
2373 	list_remove(&spa->spa_config_dirty_list, vd);
2374 }
2375 
2376 /*
2377  * Mark a top-level vdev's state as dirty, so that the next pass of
2378  * spa_sync() can convert this into vdev_config_dirty().  We distinguish
2379  * the state changes from larger config changes because they require
2380  * much less locking, and are often needed for administrative actions.
2381  */
2382 void
2383 vdev_state_dirty(vdev_t *vd)
2384 {
2385 	spa_t *spa = vd->vdev_spa;
2386 
2387 	ASSERT(vd == vd->vdev_top);
2388 
2389 	/*
2390 	 * The state list is protected by the SCL_STATE lock.  The caller
2391 	 * must either hold SCL_STATE as writer, or must be the sync thread
2392 	 * (which holds SCL_STATE as reader).  There's only one sync thread,
2393 	 * so this is sufficient to ensure mutual exclusion.
2394 	 */
2395 	ASSERT(spa_config_held(spa, SCL_STATE, RW_WRITER) ||
2396 	    (dsl_pool_sync_context(spa_get_dsl(spa)) &&
2397 	    spa_config_held(spa, SCL_STATE, RW_READER)));
2398 
2399 	if (!list_link_active(&vd->vdev_state_dirty_node))
2400 		list_insert_head(&spa->spa_state_dirty_list, vd);
2401 }
2402 
2403 void
2404 vdev_state_clean(vdev_t *vd)
2405 {
2406 	spa_t *spa = vd->vdev_spa;
2407 
2408 	ASSERT(spa_config_held(spa, SCL_STATE, RW_WRITER) ||
2409 	    (dsl_pool_sync_context(spa_get_dsl(spa)) &&
2410 	    spa_config_held(spa, SCL_STATE, RW_READER)));
2411 
2412 	ASSERT(list_link_active(&vd->vdev_state_dirty_node));
2413 	list_remove(&spa->spa_state_dirty_list, vd);
2414 }
2415 
2416 /*
2417  * Propagate vdev state up from children to parent.
2418  */
2419 void
2420 vdev_propagate_state(vdev_t *vd)
2421 {
2422 	spa_t *spa = vd->vdev_spa;
2423 	vdev_t *rvd = spa->spa_root_vdev;
2424 	int degraded = 0, faulted = 0;
2425 	int corrupted = 0;
2426 	int c;
2427 	vdev_t *child;
2428 
2429 	if (vd->vdev_children > 0) {
2430 		for (c = 0; c < vd->vdev_children; c++) {
2431 			child = vd->vdev_child[c];
2432 
2433 			if (!vdev_readable(child) ||
2434 			    (!vdev_writeable(child) && spa_writeable(spa))) {
2435 				/*
2436 				 * Root special: if there is a top-level log
2437 				 * device, treat the root vdev as if it were
2438 				 * degraded.
2439 				 */
2440 				if (child->vdev_islog && vd == rvd)
2441 					degraded++;
2442 				else
2443 					faulted++;
2444 			} else if (child->vdev_state <= VDEV_STATE_DEGRADED) {
2445 				degraded++;
2446 			}
2447 
2448 			if (child->vdev_stat.vs_aux == VDEV_AUX_CORRUPT_DATA)
2449 				corrupted++;
2450 		}
2451 
2452 		vd->vdev_ops->vdev_op_state_change(vd, faulted, degraded);
2453 
2454 		/*
2455 		 * Root special: if there is a top-level vdev that cannot be
2456 		 * opened due to corrupted metadata, then propagate the root
2457 		 * vdev's aux state as 'corrupt' rather than 'insufficient
2458 		 * replicas'.
2459 		 */
2460 		if (corrupted && vd == rvd &&
2461 		    rvd->vdev_state == VDEV_STATE_CANT_OPEN)
2462 			vdev_set_state(rvd, B_FALSE, VDEV_STATE_CANT_OPEN,
2463 			    VDEV_AUX_CORRUPT_DATA);
2464 	}
2465 
2466 	if (vd->vdev_parent)
2467 		vdev_propagate_state(vd->vdev_parent);
2468 }
2469 
2470 /*
2471  * Set a vdev's state.  If this is during an open, we don't update the parent
2472  * state, because we're in the process of opening children depth-first.
2473  * Otherwise, we propagate the change to the parent.
2474  *
2475  * If this routine places a device in a faulted state, an appropriate ereport is
2476  * generated.
2477  */
2478 void
2479 vdev_set_state(vdev_t *vd, boolean_t isopen, vdev_state_t state, vdev_aux_t aux)
2480 {
2481 	uint64_t save_state;
2482 	spa_t *spa = vd->vdev_spa;
2483 
2484 	if (state == vd->vdev_state) {
2485 		vd->vdev_stat.vs_aux = aux;
2486 		return;
2487 	}
2488 
2489 	save_state = vd->vdev_state;
2490 
2491 	vd->vdev_state = state;
2492 	vd->vdev_stat.vs_aux = aux;
2493 
2494 	/*
2495 	 * If we are setting the vdev state to anything but an open state, then
2496 	 * always close the underlying device.  Otherwise, we keep accessible
2497 	 * but invalid devices open forever.  We don't call vdev_close() itself,
2498 	 * because that implies some extra checks (offline, etc) that we don't
2499 	 * want here.  This is limited to leaf devices, because otherwise
2500 	 * closing the device will affect other children.
2501 	 */
2502 	if (vdev_is_dead(vd) && vd->vdev_ops->vdev_op_leaf)
2503 		vd->vdev_ops->vdev_op_close(vd);
2504 
2505 	if (vd->vdev_removed &&
2506 	    state == VDEV_STATE_CANT_OPEN &&
2507 	    (aux == VDEV_AUX_OPEN_FAILED || vd->vdev_checkremove)) {
2508 		/*
2509 		 * If the previous state is set to VDEV_STATE_REMOVED, then this
2510 		 * device was previously marked removed and someone attempted to
2511 		 * reopen it.  If this failed due to a nonexistent device, then
2512 		 * keep the device in the REMOVED state.  We also let this be if
2513 		 * it is one of our special test online cases, which is only
2514 		 * attempting to online the device and shouldn't generate an FMA
2515 		 * fault.
2516 		 */
2517 		vd->vdev_state = VDEV_STATE_REMOVED;
2518 		vd->vdev_stat.vs_aux = VDEV_AUX_NONE;
2519 	} else if (state == VDEV_STATE_REMOVED) {
2520 		/*
2521 		 * Indicate to the ZFS DE that this device has been removed, and
2522 		 * any recent errors should be ignored.
2523 		 */
2524 		zfs_post_remove(spa, vd);
2525 		vd->vdev_removed = B_TRUE;
2526 	} else if (state == VDEV_STATE_CANT_OPEN) {
2527 		/*
2528 		 * If we fail to open a vdev during an import, we mark it as
2529 		 * "not available", which signifies that it was never there to
2530 		 * begin with.  Failure to open such a device is not considered
2531 		 * an error.
2532 		 */
2533 		if (spa->spa_load_state == SPA_LOAD_IMPORT &&
2534 		    vd->vdev_ops->vdev_op_leaf)
2535 			vd->vdev_not_present = 1;
2536 
2537 		/*
2538 		 * Post the appropriate ereport.  If the 'prevstate' field is
2539 		 * set to something other than VDEV_STATE_UNKNOWN, it indicates
2540 		 * that this is part of a vdev_reopen().  In this case, we don't
2541 		 * want to post the ereport if the device was already in the
2542 		 * CANT_OPEN state beforehand.
2543 		 *
2544 		 * If the 'checkremove' flag is set, then this is an attempt to
2545 		 * online the device in response to an insertion event.  If we
2546 		 * hit this case, then we have detected an insertion event for a
2547 		 * faulted or offline device that wasn't in the removed state.
2548 		 * In this scenario, we don't post an ereport because we are
2549 		 * about to replace the device, or attempt an online with
2550 		 * vdev_forcefault, which will generate the fault for us.
2551 		 */
2552 		if ((vd->vdev_prevstate != state || vd->vdev_forcefault) &&
2553 		    !vd->vdev_not_present && !vd->vdev_checkremove &&
2554 		    vd != spa->spa_root_vdev) {
2555 			const char *class;
2556 
2557 			switch (aux) {
2558 			case VDEV_AUX_OPEN_FAILED:
2559 				class = FM_EREPORT_ZFS_DEVICE_OPEN_FAILED;
2560 				break;
2561 			case VDEV_AUX_CORRUPT_DATA:
2562 				class = FM_EREPORT_ZFS_DEVICE_CORRUPT_DATA;
2563 				break;
2564 			case VDEV_AUX_NO_REPLICAS:
2565 				class = FM_EREPORT_ZFS_DEVICE_NO_REPLICAS;
2566 				break;
2567 			case VDEV_AUX_BAD_GUID_SUM:
2568 				class = FM_EREPORT_ZFS_DEVICE_BAD_GUID_SUM;
2569 				break;
2570 			case VDEV_AUX_TOO_SMALL:
2571 				class = FM_EREPORT_ZFS_DEVICE_TOO_SMALL;
2572 				break;
2573 			case VDEV_AUX_BAD_LABEL:
2574 				class = FM_EREPORT_ZFS_DEVICE_BAD_LABEL;
2575 				break;
2576 			case VDEV_AUX_IO_FAILURE:
2577 				class = FM_EREPORT_ZFS_IO_FAILURE;
2578 				break;
2579 			default:
2580 				class = FM_EREPORT_ZFS_DEVICE_UNKNOWN;
2581 			}
2582 
2583 			zfs_ereport_post(class, spa, vd, NULL, save_state, 0);
2584 		}
2585 
2586 		/* Erase any notion of persistent removed state */
2587 		vd->vdev_removed = B_FALSE;
2588 	} else {
2589 		vd->vdev_removed = B_FALSE;
2590 	}
2591 
2592 	if (!isopen && vd->vdev_parent)
2593 		vdev_propagate_state(vd->vdev_parent);
2594 }
2595 
2596 /*
2597  * Check the vdev configuration to ensure that it's capable of supporting
2598  * a root pool. Currently, we do not support RAID-Z or partial configuration.
2599  * In addition, only a single top-level vdev is allowed and none of the leaves
2600  * can be wholedisks.
2601  */
2602 boolean_t
2603 vdev_is_bootable(vdev_t *vd)
2604 {
2605 	int c;
2606 
2607 	if (!vd->vdev_ops->vdev_op_leaf) {
2608 		char *vdev_type = vd->vdev_ops->vdev_op_type;
2609 
2610 		if (strcmp(vdev_type, VDEV_TYPE_ROOT) == 0 &&
2611 		    vd->vdev_children > 1) {
2612 			return (B_FALSE);
2613 		} else if (strcmp(vdev_type, VDEV_TYPE_RAIDZ) == 0 ||
2614 		    strcmp(vdev_type, VDEV_TYPE_MISSING) == 0) {
2615 			return (B_FALSE);
2616 		}
2617 	} else if (vd->vdev_wholedisk == 1) {
2618 		return (B_FALSE);
2619 	}
2620 
2621 	for (c = 0; c < vd->vdev_children; c++) {
2622 		if (!vdev_is_bootable(vd->vdev_child[c]))
2623 			return (B_FALSE);
2624 	}
2625 	return (B_TRUE);
2626 }
2627