xref: /illumos-gate/usr/src/uts/common/fs/zfs/vdev_label.c (revision 5cabbc6b49070407fb9610cfe73d4c0e0dea3e77)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright (c) 2012, 2015 by Delphix. All rights reserved.
25  */
26 
27 /*
28  * Virtual Device Labels
29  * ---------------------
30  *
31  * The vdev label serves several distinct purposes:
32  *
33  *	1. Uniquely identify this device as part of a ZFS pool and confirm its
34  *	   identity within the pool.
35  *
36  * 	2. Verify that all the devices given in a configuration are present
37  *         within the pool.
38  *
39  * 	3. Determine the uberblock for the pool.
40  *
41  * 	4. In case of an import operation, determine the configuration of the
42  *         toplevel vdev of which it is a part.
43  *
44  * 	5. If an import operation cannot find all the devices in the pool,
45  *         provide enough information to the administrator to determine which
46  *         devices are missing.
47  *
48  * It is important to note that while the kernel is responsible for writing the
49  * label, it only consumes the information in the first three cases.  The
50  * latter information is only consumed in userland when determining the
51  * configuration to import a pool.
52  *
53  *
54  * Label Organization
55  * ------------------
56  *
57  * Before describing the contents of the label, it's important to understand how
58  * the labels are written and updated with respect to the uberblock.
59  *
60  * When the pool configuration is altered, either because it was newly created
61  * or a device was added, we want to update all the labels such that we can deal
62  * with fatal failure at any point.  To this end, each disk has two labels which
63  * are updated before and after the uberblock is synced.  Assuming we have
64  * labels and an uberblock with the following transaction groups:
65  *
66  *              L1          UB          L2
67  *           +------+    +------+    +------+
68  *           |      |    |      |    |      |
69  *           | t10  |    | t10  |    | t10  |
70  *           |      |    |      |    |      |
71  *           +------+    +------+    +------+
72  *
73  * In this stable state, the labels and the uberblock were all updated within
74  * the same transaction group (10).  Each label is mirrored and checksummed, so
75  * that we can detect when we fail partway through writing the label.
76  *
77  * In order to identify which labels are valid, the labels are written in the
78  * following manner:
79  *
80  * 	1. For each vdev, update 'L1' to the new label
81  * 	2. Update the uberblock
82  * 	3. For each vdev, update 'L2' to the new label
83  *
84  * Given arbitrary failure, we can determine the correct label to use based on
85  * the transaction group.  If we fail after updating L1 but before updating the
86  * UB, we will notice that L1's transaction group is greater than the uberblock,
87  * so L2 must be valid.  If we fail after writing the uberblock but before
88  * writing L2, we will notice that L2's transaction group is less than L1, and
89  * therefore L1 is valid.
90  *
91  * Another added complexity is that not every label is updated when the config
92  * is synced.  If we add a single device, we do not want to have to re-write
93  * every label for every device in the pool.  This means that both L1 and L2 may
94  * be older than the pool uberblock, because the necessary information is stored
95  * on another vdev.
96  *
97  *
98  * On-disk Format
99  * --------------
100  *
101  * The vdev label consists of two distinct parts, and is wrapped within the
102  * vdev_label_t structure.  The label includes 8k of padding to permit legacy
103  * VTOC disk labels, but is otherwise ignored.
104  *
105  * The first half of the label is a packed nvlist which contains pool wide
106  * properties, per-vdev properties, and configuration information.  It is
107  * described in more detail below.
108  *
109  * The latter half of the label consists of a redundant array of uberblocks.
110  * These uberblocks are updated whenever a transaction group is committed,
111  * or when the configuration is updated.  When a pool is loaded, we scan each
112  * vdev for the 'best' uberblock.
113  *
114  *
115  * Configuration Information
116  * -------------------------
117  *
118  * The nvlist describing the pool and vdev contains the following elements:
119  *
120  * 	version		ZFS on-disk version
121  * 	name		Pool name
122  * 	state		Pool state
123  * 	txg		Transaction group in which this label was written
124  * 	pool_guid	Unique identifier for this pool
125  * 	vdev_tree	An nvlist describing vdev tree.
126  *	features_for_read
127  *			An nvlist of the features necessary for reading the MOS.
128  *
129  * Each leaf device label also contains the following:
130  *
131  * 	top_guid	Unique ID for top-level vdev in which this is contained
132  * 	guid		Unique ID for the leaf vdev
133  *
134  * The 'vs' configuration follows the format described in 'spa_config.c'.
135  */
136 
137 #include <sys/zfs_context.h>
138 #include <sys/spa.h>
139 #include <sys/spa_impl.h>
140 #include <sys/dmu.h>
141 #include <sys/zap.h>
142 #include <sys/vdev.h>
143 #include <sys/vdev_impl.h>
144 #include <sys/uberblock_impl.h>
145 #include <sys/metaslab.h>
146 #include <sys/metaslab_impl.h>
147 #include <sys/zio.h>
148 #include <sys/dsl_scan.h>
149 #include <sys/abd.h>
150 #include <sys/fs/zfs.h>
151 
152 /*
153  * Basic routines to read and write from a vdev label.
154  * Used throughout the rest of this file.
155  */
156 uint64_t
157 vdev_label_offset(uint64_t psize, int l, uint64_t offset)
158 {
159 	ASSERT(offset < sizeof (vdev_label_t));
160 	ASSERT(P2PHASE_TYPED(psize, sizeof (vdev_label_t), uint64_t) == 0);
161 
162 	return (offset + l * sizeof (vdev_label_t) + (l < VDEV_LABELS / 2 ?
163 	    0 : psize - VDEV_LABELS * sizeof (vdev_label_t)));
164 }
165 
166 /*
167  * Returns back the vdev label associated with the passed in offset.
168  */
169 int
170 vdev_label_number(uint64_t psize, uint64_t offset)
171 {
172 	int l;
173 
174 	if (offset >= psize - VDEV_LABEL_END_SIZE) {
175 		offset -= psize - VDEV_LABEL_END_SIZE;
176 		offset += (VDEV_LABELS / 2) * sizeof (vdev_label_t);
177 	}
178 	l = offset / sizeof (vdev_label_t);
179 	return (l < VDEV_LABELS ? l : -1);
180 }
181 
182 static void
183 vdev_label_read(zio_t *zio, vdev_t *vd, int l, abd_t *buf, uint64_t offset,
184     uint64_t size, zio_done_func_t *done, void *private, int flags)
185 {
186 	ASSERT(spa_config_held(zio->io_spa, SCL_STATE_ALL, RW_WRITER) ==
187 	    SCL_STATE_ALL);
188 	ASSERT(flags & ZIO_FLAG_CONFIG_WRITER);
189 
190 	zio_nowait(zio_read_phys(zio, vd,
191 	    vdev_label_offset(vd->vdev_psize, l, offset),
192 	    size, buf, ZIO_CHECKSUM_LABEL, done, private,
193 	    ZIO_PRIORITY_SYNC_READ, flags, B_TRUE));
194 }
195 
196 static void
197 vdev_label_write(zio_t *zio, vdev_t *vd, int l, abd_t *buf, uint64_t offset,
198     uint64_t size, zio_done_func_t *done, void *private, int flags)
199 {
200 	ASSERT(spa_config_held(zio->io_spa, SCL_ALL, RW_WRITER) == SCL_ALL ||
201 	    (spa_config_held(zio->io_spa, SCL_CONFIG | SCL_STATE, RW_READER) ==
202 	    (SCL_CONFIG | SCL_STATE) &&
203 	    dsl_pool_sync_context(spa_get_dsl(zio->io_spa))));
204 	ASSERT(flags & ZIO_FLAG_CONFIG_WRITER);
205 
206 	zio_nowait(zio_write_phys(zio, vd,
207 	    vdev_label_offset(vd->vdev_psize, l, offset),
208 	    size, buf, ZIO_CHECKSUM_LABEL, done, private,
209 	    ZIO_PRIORITY_SYNC_WRITE, flags, B_TRUE));
210 }
211 
212 /*
213  * Generate the nvlist representing this vdev's config.
214  */
215 nvlist_t *
216 vdev_config_generate(spa_t *spa, vdev_t *vd, boolean_t getstats,
217     vdev_config_flag_t flags)
218 {
219 	nvlist_t *nv = NULL;
220 	vdev_indirect_config_t *vic = &vd->vdev_indirect_config;
221 
222 	nv = fnvlist_alloc();
223 
224 	fnvlist_add_string(nv, ZPOOL_CONFIG_TYPE, vd->vdev_ops->vdev_op_type);
225 	if (!(flags & (VDEV_CONFIG_SPARE | VDEV_CONFIG_L2CACHE)))
226 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_ID, vd->vdev_id);
227 	fnvlist_add_uint64(nv, ZPOOL_CONFIG_GUID, vd->vdev_guid);
228 
229 	if (vd->vdev_path != NULL)
230 		fnvlist_add_string(nv, ZPOOL_CONFIG_PATH, vd->vdev_path);
231 
232 	if (vd->vdev_devid != NULL)
233 		fnvlist_add_string(nv, ZPOOL_CONFIG_DEVID, vd->vdev_devid);
234 
235 	if (vd->vdev_physpath != NULL)
236 		fnvlist_add_string(nv, ZPOOL_CONFIG_PHYS_PATH,
237 		    vd->vdev_physpath);
238 
239 	if (vd->vdev_fru != NULL)
240 		fnvlist_add_string(nv, ZPOOL_CONFIG_FRU, vd->vdev_fru);
241 
242 	if (vd->vdev_nparity != 0) {
243 		ASSERT(strcmp(vd->vdev_ops->vdev_op_type,
244 		    VDEV_TYPE_RAIDZ) == 0);
245 
246 		/*
247 		 * Make sure someone hasn't managed to sneak a fancy new vdev
248 		 * into a crufty old storage pool.
249 		 */
250 		ASSERT(vd->vdev_nparity == 1 ||
251 		    (vd->vdev_nparity <= 2 &&
252 		    spa_version(spa) >= SPA_VERSION_RAIDZ2) ||
253 		    (vd->vdev_nparity <= 3 &&
254 		    spa_version(spa) >= SPA_VERSION_RAIDZ3));
255 
256 		/*
257 		 * Note that we'll add the nparity tag even on storage pools
258 		 * that only support a single parity device -- older software
259 		 * will just ignore it.
260 		 */
261 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_NPARITY, vd->vdev_nparity);
262 	}
263 
264 	if (vd->vdev_wholedisk != -1ULL)
265 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
266 		    vd->vdev_wholedisk);
267 
268 	if (vd->vdev_not_present)
269 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 1);
270 
271 	if (vd->vdev_isspare)
272 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_SPARE, 1);
273 
274 	if (!(flags & (VDEV_CONFIG_SPARE | VDEV_CONFIG_L2CACHE)) &&
275 	    vd == vd->vdev_top) {
276 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_METASLAB_ARRAY,
277 		    vd->vdev_ms_array);
278 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_METASLAB_SHIFT,
279 		    vd->vdev_ms_shift);
280 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_ASHIFT, vd->vdev_ashift);
281 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_ASIZE,
282 		    vd->vdev_asize);
283 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_LOG, vd->vdev_islog);
284 		if (vd->vdev_removing) {
285 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_REMOVING,
286 			    vd->vdev_removing);
287 		}
288 	}
289 
290 	if (vd->vdev_dtl_sm != NULL) {
291 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_DTL,
292 		    space_map_object(vd->vdev_dtl_sm));
293 	}
294 
295 	if (vic->vic_mapping_object != 0) {
296 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_INDIRECT_OBJECT,
297 		    vic->vic_mapping_object);
298 	}
299 
300 	if (vic->vic_births_object != 0) {
301 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_INDIRECT_BIRTHS,
302 		    vic->vic_births_object);
303 	}
304 
305 	if (vic->vic_prev_indirect_vdev != UINT64_MAX) {
306 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_PREV_INDIRECT_VDEV,
307 		    vic->vic_prev_indirect_vdev);
308 	}
309 
310 	if (vd->vdev_crtxg)
311 		fnvlist_add_uint64(nv, ZPOOL_CONFIG_CREATE_TXG, vd->vdev_crtxg);
312 
313 	if (flags & VDEV_CONFIG_MOS) {
314 		if (vd->vdev_leaf_zap != 0) {
315 			ASSERT(vd->vdev_ops->vdev_op_leaf);
316 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_VDEV_LEAF_ZAP,
317 			    vd->vdev_leaf_zap);
318 		}
319 
320 		if (vd->vdev_top_zap != 0) {
321 			ASSERT(vd == vd->vdev_top);
322 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_VDEV_TOP_ZAP,
323 			    vd->vdev_top_zap);
324 		}
325 	}
326 
327 	if (getstats) {
328 		vdev_stat_t vs;
329 
330 		vdev_get_stats(vd, &vs);
331 		fnvlist_add_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
332 		    (uint64_t *)&vs, sizeof (vs) / sizeof (uint64_t));
333 
334 		/* provide either current or previous scan information */
335 		pool_scan_stat_t ps;
336 		if (spa_scan_get_stats(spa, &ps) == 0) {
337 			fnvlist_add_uint64_array(nv,
338 			    ZPOOL_CONFIG_SCAN_STATS, (uint64_t *)&ps,
339 			    sizeof (pool_scan_stat_t) / sizeof (uint64_t));
340 		}
341 
342 		pool_removal_stat_t prs;
343 		if (spa_removal_get_stats(spa, &prs) == 0) {
344 			fnvlist_add_uint64_array(nv,
345 			    ZPOOL_CONFIG_REMOVAL_STATS, (uint64_t *)&prs,
346 			    sizeof (prs) / sizeof (uint64_t));
347 		}
348 
349 		/*
350 		 * Note: this can be called from open context
351 		 * (spa_get_stats()), so we need the rwlock to prevent
352 		 * the mapping from being changed by condensing.
353 		 */
354 		rw_enter(&vd->vdev_indirect_rwlock, RW_READER);
355 		if (vd->vdev_indirect_mapping != NULL) {
356 			ASSERT(vd->vdev_indirect_births != NULL);
357 			vdev_indirect_mapping_t *vim =
358 			    vd->vdev_indirect_mapping;
359 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_INDIRECT_SIZE,
360 			    vdev_indirect_mapping_size(vim));
361 		}
362 		rw_exit(&vd->vdev_indirect_rwlock);
363 		if (vd->vdev_mg != NULL &&
364 		    vd->vdev_mg->mg_fragmentation != ZFS_FRAG_INVALID) {
365 			/*
366 			 * Compute approximately how much memory would be used
367 			 * for the indirect mapping if this device were to
368 			 * be removed.
369 			 *
370 			 * Note: If the frag metric is invalid, then not
371 			 * enough metaslabs have been converted to have
372 			 * histograms.
373 			 */
374 			uint64_t seg_count = 0;
375 
376 			/*
377 			 * There are the same number of allocated segments
378 			 * as free segments, so we will have at least one
379 			 * entry per free segment.
380 			 */
381 			for (int i = 0; i < RANGE_TREE_HISTOGRAM_SIZE; i++) {
382 				seg_count += vd->vdev_mg->mg_histogram[i];
383 			}
384 
385 			/*
386 			 * The maximum length of a mapping is SPA_MAXBLOCKSIZE,
387 			 * so we need at least one entry per SPA_MAXBLOCKSIZE
388 			 * of allocated data.
389 			 */
390 			seg_count += vd->vdev_stat.vs_alloc / SPA_MAXBLOCKSIZE;
391 
392 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_INDIRECT_SIZE,
393 			    seg_count *
394 			    sizeof (vdev_indirect_mapping_entry_phys_t));
395 		}
396 	}
397 
398 	if (!vd->vdev_ops->vdev_op_leaf) {
399 		nvlist_t **child;
400 		int c, idx;
401 
402 		ASSERT(!vd->vdev_ishole);
403 
404 		child = kmem_alloc(vd->vdev_children * sizeof (nvlist_t *),
405 		    KM_SLEEP);
406 
407 		for (c = 0, idx = 0; c < vd->vdev_children; c++) {
408 			vdev_t *cvd = vd->vdev_child[c];
409 
410 			/*
411 			 * If we're generating an nvlist of removing
412 			 * vdevs then skip over any device which is
413 			 * not being removed.
414 			 */
415 			if ((flags & VDEV_CONFIG_REMOVING) &&
416 			    !cvd->vdev_removing)
417 				continue;
418 
419 			child[idx++] = vdev_config_generate(spa, cvd,
420 			    getstats, flags);
421 		}
422 
423 		if (idx) {
424 			fnvlist_add_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
425 			    child, idx);
426 		}
427 
428 		for (c = 0; c < idx; c++)
429 			nvlist_free(child[c]);
430 
431 		kmem_free(child, vd->vdev_children * sizeof (nvlist_t *));
432 
433 	} else {
434 		const char *aux = NULL;
435 
436 		if (vd->vdev_offline && !vd->vdev_tmpoffline)
437 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_OFFLINE, B_TRUE);
438 		if (vd->vdev_resilver_txg != 0)
439 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_RESILVER_TXG,
440 			    vd->vdev_resilver_txg);
441 		if (vd->vdev_faulted)
442 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_FAULTED, B_TRUE);
443 		if (vd->vdev_degraded)
444 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_DEGRADED, B_TRUE);
445 		if (vd->vdev_removed)
446 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_REMOVED, B_TRUE);
447 		if (vd->vdev_unspare)
448 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_UNSPARE, B_TRUE);
449 		if (vd->vdev_ishole)
450 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_HOLE, B_TRUE);
451 
452 		switch (vd->vdev_stat.vs_aux) {
453 		case VDEV_AUX_ERR_EXCEEDED:
454 			aux = "err_exceeded";
455 			break;
456 
457 		case VDEV_AUX_EXTERNAL:
458 			aux = "external";
459 			break;
460 		}
461 
462 		if (aux != NULL)
463 			fnvlist_add_string(nv, ZPOOL_CONFIG_AUX_STATE, aux);
464 
465 		if (vd->vdev_splitting && vd->vdev_orig_guid != 0LL) {
466 			fnvlist_add_uint64(nv, ZPOOL_CONFIG_ORIG_GUID,
467 			    vd->vdev_orig_guid);
468 		}
469 	}
470 
471 	return (nv);
472 }
473 
474 /*
475  * Generate a view of the top-level vdevs.  If we currently have holes
476  * in the namespace, then generate an array which contains a list of holey
477  * vdevs.  Additionally, add the number of top-level children that currently
478  * exist.
479  */
480 void
481 vdev_top_config_generate(spa_t *spa, nvlist_t *config)
482 {
483 	vdev_t *rvd = spa->spa_root_vdev;
484 	uint64_t *array;
485 	uint_t c, idx;
486 
487 	array = kmem_alloc(rvd->vdev_children * sizeof (uint64_t), KM_SLEEP);
488 
489 	for (c = 0, idx = 0; c < rvd->vdev_children; c++) {
490 		vdev_t *tvd = rvd->vdev_child[c];
491 
492 		if (tvd->vdev_ishole) {
493 			array[idx++] = c;
494 		}
495 	}
496 
497 	if (idx) {
498 		VERIFY(nvlist_add_uint64_array(config, ZPOOL_CONFIG_HOLE_ARRAY,
499 		    array, idx) == 0);
500 	}
501 
502 	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_VDEV_CHILDREN,
503 	    rvd->vdev_children) == 0);
504 
505 	kmem_free(array, rvd->vdev_children * sizeof (uint64_t));
506 }
507 
508 /*
509  * Returns the configuration from the label of the given vdev. For vdevs
510  * which don't have a txg value stored on their label (i.e. spares/cache)
511  * or have not been completely initialized (txg = 0) just return
512  * the configuration from the first valid label we find. Otherwise,
513  * find the most up-to-date label that does not exceed the specified
514  * 'txg' value.
515  */
516 nvlist_t *
517 vdev_label_read_config(vdev_t *vd, uint64_t txg)
518 {
519 	spa_t *spa = vd->vdev_spa;
520 	nvlist_t *config = NULL;
521 	vdev_phys_t *vp;
522 	abd_t *vp_abd;
523 	zio_t *zio;
524 	uint64_t best_txg = 0;
525 	int error = 0;
526 	int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL |
527 	    ZIO_FLAG_SPECULATIVE;
528 
529 	ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);
530 
531 	if (!vdev_readable(vd))
532 		return (NULL);
533 
534 	vp_abd = abd_alloc_linear(sizeof (vdev_phys_t), B_TRUE);
535 	vp = abd_to_buf(vp_abd);
536 
537 retry:
538 	for (int l = 0; l < VDEV_LABELS; l++) {
539 		nvlist_t *label = NULL;
540 
541 		zio = zio_root(spa, NULL, NULL, flags);
542 
543 		vdev_label_read(zio, vd, l, vp_abd,
544 		    offsetof(vdev_label_t, vl_vdev_phys),
545 		    sizeof (vdev_phys_t), NULL, NULL, flags);
546 
547 		if (zio_wait(zio) == 0 &&
548 		    nvlist_unpack(vp->vp_nvlist, sizeof (vp->vp_nvlist),
549 		    &label, 0) == 0) {
550 			uint64_t label_txg = 0;
551 
552 			/*
553 			 * Auxiliary vdevs won't have txg values in their
554 			 * labels and newly added vdevs may not have been
555 			 * completely initialized so just return the
556 			 * configuration from the first valid label we
557 			 * encounter.
558 			 */
559 			error = nvlist_lookup_uint64(label,
560 			    ZPOOL_CONFIG_POOL_TXG, &label_txg);
561 			if ((error || label_txg == 0) && !config) {
562 				config = label;
563 				break;
564 			} else if (label_txg <= txg && label_txg > best_txg) {
565 				best_txg = label_txg;
566 				nvlist_free(config);
567 				config = fnvlist_dup(label);
568 			}
569 		}
570 
571 		if (label != NULL) {
572 			nvlist_free(label);
573 			label = NULL;
574 		}
575 	}
576 
577 	if (config == NULL && !(flags & ZIO_FLAG_TRYHARD)) {
578 		flags |= ZIO_FLAG_TRYHARD;
579 		goto retry;
580 	}
581 
582 	abd_free(vp_abd);
583 
584 	return (config);
585 }
586 
587 /*
588  * Determine if a device is in use.  The 'spare_guid' parameter will be filled
589  * in with the device guid if this spare is active elsewhere on the system.
590  */
591 static boolean_t
592 vdev_inuse(vdev_t *vd, uint64_t crtxg, vdev_labeltype_t reason,
593     uint64_t *spare_guid, uint64_t *l2cache_guid)
594 {
595 	spa_t *spa = vd->vdev_spa;
596 	uint64_t state, pool_guid, device_guid, txg, spare_pool;
597 	uint64_t vdtxg = 0;
598 	nvlist_t *label;
599 
600 	if (spare_guid)
601 		*spare_guid = 0ULL;
602 	if (l2cache_guid)
603 		*l2cache_guid = 0ULL;
604 
605 	/*
606 	 * Read the label, if any, and perform some basic sanity checks.
607 	 */
608 	if ((label = vdev_label_read_config(vd, -1ULL)) == NULL)
609 		return (B_FALSE);
610 
611 	(void) nvlist_lookup_uint64(label, ZPOOL_CONFIG_CREATE_TXG,
612 	    &vdtxg);
613 
614 	if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_STATE,
615 	    &state) != 0 ||
616 	    nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID,
617 	    &device_guid) != 0) {
618 		nvlist_free(label);
619 		return (B_FALSE);
620 	}
621 
622 	if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
623 	    (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_GUID,
624 	    &pool_guid) != 0 ||
625 	    nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_TXG,
626 	    &txg) != 0)) {
627 		nvlist_free(label);
628 		return (B_FALSE);
629 	}
630 
631 	nvlist_free(label);
632 
633 	/*
634 	 * Check to see if this device indeed belongs to the pool it claims to
635 	 * be a part of.  The only way this is allowed is if the device is a hot
636 	 * spare (which we check for later on).
637 	 */
638 	if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
639 	    !spa_guid_exists(pool_guid, device_guid) &&
640 	    !spa_spare_exists(device_guid, NULL, NULL) &&
641 	    !spa_l2cache_exists(device_guid, NULL))
642 		return (B_FALSE);
643 
644 	/*
645 	 * If the transaction group is zero, then this an initialized (but
646 	 * unused) label.  This is only an error if the create transaction
647 	 * on-disk is the same as the one we're using now, in which case the
648 	 * user has attempted to add the same vdev multiple times in the same
649 	 * transaction.
650 	 */
651 	if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
652 	    txg == 0 && vdtxg == crtxg)
653 		return (B_TRUE);
654 
655 	/*
656 	 * Check to see if this is a spare device.  We do an explicit check for
657 	 * spa_has_spare() here because it may be on our pending list of spares
658 	 * to add.  We also check if it is an l2cache device.
659 	 */
660 	if (spa_spare_exists(device_guid, &spare_pool, NULL) ||
661 	    spa_has_spare(spa, device_guid)) {
662 		if (spare_guid)
663 			*spare_guid = device_guid;
664 
665 		switch (reason) {
666 		case VDEV_LABEL_CREATE:
667 		case VDEV_LABEL_L2CACHE:
668 			return (B_TRUE);
669 
670 		case VDEV_LABEL_REPLACE:
671 			return (!spa_has_spare(spa, device_guid) ||
672 			    spare_pool != 0ULL);
673 
674 		case VDEV_LABEL_SPARE:
675 			return (spa_has_spare(spa, device_guid));
676 		}
677 	}
678 
679 	/*
680 	 * Check to see if this is an l2cache device.
681 	 */
682 	if (spa_l2cache_exists(device_guid, NULL))
683 		return (B_TRUE);
684 
685 	/*
686 	 * We can't rely on a pool's state if it's been imported
687 	 * read-only.  Instead we look to see if the pools is marked
688 	 * read-only in the namespace and set the state to active.
689 	 */
690 	if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
691 	    (spa = spa_by_guid(pool_guid, device_guid)) != NULL &&
692 	    spa_mode(spa) == FREAD)
693 		state = POOL_STATE_ACTIVE;
694 
695 	/*
696 	 * If the device is marked ACTIVE, then this device is in use by another
697 	 * pool on the system.
698 	 */
699 	return (state == POOL_STATE_ACTIVE);
700 }
701 
702 /*
703  * Initialize a vdev label.  We check to make sure each leaf device is not in
704  * use, and writable.  We put down an initial label which we will later
705  * overwrite with a complete label.  Note that it's important to do this
706  * sequentially, not in parallel, so that we catch cases of multiple use of the
707  * same leaf vdev in the vdev we're creating -- e.g. mirroring a disk with
708  * itself.
709  */
710 int
711 vdev_label_init(vdev_t *vd, uint64_t crtxg, vdev_labeltype_t reason)
712 {
713 	spa_t *spa = vd->vdev_spa;
714 	nvlist_t *label;
715 	vdev_phys_t *vp;
716 	abd_t *vp_abd;
717 	abd_t *pad2;
718 	uberblock_t *ub;
719 	abd_t *ub_abd;
720 	zio_t *zio;
721 	char *buf;
722 	size_t buflen;
723 	int error;
724 	uint64_t spare_guid, l2cache_guid;
725 	int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL;
726 
727 	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
728 
729 	for (int c = 0; c < vd->vdev_children; c++)
730 		if ((error = vdev_label_init(vd->vdev_child[c],
731 		    crtxg, reason)) != 0)
732 			return (error);
733 
734 	/* Track the creation time for this vdev */
735 	vd->vdev_crtxg = crtxg;
736 
737 	if (!vd->vdev_ops->vdev_op_leaf || !spa_writeable(spa))
738 		return (0);
739 
740 	/*
741 	 * Dead vdevs cannot be initialized.
742 	 */
743 	if (vdev_is_dead(vd))
744 		return (SET_ERROR(EIO));
745 
746 	/*
747 	 * Determine if the vdev is in use.
748 	 */
749 	if (reason != VDEV_LABEL_REMOVE && reason != VDEV_LABEL_SPLIT &&
750 	    vdev_inuse(vd, crtxg, reason, &spare_guid, &l2cache_guid))
751 		return (SET_ERROR(EBUSY));
752 
753 	/*
754 	 * If this is a request to add or replace a spare or l2cache device
755 	 * that is in use elsewhere on the system, then we must update the
756 	 * guid (which was initialized to a random value) to reflect the
757 	 * actual GUID (which is shared between multiple pools).
758 	 */
759 	if (reason != VDEV_LABEL_REMOVE && reason != VDEV_LABEL_L2CACHE &&
760 	    spare_guid != 0ULL) {
761 		uint64_t guid_delta = spare_guid - vd->vdev_guid;
762 
763 		vd->vdev_guid += guid_delta;
764 
765 		for (vdev_t *pvd = vd; pvd != NULL; pvd = pvd->vdev_parent)
766 			pvd->vdev_guid_sum += guid_delta;
767 
768 		/*
769 		 * If this is a replacement, then we want to fallthrough to the
770 		 * rest of the code.  If we're adding a spare, then it's already
771 		 * labeled appropriately and we can just return.
772 		 */
773 		if (reason == VDEV_LABEL_SPARE)
774 			return (0);
775 		ASSERT(reason == VDEV_LABEL_REPLACE ||
776 		    reason == VDEV_LABEL_SPLIT);
777 	}
778 
779 	if (reason != VDEV_LABEL_REMOVE && reason != VDEV_LABEL_SPARE &&
780 	    l2cache_guid != 0ULL) {
781 		uint64_t guid_delta = l2cache_guid - vd->vdev_guid;
782 
783 		vd->vdev_guid += guid_delta;
784 
785 		for (vdev_t *pvd = vd; pvd != NULL; pvd = pvd->vdev_parent)
786 			pvd->vdev_guid_sum += guid_delta;
787 
788 		/*
789 		 * If this is a replacement, then we want to fallthrough to the
790 		 * rest of the code.  If we're adding an l2cache, then it's
791 		 * already labeled appropriately and we can just return.
792 		 */
793 		if (reason == VDEV_LABEL_L2CACHE)
794 			return (0);
795 		ASSERT(reason == VDEV_LABEL_REPLACE);
796 	}
797 
798 	/*
799 	 * Initialize its label.
800 	 */
801 	vp_abd = abd_alloc_linear(sizeof (vdev_phys_t), B_TRUE);
802 	abd_zero(vp_abd, sizeof (vdev_phys_t));
803 	vp = abd_to_buf(vp_abd);
804 
805 	/*
806 	 * Generate a label describing the pool and our top-level vdev.
807 	 * We mark it as being from txg 0 to indicate that it's not
808 	 * really part of an active pool just yet.  The labels will
809 	 * be written again with a meaningful txg by spa_sync().
810 	 */
811 	if (reason == VDEV_LABEL_SPARE ||
812 	    (reason == VDEV_LABEL_REMOVE && vd->vdev_isspare)) {
813 		/*
814 		 * For inactive hot spares, we generate a special label that
815 		 * identifies as a mutually shared hot spare.  We write the
816 		 * label if we are adding a hot spare, or if we are removing an
817 		 * active hot spare (in which case we want to revert the
818 		 * labels).
819 		 */
820 		VERIFY(nvlist_alloc(&label, NV_UNIQUE_NAME, KM_SLEEP) == 0);
821 
822 		VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_VERSION,
823 		    spa_version(spa)) == 0);
824 		VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_POOL_STATE,
825 		    POOL_STATE_SPARE) == 0);
826 		VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_GUID,
827 		    vd->vdev_guid) == 0);
828 	} else if (reason == VDEV_LABEL_L2CACHE ||
829 	    (reason == VDEV_LABEL_REMOVE && vd->vdev_isl2cache)) {
830 		/*
831 		 * For level 2 ARC devices, add a special label.
832 		 */
833 		VERIFY(nvlist_alloc(&label, NV_UNIQUE_NAME, KM_SLEEP) == 0);
834 
835 		VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_VERSION,
836 		    spa_version(spa)) == 0);
837 		VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_POOL_STATE,
838 		    POOL_STATE_L2CACHE) == 0);
839 		VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_GUID,
840 		    vd->vdev_guid) == 0);
841 	} else {
842 		uint64_t txg = 0ULL;
843 
844 		if (reason == VDEV_LABEL_SPLIT)
845 			txg = spa->spa_uberblock.ub_txg;
846 		label = spa_config_generate(spa, vd, txg, B_FALSE);
847 
848 		/*
849 		 * Add our creation time.  This allows us to detect multiple
850 		 * vdev uses as described above, and automatically expires if we
851 		 * fail.
852 		 */
853 		VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_CREATE_TXG,
854 		    crtxg) == 0);
855 	}
856 
857 	buf = vp->vp_nvlist;
858 	buflen = sizeof (vp->vp_nvlist);
859 
860 	error = nvlist_pack(label, &buf, &buflen, NV_ENCODE_XDR, KM_SLEEP);
861 	if (error != 0) {
862 		nvlist_free(label);
863 		abd_free(vp_abd);
864 		/* EFAULT means nvlist_pack ran out of room */
865 		return (error == EFAULT ? ENAMETOOLONG : EINVAL);
866 	}
867 
868 	/*
869 	 * Initialize uberblock template.
870 	 */
871 	ub_abd = abd_alloc_linear(VDEV_UBERBLOCK_RING, B_TRUE);
872 	abd_zero(ub_abd, VDEV_UBERBLOCK_RING);
873 	abd_copy_from_buf(ub_abd, &spa->spa_uberblock, sizeof (uberblock_t));
874 	ub = abd_to_buf(ub_abd);
875 	ub->ub_txg = 0;
876 
877 	/* Initialize the 2nd padding area. */
878 	pad2 = abd_alloc_for_io(VDEV_PAD_SIZE, B_TRUE);
879 	abd_zero(pad2, VDEV_PAD_SIZE);
880 
881 	/*
882 	 * Write everything in parallel.
883 	 */
884 retry:
885 	zio = zio_root(spa, NULL, NULL, flags);
886 
887 	for (int l = 0; l < VDEV_LABELS; l++) {
888 
889 		vdev_label_write(zio, vd, l, vp_abd,
890 		    offsetof(vdev_label_t, vl_vdev_phys),
891 		    sizeof (vdev_phys_t), NULL, NULL, flags);
892 
893 		/*
894 		 * Skip the 1st padding area.
895 		 * Zero out the 2nd padding area where it might have
896 		 * left over data from previous filesystem format.
897 		 */
898 		vdev_label_write(zio, vd, l, pad2,
899 		    offsetof(vdev_label_t, vl_pad2),
900 		    VDEV_PAD_SIZE, NULL, NULL, flags);
901 
902 		vdev_label_write(zio, vd, l, ub_abd,
903 		    offsetof(vdev_label_t, vl_uberblock),
904 		    VDEV_UBERBLOCK_RING, NULL, NULL, flags);
905 	}
906 
907 	error = zio_wait(zio);
908 
909 	if (error != 0 && !(flags & ZIO_FLAG_TRYHARD)) {
910 		flags |= ZIO_FLAG_TRYHARD;
911 		goto retry;
912 	}
913 
914 	nvlist_free(label);
915 	abd_free(pad2);
916 	abd_free(ub_abd);
917 	abd_free(vp_abd);
918 
919 	/*
920 	 * If this vdev hasn't been previously identified as a spare, then we
921 	 * mark it as such only if a) we are labeling it as a spare, or b) it
922 	 * exists as a spare elsewhere in the system.  Do the same for
923 	 * level 2 ARC devices.
924 	 */
925 	if (error == 0 && !vd->vdev_isspare &&
926 	    (reason == VDEV_LABEL_SPARE ||
927 	    spa_spare_exists(vd->vdev_guid, NULL, NULL)))
928 		spa_spare_add(vd);
929 
930 	if (error == 0 && !vd->vdev_isl2cache &&
931 	    (reason == VDEV_LABEL_L2CACHE ||
932 	    spa_l2cache_exists(vd->vdev_guid, NULL)))
933 		spa_l2cache_add(vd);
934 
935 	return (error);
936 }
937 
938 /*
939  * ==========================================================================
940  * uberblock load/sync
941  * ==========================================================================
942  */
943 
944 /*
945  * Consider the following situation: txg is safely synced to disk.  We've
946  * written the first uberblock for txg + 1, and then we lose power.  When we
947  * come back up, we fail to see the uberblock for txg + 1 because, say,
948  * it was on a mirrored device and the replica to which we wrote txg + 1
949  * is now offline.  If we then make some changes and sync txg + 1, and then
950  * the missing replica comes back, then for a few seconds we'll have two
951  * conflicting uberblocks on disk with the same txg.  The solution is simple:
952  * among uberblocks with equal txg, choose the one with the latest timestamp.
953  */
954 static int
955 vdev_uberblock_compare(uberblock_t *ub1, uberblock_t *ub2)
956 {
957 	if (ub1->ub_txg < ub2->ub_txg)
958 		return (-1);
959 	if (ub1->ub_txg > ub2->ub_txg)
960 		return (1);
961 
962 	if (ub1->ub_timestamp < ub2->ub_timestamp)
963 		return (-1);
964 	if (ub1->ub_timestamp > ub2->ub_timestamp)
965 		return (1);
966 
967 	return (0);
968 }
969 
970 struct ubl_cbdata {
971 	uberblock_t	*ubl_ubbest;	/* Best uberblock */
972 	vdev_t		*ubl_vd;	/* vdev associated with the above */
973 };
974 
975 static void
976 vdev_uberblock_load_done(zio_t *zio)
977 {
978 	vdev_t *vd = zio->io_vd;
979 	spa_t *spa = zio->io_spa;
980 	zio_t *rio = zio->io_private;
981 	uberblock_t *ub = abd_to_buf(zio->io_abd);
982 	struct ubl_cbdata *cbp = rio->io_private;
983 
984 	ASSERT3U(zio->io_size, ==, VDEV_UBERBLOCK_SIZE(vd));
985 
986 	if (zio->io_error == 0 && uberblock_verify(ub) == 0) {
987 		mutex_enter(&rio->io_lock);
988 		if (ub->ub_txg <= spa->spa_load_max_txg &&
989 		    vdev_uberblock_compare(ub, cbp->ubl_ubbest) > 0) {
990 			/*
991 			 * Keep track of the vdev in which this uberblock
992 			 * was found. We will use this information later
993 			 * to obtain the config nvlist associated with
994 			 * this uberblock.
995 			 */
996 			*cbp->ubl_ubbest = *ub;
997 			cbp->ubl_vd = vd;
998 		}
999 		mutex_exit(&rio->io_lock);
1000 	}
1001 
1002 	abd_free(zio->io_abd);
1003 }
1004 
1005 static void
1006 vdev_uberblock_load_impl(zio_t *zio, vdev_t *vd, int flags,
1007     struct ubl_cbdata *cbp)
1008 {
1009 	for (int c = 0; c < vd->vdev_children; c++)
1010 		vdev_uberblock_load_impl(zio, vd->vdev_child[c], flags, cbp);
1011 
1012 	if (vd->vdev_ops->vdev_op_leaf && vdev_readable(vd)) {
1013 		for (int l = 0; l < VDEV_LABELS; l++) {
1014 			for (int n = 0; n < VDEV_UBERBLOCK_COUNT(vd); n++) {
1015 				vdev_label_read(zio, vd, l,
1016 				    abd_alloc_linear(VDEV_UBERBLOCK_SIZE(vd),
1017 				    B_TRUE), VDEV_UBERBLOCK_OFFSET(vd, n),
1018 				    VDEV_UBERBLOCK_SIZE(vd),
1019 				    vdev_uberblock_load_done, zio, flags);
1020 			}
1021 		}
1022 	}
1023 }
1024 
1025 /*
1026  * Reads the 'best' uberblock from disk along with its associated
1027  * configuration. First, we read the uberblock array of each label of each
1028  * vdev, keeping track of the uberblock with the highest txg in each array.
1029  * Then, we read the configuration from the same vdev as the best uberblock.
1030  */
1031 void
1032 vdev_uberblock_load(vdev_t *rvd, uberblock_t *ub, nvlist_t **config)
1033 {
1034 	zio_t *zio;
1035 	spa_t *spa = rvd->vdev_spa;
1036 	struct ubl_cbdata cb;
1037 	int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL |
1038 	    ZIO_FLAG_SPECULATIVE | ZIO_FLAG_TRYHARD;
1039 
1040 	ASSERT(ub);
1041 	ASSERT(config);
1042 
1043 	bzero(ub, sizeof (uberblock_t));
1044 	*config = NULL;
1045 
1046 	cb.ubl_ubbest = ub;
1047 	cb.ubl_vd = NULL;
1048 
1049 	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1050 	zio = zio_root(spa, NULL, &cb, flags);
1051 	vdev_uberblock_load_impl(zio, rvd, flags, &cb);
1052 	(void) zio_wait(zio);
1053 
1054 	/*
1055 	 * It's possible that the best uberblock was discovered on a label
1056 	 * that has a configuration which was written in a future txg.
1057 	 * Search all labels on this vdev to find the configuration that
1058 	 * matches the txg for our uberblock.
1059 	 */
1060 	if (cb.ubl_vd != NULL)
1061 		*config = vdev_label_read_config(cb.ubl_vd, ub->ub_txg);
1062 	spa_config_exit(spa, SCL_ALL, FTAG);
1063 }
1064 
1065 /*
1066  * On success, increment root zio's count of good writes.
1067  * We only get credit for writes to known-visible vdevs; see spa_vdev_add().
1068  */
1069 static void
1070 vdev_uberblock_sync_done(zio_t *zio)
1071 {
1072 	uint64_t *good_writes = zio->io_private;
1073 
1074 	if (zio->io_error == 0 && zio->io_vd->vdev_top->vdev_ms_array != 0)
1075 		atomic_inc_64(good_writes);
1076 }
1077 
1078 /*
1079  * Write the uberblock to all labels of all leaves of the specified vdev.
1080  */
1081 static void
1082 vdev_uberblock_sync(zio_t *zio, uberblock_t *ub, vdev_t *vd, int flags)
1083 {
1084 	for (int c = 0; c < vd->vdev_children; c++)
1085 		vdev_uberblock_sync(zio, ub, vd->vdev_child[c], flags);
1086 
1087 	if (!vd->vdev_ops->vdev_op_leaf)
1088 		return;
1089 
1090 	if (!vdev_writeable(vd))
1091 		return;
1092 
1093 	int n = ub->ub_txg & (VDEV_UBERBLOCK_COUNT(vd) - 1);
1094 
1095 	/* Copy the uberblock_t into the ABD */
1096 	abd_t *ub_abd = abd_alloc_for_io(VDEV_UBERBLOCK_SIZE(vd), B_TRUE);
1097 	abd_zero(ub_abd, VDEV_UBERBLOCK_SIZE(vd));
1098 	abd_copy_from_buf(ub_abd, ub, sizeof (uberblock_t));
1099 
1100 	for (int l = 0; l < VDEV_LABELS; l++)
1101 		vdev_label_write(zio, vd, l, ub_abd,
1102 		    VDEV_UBERBLOCK_OFFSET(vd, n), VDEV_UBERBLOCK_SIZE(vd),
1103 		    vdev_uberblock_sync_done, zio->io_private,
1104 		    flags | ZIO_FLAG_DONT_PROPAGATE);
1105 
1106 	abd_free(ub_abd);
1107 }
1108 
1109 /* Sync the uberblocks to all vdevs in svd[] */
1110 int
1111 vdev_uberblock_sync_list(vdev_t **svd, int svdcount, uberblock_t *ub, int flags)
1112 {
1113 	spa_t *spa = svd[0]->vdev_spa;
1114 	zio_t *zio;
1115 	uint64_t good_writes = 0;
1116 
1117 	zio = zio_root(spa, NULL, &good_writes, flags);
1118 
1119 	for (int v = 0; v < svdcount; v++)
1120 		vdev_uberblock_sync(zio, ub, svd[v], flags);
1121 
1122 	(void) zio_wait(zio);
1123 
1124 	/*
1125 	 * Flush the uberblocks to disk.  This ensures that the odd labels
1126 	 * are no longer needed (because the new uberblocks and the even
1127 	 * labels are safely on disk), so it is safe to overwrite them.
1128 	 */
1129 	zio = zio_root(spa, NULL, NULL, flags);
1130 
1131 	for (int v = 0; v < svdcount; v++) {
1132 		if (vdev_writeable(svd[v])) {
1133 			zio_flush(zio, svd[v]);
1134 		}
1135 	}
1136 
1137 	(void) zio_wait(zio);
1138 
1139 	return (good_writes >= 1 ? 0 : EIO);
1140 }
1141 
1142 /*
1143  * On success, increment the count of good writes for our top-level vdev.
1144  */
1145 static void
1146 vdev_label_sync_done(zio_t *zio)
1147 {
1148 	uint64_t *good_writes = zio->io_private;
1149 
1150 	if (zio->io_error == 0)
1151 		atomic_inc_64(good_writes);
1152 }
1153 
1154 /*
1155  * If there weren't enough good writes, indicate failure to the parent.
1156  */
1157 static void
1158 vdev_label_sync_top_done(zio_t *zio)
1159 {
1160 	uint64_t *good_writes = zio->io_private;
1161 
1162 	if (*good_writes == 0)
1163 		zio->io_error = SET_ERROR(EIO);
1164 
1165 	kmem_free(good_writes, sizeof (uint64_t));
1166 }
1167 
1168 /*
1169  * We ignore errors for log and cache devices, simply free the private data.
1170  */
1171 static void
1172 vdev_label_sync_ignore_done(zio_t *zio)
1173 {
1174 	kmem_free(zio->io_private, sizeof (uint64_t));
1175 }
1176 
1177 /*
1178  * Write all even or odd labels to all leaves of the specified vdev.
1179  */
1180 static void
1181 vdev_label_sync(zio_t *zio, vdev_t *vd, int l, uint64_t txg, int flags)
1182 {
1183 	nvlist_t *label;
1184 	vdev_phys_t *vp;
1185 	abd_t *vp_abd;
1186 	char *buf;
1187 	size_t buflen;
1188 
1189 	for (int c = 0; c < vd->vdev_children; c++)
1190 		vdev_label_sync(zio, vd->vdev_child[c], l, txg, flags);
1191 
1192 	if (!vd->vdev_ops->vdev_op_leaf)
1193 		return;
1194 
1195 	if (!vdev_writeable(vd))
1196 		return;
1197 
1198 	/*
1199 	 * Generate a label describing the top-level config to which we belong.
1200 	 */
1201 	label = spa_config_generate(vd->vdev_spa, vd, txg, B_FALSE);
1202 
1203 	vp_abd = abd_alloc_linear(sizeof (vdev_phys_t), B_TRUE);
1204 	abd_zero(vp_abd, sizeof (vdev_phys_t));
1205 	vp = abd_to_buf(vp_abd);
1206 
1207 	buf = vp->vp_nvlist;
1208 	buflen = sizeof (vp->vp_nvlist);
1209 
1210 	if (nvlist_pack(label, &buf, &buflen, NV_ENCODE_XDR, KM_SLEEP) == 0) {
1211 		for (; l < VDEV_LABELS; l += 2) {
1212 			vdev_label_write(zio, vd, l, vp_abd,
1213 			    offsetof(vdev_label_t, vl_vdev_phys),
1214 			    sizeof (vdev_phys_t),
1215 			    vdev_label_sync_done, zio->io_private,
1216 			    flags | ZIO_FLAG_DONT_PROPAGATE);
1217 		}
1218 	}
1219 
1220 	abd_free(vp_abd);
1221 	nvlist_free(label);
1222 }
1223 
1224 int
1225 vdev_label_sync_list(spa_t *spa, int l, uint64_t txg, int flags)
1226 {
1227 	list_t *dl = &spa->spa_config_dirty_list;
1228 	vdev_t *vd;
1229 	zio_t *zio;
1230 	int error;
1231 
1232 	/*
1233 	 * Write the new labels to disk.
1234 	 */
1235 	zio = zio_root(spa, NULL, NULL, flags);
1236 
1237 	for (vd = list_head(dl); vd != NULL; vd = list_next(dl, vd)) {
1238 		uint64_t *good_writes = kmem_zalloc(sizeof (uint64_t),
1239 		    KM_SLEEP);
1240 
1241 		ASSERT(!vd->vdev_ishole);
1242 
1243 		zio_t *vio = zio_null(zio, spa, NULL,
1244 		    (vd->vdev_islog || vd->vdev_aux != NULL) ?
1245 		    vdev_label_sync_ignore_done : vdev_label_sync_top_done,
1246 		    good_writes, flags);
1247 		vdev_label_sync(vio, vd, l, txg, flags);
1248 		zio_nowait(vio);
1249 	}
1250 
1251 	error = zio_wait(zio);
1252 
1253 	/*
1254 	 * Flush the new labels to disk.
1255 	 */
1256 	zio = zio_root(spa, NULL, NULL, flags);
1257 
1258 	for (vd = list_head(dl); vd != NULL; vd = list_next(dl, vd))
1259 		zio_flush(zio, vd);
1260 
1261 	(void) zio_wait(zio);
1262 
1263 	return (error);
1264 }
1265 
1266 /*
1267  * Sync the uberblock and any changes to the vdev configuration.
1268  *
1269  * The order of operations is carefully crafted to ensure that
1270  * if the system panics or loses power at any time, the state on disk
1271  * is still transactionally consistent.  The in-line comments below
1272  * describe the failure semantics at each stage.
1273  *
1274  * Moreover, vdev_config_sync() is designed to be idempotent: if it fails
1275  * at any time, you can just call it again, and it will resume its work.
1276  */
1277 int
1278 vdev_config_sync(vdev_t **svd, int svdcount, uint64_t txg)
1279 {
1280 	spa_t *spa = svd[0]->vdev_spa;
1281 	uberblock_t *ub = &spa->spa_uberblock;
1282 	vdev_t *vd;
1283 	zio_t *zio;
1284 	int error = 0;
1285 	int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL;
1286 
1287 retry:
1288 	/*
1289 	 * Normally, we don't want to try too hard to write every label and
1290 	 * uberblock.  If there is a flaky disk, we don't want the rest of the
1291 	 * sync process to block while we retry.  But if we can't write a
1292 	 * single label out, we should retry with ZIO_FLAG_TRYHARD before
1293 	 * bailing out and declaring the pool faulted.
1294 	 */
1295 	if (error != 0) {
1296 		if ((flags & ZIO_FLAG_TRYHARD) != 0)
1297 			return (error);
1298 		flags |= ZIO_FLAG_TRYHARD;
1299 	}
1300 
1301 	ASSERT(ub->ub_txg <= txg);
1302 
1303 	/*
1304 	 * If this isn't a resync due to I/O errors,
1305 	 * and nothing changed in this transaction group,
1306 	 * and the vdev configuration hasn't changed,
1307 	 * then there's nothing to do.
1308 	 */
1309 	if (ub->ub_txg < txg &&
1310 	    uberblock_update(ub, spa->spa_root_vdev, txg) == B_FALSE &&
1311 	    list_is_empty(&spa->spa_config_dirty_list))
1312 		return (0);
1313 
1314 	if (txg > spa_freeze_txg(spa))
1315 		return (0);
1316 
1317 	ASSERT(txg <= spa->spa_final_txg);
1318 
1319 	/*
1320 	 * Flush the write cache of every disk that's been written to
1321 	 * in this transaction group.  This ensures that all blocks
1322 	 * written in this txg will be committed to stable storage
1323 	 * before any uberblock that references them.
1324 	 */
1325 	zio = zio_root(spa, NULL, NULL, flags);
1326 
1327 	for (vd = txg_list_head(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)); vd;
1328 	    vd = txg_list_next(&spa->spa_vdev_txg_list, vd, TXG_CLEAN(txg)))
1329 		zio_flush(zio, vd);
1330 
1331 	(void) zio_wait(zio);
1332 
1333 	/*
1334 	 * Sync out the even labels (L0, L2) for every dirty vdev.  If the
1335 	 * system dies in the middle of this process, that's OK: all of the
1336 	 * even labels that made it to disk will be newer than any uberblock,
1337 	 * and will therefore be considered invalid.  The odd labels (L1, L3),
1338 	 * which have not yet been touched, will still be valid.  We flush
1339 	 * the new labels to disk to ensure that all even-label updates
1340 	 * are committed to stable storage before the uberblock update.
1341 	 */
1342 	if ((error = vdev_label_sync_list(spa, 0, txg, flags)) != 0)
1343 		goto retry;
1344 
1345 	/*
1346 	 * Sync the uberblocks to all vdevs in svd[].
1347 	 * If the system dies in the middle of this step, there are two cases
1348 	 * to consider, and the on-disk state is consistent either way:
1349 	 *
1350 	 * (1)	If none of the new uberblocks made it to disk, then the
1351 	 *	previous uberblock will be the newest, and the odd labels
1352 	 *	(which had not yet been touched) will be valid with respect
1353 	 *	to that uberblock.
1354 	 *
1355 	 * (2)	If one or more new uberblocks made it to disk, then they
1356 	 *	will be the newest, and the even labels (which had all
1357 	 *	been successfully committed) will be valid with respect
1358 	 *	to the new uberblocks.
1359 	 */
1360 	if ((error = vdev_uberblock_sync_list(svd, svdcount, ub, flags)) != 0)
1361 		goto retry;
1362 
1363 	/*
1364 	 * Sync out odd labels for every dirty vdev.  If the system dies
1365 	 * in the middle of this process, the even labels and the new
1366 	 * uberblocks will suffice to open the pool.  The next time
1367 	 * the pool is opened, the first thing we'll do -- before any
1368 	 * user data is modified -- is mark every vdev dirty so that
1369 	 * all labels will be brought up to date.  We flush the new labels
1370 	 * to disk to ensure that all odd-label updates are committed to
1371 	 * stable storage before the next transaction group begins.
1372 	 */
1373 	if ((error = vdev_label_sync_list(spa, 1, txg, flags)) != 0)
1374 		goto retry;
1375 
1376 	return (0);
1377 }
1378