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 https://opensource.org/licenses/CDDL-1.0.
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, 2020 by Delphix. All rights reserved.
25 * Copyright (c) 2017, Intel Corporation.
26 */
27
28 /*
29 * Virtual Device Labels
30 * ---------------------
31 *
32 * The vdev label serves several distinct purposes:
33 *
34 * 1. Uniquely identify this device as part of a ZFS pool and confirm its
35 * identity within the pool.
36 *
37 * 2. Verify that all the devices given in a configuration are present
38 * within the pool.
39 *
40 * 3. Determine the uberblock for the pool.
41 *
42 * 4. In case of an import operation, determine the configuration of the
43 * toplevel vdev of which it is a part.
44 *
45 * 5. If an import operation cannot find all the devices in the pool,
46 * provide enough information to the administrator to determine which
47 * devices are missing.
48 *
49 * It is important to note that while the kernel is responsible for writing the
50 * label, it only consumes the information in the first three cases. The
51 * latter information is only consumed in userland when determining the
52 * configuration to import a pool.
53 *
54 *
55 * Label Organization
56 * ------------------
57 *
58 * Before describing the contents of the label, it's important to understand how
59 * the labels are written and updated with respect to the uberblock.
60 *
61 * When the pool configuration is altered, either because it was newly created
62 * or a device was added, we want to update all the labels such that we can deal
63 * with fatal failure at any point. To this end, each disk has two labels which
64 * are updated before and after the uberblock is synced. Assuming we have
65 * labels and an uberblock with the following transaction groups:
66 *
67 * L1 UB L2
68 * +------+ +------+ +------+
69 * | | | | | |
70 * | t10 | | t10 | | t10 |
71 * | | | | | |
72 * +------+ +------+ +------+
73 *
74 * In this stable state, the labels and the uberblock were all updated within
75 * the same transaction group (10). Each label is mirrored and checksummed, so
76 * that we can detect when we fail partway through writing the label.
77 *
78 * In order to identify which labels are valid, the labels are written in the
79 * following manner:
80 *
81 * 1. For each vdev, update 'L1' to the new label
82 * 2. Update the uberblock
83 * 3. For each vdev, update 'L2' to the new label
84 *
85 * Given arbitrary failure, we can determine the correct label to use based on
86 * the transaction group. If we fail after updating L1 but before updating the
87 * UB, we will notice that L1's transaction group is greater than the uberblock,
88 * so L2 must be valid. If we fail after writing the uberblock but before
89 * writing L2, we will notice that L2's transaction group is less than L1, and
90 * therefore L1 is valid.
91 *
92 * Another added complexity is that not every label is updated when the config
93 * is synced. If we add a single device, we do not want to have to re-write
94 * every label for every device in the pool. This means that both L1 and L2 may
95 * be older than the pool uberblock, because the necessary information is stored
96 * on another vdev.
97 *
98 *
99 * On-disk Format
100 * --------------
101 *
102 * The vdev label consists of two distinct parts, and is wrapped within the
103 * vdev_label_t structure. The label includes 8k of padding to permit legacy
104 * VTOC disk labels, but is otherwise ignored.
105 *
106 * The first half of the label is a packed nvlist which contains pool wide
107 * properties, per-vdev properties, and configuration information. It is
108 * described in more detail below.
109 *
110 * The latter half of the label consists of a redundant array of uberblocks.
111 * These uberblocks are updated whenever a transaction group is committed,
112 * or when the configuration is updated. When a pool is loaded, we scan each
113 * vdev for the 'best' uberblock.
114 *
115 *
116 * Configuration Information
117 * -------------------------
118 *
119 * The nvlist describing the pool and vdev contains the following elements:
120 *
121 * version ZFS on-disk version
122 * name Pool name
123 * state Pool state
124 * txg Transaction group in which this label was written
125 * pool_guid Unique identifier for this pool
126 * vdev_tree An nvlist describing vdev tree.
127 * features_for_read
128 * An nvlist of the features necessary for reading the MOS.
129 *
130 * Each leaf device label also contains the following:
131 *
132 * top_guid Unique ID for top-level vdev in which this is contained
133 * guid Unique ID for the leaf vdev
134 *
135 * The 'vs' configuration follows the format described in 'spa_config.c'.
136 */
137
138 #include <sys/zfs_context.h>
139 #include <sys/spa.h>
140 #include <sys/spa_impl.h>
141 #include <sys/dmu.h>
142 #include <sys/zap.h>
143 #include <sys/vdev.h>
144 #include <sys/vdev_impl.h>
145 #include <sys/vdev_raidz.h>
146 #include <sys/vdev_draid.h>
147 #include <sys/uberblock_impl.h>
148 #include <sys/metaslab.h>
149 #include <sys/metaslab_impl.h>
150 #include <sys/zio.h>
151 #include <sys/dsl_scan.h>
152 #include <sys/abd.h>
153 #include <sys/fs/zfs.h>
154 #include <sys/byteorder.h>
155 #include <sys/zfs_bootenv.h>
156
157 /*
158 * Basic routines to read and write from a vdev label.
159 * Used throughout the rest of this file.
160 */
161 uint64_t
vdev_label_offset(uint64_t psize,int l,uint64_t offset)162 vdev_label_offset(uint64_t psize, int l, uint64_t offset)
163 {
164 ASSERT(offset < sizeof (vdev_label_t));
165 ASSERT(P2PHASE_TYPED(psize, sizeof (vdev_label_t), uint64_t) == 0);
166
167 return (offset + l * sizeof (vdev_label_t) + (l < VDEV_LABELS / 2 ?
168 0 : psize - VDEV_LABELS * sizeof (vdev_label_t)));
169 }
170
171 /*
172 * Returns back the vdev label associated with the passed in offset.
173 */
174 int
vdev_label_number(uint64_t psize,uint64_t offset)175 vdev_label_number(uint64_t psize, uint64_t offset)
176 {
177 int l;
178
179 if (offset >= psize - VDEV_LABEL_END_SIZE) {
180 offset -= psize - VDEV_LABEL_END_SIZE;
181 offset += (VDEV_LABELS / 2) * sizeof (vdev_label_t);
182 }
183 l = offset / sizeof (vdev_label_t);
184 return (l < VDEV_LABELS ? l : -1);
185 }
186
187 static void
vdev_label_read(zio_t * zio,vdev_t * vd,int l,abd_t * buf,uint64_t offset,uint64_t size,zio_done_func_t * done,void * private,int flags)188 vdev_label_read(zio_t *zio, vdev_t *vd, int l, abd_t *buf, uint64_t offset,
189 uint64_t size, zio_done_func_t *done, void *private, int flags)
190 {
191 ASSERT(
192 spa_config_held(zio->io_spa, SCL_STATE, RW_READER) == SCL_STATE ||
193 spa_config_held(zio->io_spa, SCL_STATE, RW_WRITER) == SCL_STATE);
194 ASSERT(flags & ZIO_FLAG_CONFIG_WRITER);
195
196 zio_nowait(zio_read_phys(zio, vd,
197 vdev_label_offset(vd->vdev_psize, l, offset),
198 size, buf, ZIO_CHECKSUM_LABEL, done, private,
199 ZIO_PRIORITY_SYNC_READ, flags, B_TRUE));
200 }
201
202 void
vdev_label_write(zio_t * zio,vdev_t * vd,int l,abd_t * buf,uint64_t offset,uint64_t size,zio_done_func_t * done,void * private,int flags)203 vdev_label_write(zio_t *zio, vdev_t *vd, int l, abd_t *buf, uint64_t offset,
204 uint64_t size, zio_done_func_t *done, void *private, int flags)
205 {
206 ASSERT(
207 spa_config_held(zio->io_spa, SCL_STATE, RW_READER) == SCL_STATE ||
208 spa_config_held(zio->io_spa, SCL_STATE, RW_WRITER) == SCL_STATE);
209 ASSERT(flags & ZIO_FLAG_CONFIG_WRITER);
210
211 zio_nowait(zio_write_phys(zio, vd,
212 vdev_label_offset(vd->vdev_psize, l, offset),
213 size, buf, ZIO_CHECKSUM_LABEL, done, private,
214 ZIO_PRIORITY_SYNC_WRITE, flags, B_TRUE));
215 }
216
217 /*
218 * Generate the nvlist representing this vdev's stats
219 */
220 void
vdev_config_generate_stats(vdev_t * vd,nvlist_t * nv)221 vdev_config_generate_stats(vdev_t *vd, nvlist_t *nv)
222 {
223 nvlist_t *nvx;
224 vdev_stat_t *vs;
225 vdev_stat_ex_t *vsx;
226
227 vs = kmem_alloc(sizeof (*vs), KM_SLEEP);
228 vsx = kmem_alloc(sizeof (*vsx), KM_SLEEP);
229
230 vdev_get_stats_ex(vd, vs, vsx);
231 fnvlist_add_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
232 (uint64_t *)vs, sizeof (*vs) / sizeof (uint64_t));
233
234 /*
235 * Add extended stats into a special extended stats nvlist. This keeps
236 * all the extended stats nicely grouped together. The extended stats
237 * nvlist is then added to the main nvlist.
238 */
239 nvx = fnvlist_alloc();
240
241 /* ZIOs in flight to disk */
242 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE,
243 vsx->vsx_active_queue[ZIO_PRIORITY_SYNC_READ]);
244
245 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE,
246 vsx->vsx_active_queue[ZIO_PRIORITY_SYNC_WRITE]);
247
248 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE,
249 vsx->vsx_active_queue[ZIO_PRIORITY_ASYNC_READ]);
250
251 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE,
252 vsx->vsx_active_queue[ZIO_PRIORITY_ASYNC_WRITE]);
253
254 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE,
255 vsx->vsx_active_queue[ZIO_PRIORITY_SCRUB]);
256
257 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_TRIM_ACTIVE_QUEUE,
258 vsx->vsx_active_queue[ZIO_PRIORITY_TRIM]);
259
260 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_REBUILD_ACTIVE_QUEUE,
261 vsx->vsx_active_queue[ZIO_PRIORITY_REBUILD]);
262
263 /* ZIOs pending */
264 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SYNC_R_PEND_QUEUE,
265 vsx->vsx_pend_queue[ZIO_PRIORITY_SYNC_READ]);
266
267 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SYNC_W_PEND_QUEUE,
268 vsx->vsx_pend_queue[ZIO_PRIORITY_SYNC_WRITE]);
269
270 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_ASYNC_R_PEND_QUEUE,
271 vsx->vsx_pend_queue[ZIO_PRIORITY_ASYNC_READ]);
272
273 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_ASYNC_W_PEND_QUEUE,
274 vsx->vsx_pend_queue[ZIO_PRIORITY_ASYNC_WRITE]);
275
276 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SCRUB_PEND_QUEUE,
277 vsx->vsx_pend_queue[ZIO_PRIORITY_SCRUB]);
278
279 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_TRIM_PEND_QUEUE,
280 vsx->vsx_pend_queue[ZIO_PRIORITY_TRIM]);
281
282 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_REBUILD_PEND_QUEUE,
283 vsx->vsx_pend_queue[ZIO_PRIORITY_REBUILD]);
284
285 /* Histograms */
286 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
287 vsx->vsx_total_histo[ZIO_TYPE_READ],
288 ARRAY_SIZE(vsx->vsx_total_histo[ZIO_TYPE_READ]));
289
290 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
291 vsx->vsx_total_histo[ZIO_TYPE_WRITE],
292 ARRAY_SIZE(vsx->vsx_total_histo[ZIO_TYPE_WRITE]));
293
294 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
295 vsx->vsx_disk_histo[ZIO_TYPE_READ],
296 ARRAY_SIZE(vsx->vsx_disk_histo[ZIO_TYPE_READ]));
297
298 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
299 vsx->vsx_disk_histo[ZIO_TYPE_WRITE],
300 ARRAY_SIZE(vsx->vsx_disk_histo[ZIO_TYPE_WRITE]));
301
302 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO,
303 vsx->vsx_queue_histo[ZIO_PRIORITY_SYNC_READ],
304 ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_SYNC_READ]));
305
306 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO,
307 vsx->vsx_queue_histo[ZIO_PRIORITY_SYNC_WRITE],
308 ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_SYNC_WRITE]));
309
310 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO,
311 vsx->vsx_queue_histo[ZIO_PRIORITY_ASYNC_READ],
312 ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_ASYNC_READ]));
313
314 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO,
315 vsx->vsx_queue_histo[ZIO_PRIORITY_ASYNC_WRITE],
316 ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_ASYNC_WRITE]));
317
318 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO,
319 vsx->vsx_queue_histo[ZIO_PRIORITY_SCRUB],
320 ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_SCRUB]));
321
322 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_TRIM_LAT_HISTO,
323 vsx->vsx_queue_histo[ZIO_PRIORITY_TRIM],
324 ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_TRIM]));
325
326 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_REBUILD_LAT_HISTO,
327 vsx->vsx_queue_histo[ZIO_PRIORITY_REBUILD],
328 ARRAY_SIZE(vsx->vsx_queue_histo[ZIO_PRIORITY_REBUILD]));
329
330 /* Request sizes */
331 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SYNC_IND_R_HISTO,
332 vsx->vsx_ind_histo[ZIO_PRIORITY_SYNC_READ],
333 ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_SYNC_READ]));
334
335 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SYNC_IND_W_HISTO,
336 vsx->vsx_ind_histo[ZIO_PRIORITY_SYNC_WRITE],
337 ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_SYNC_WRITE]));
338
339 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_ASYNC_IND_R_HISTO,
340 vsx->vsx_ind_histo[ZIO_PRIORITY_ASYNC_READ],
341 ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_ASYNC_READ]));
342
343 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_ASYNC_IND_W_HISTO,
344 vsx->vsx_ind_histo[ZIO_PRIORITY_ASYNC_WRITE],
345 ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_ASYNC_WRITE]));
346
347 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_IND_SCRUB_HISTO,
348 vsx->vsx_ind_histo[ZIO_PRIORITY_SCRUB],
349 ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_SCRUB]));
350
351 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_IND_TRIM_HISTO,
352 vsx->vsx_ind_histo[ZIO_PRIORITY_TRIM],
353 ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_TRIM]));
354
355 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_IND_REBUILD_HISTO,
356 vsx->vsx_ind_histo[ZIO_PRIORITY_REBUILD],
357 ARRAY_SIZE(vsx->vsx_ind_histo[ZIO_PRIORITY_REBUILD]));
358
359 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SYNC_AGG_R_HISTO,
360 vsx->vsx_agg_histo[ZIO_PRIORITY_SYNC_READ],
361 ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_SYNC_READ]));
362
363 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_SYNC_AGG_W_HISTO,
364 vsx->vsx_agg_histo[ZIO_PRIORITY_SYNC_WRITE],
365 ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_SYNC_WRITE]));
366
367 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_ASYNC_AGG_R_HISTO,
368 vsx->vsx_agg_histo[ZIO_PRIORITY_ASYNC_READ],
369 ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_ASYNC_READ]));
370
371 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_ASYNC_AGG_W_HISTO,
372 vsx->vsx_agg_histo[ZIO_PRIORITY_ASYNC_WRITE],
373 ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_ASYNC_WRITE]));
374
375 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_AGG_SCRUB_HISTO,
376 vsx->vsx_agg_histo[ZIO_PRIORITY_SCRUB],
377 ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_SCRUB]));
378
379 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_AGG_TRIM_HISTO,
380 vsx->vsx_agg_histo[ZIO_PRIORITY_TRIM],
381 ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_TRIM]));
382
383 fnvlist_add_uint64_array(nvx, ZPOOL_CONFIG_VDEV_AGG_REBUILD_HISTO,
384 vsx->vsx_agg_histo[ZIO_PRIORITY_REBUILD],
385 ARRAY_SIZE(vsx->vsx_agg_histo[ZIO_PRIORITY_REBUILD]));
386
387 /* IO delays */
388 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_SLOW_IOS, vs->vs_slow_ios);
389
390 /* Direct I/O write verify errors */
391 fnvlist_add_uint64(nvx, ZPOOL_CONFIG_VDEV_DIO_VERIFY_ERRORS,
392 vs->vs_dio_verify_errors);
393
394 /* Add extended stats nvlist to main nvlist */
395 fnvlist_add_nvlist(nv, ZPOOL_CONFIG_VDEV_STATS_EX, nvx);
396
397 fnvlist_free(nvx);
398 kmem_free(vs, sizeof (*vs));
399 kmem_free(vsx, sizeof (*vsx));
400 }
401
402 static void
root_vdev_actions_getprogress(vdev_t * vd,nvlist_t * nvl)403 root_vdev_actions_getprogress(vdev_t *vd, nvlist_t *nvl)
404 {
405 spa_t *spa = vd->vdev_spa;
406
407 if (vd != spa->spa_root_vdev)
408 return;
409
410 /* provide either current or previous scan information */
411 pool_scan_stat_t ps;
412 if (spa_scan_get_stats(spa, &ps) == 0) {
413 fnvlist_add_uint64_array(nvl,
414 ZPOOL_CONFIG_SCAN_STATS, (uint64_t *)&ps,
415 sizeof (pool_scan_stat_t) / sizeof (uint64_t));
416 }
417
418 pool_removal_stat_t prs;
419 if (spa_removal_get_stats(spa, &prs) == 0) {
420 fnvlist_add_uint64_array(nvl,
421 ZPOOL_CONFIG_REMOVAL_STATS, (uint64_t *)&prs,
422 sizeof (prs) / sizeof (uint64_t));
423 }
424
425 pool_checkpoint_stat_t pcs;
426 if (spa_checkpoint_get_stats(spa, &pcs) == 0) {
427 fnvlist_add_uint64_array(nvl,
428 ZPOOL_CONFIG_CHECKPOINT_STATS, (uint64_t *)&pcs,
429 sizeof (pcs) / sizeof (uint64_t));
430 }
431
432 pool_raidz_expand_stat_t pres;
433 if (spa_raidz_expand_get_stats(spa, &pres) == 0) {
434 fnvlist_add_uint64_array(nvl,
435 ZPOOL_CONFIG_RAIDZ_EXPAND_STATS, (uint64_t *)&pres,
436 sizeof (pres) / sizeof (uint64_t));
437 }
438 }
439
440 static void
top_vdev_actions_getprogress(vdev_t * vd,nvlist_t * nvl)441 top_vdev_actions_getprogress(vdev_t *vd, nvlist_t *nvl)
442 {
443 if (vd == vd->vdev_top) {
444 vdev_rebuild_stat_t vrs;
445 if (vdev_rebuild_get_stats(vd, &vrs) == 0) {
446 fnvlist_add_uint64_array(nvl,
447 ZPOOL_CONFIG_REBUILD_STATS, (uint64_t *)&vrs,
448 sizeof (vrs) / sizeof (uint64_t));
449 }
450 }
451 }
452
453 /*
454 * Generate the nvlist representing this vdev's config.
455 */
456 nvlist_t *
vdev_config_generate(spa_t * spa,vdev_t * vd,boolean_t getstats,vdev_config_flag_t flags)457 vdev_config_generate(spa_t *spa, vdev_t *vd, boolean_t getstats,
458 vdev_config_flag_t flags)
459 {
460 nvlist_t *nv = NULL;
461 vdev_indirect_config_t *vic = &vd->vdev_indirect_config;
462
463 nv = fnvlist_alloc();
464
465 fnvlist_add_string(nv, ZPOOL_CONFIG_TYPE, vd->vdev_ops->vdev_op_type);
466 if (!(flags & (VDEV_CONFIG_SPARE | VDEV_CONFIG_L2CACHE)))
467 fnvlist_add_uint64(nv, ZPOOL_CONFIG_ID, vd->vdev_id);
468 fnvlist_add_uint64(nv, ZPOOL_CONFIG_GUID, vd->vdev_guid);
469
470 if (vd->vdev_path != NULL)
471 fnvlist_add_string(nv, ZPOOL_CONFIG_PATH, vd->vdev_path);
472
473 if (vd->vdev_devid != NULL)
474 fnvlist_add_string(nv, ZPOOL_CONFIG_DEVID, vd->vdev_devid);
475
476 if (vd->vdev_physpath != NULL)
477 fnvlist_add_string(nv, ZPOOL_CONFIG_PHYS_PATH,
478 vd->vdev_physpath);
479
480 if (vd->vdev_enc_sysfs_path != NULL)
481 fnvlist_add_string(nv, ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH,
482 vd->vdev_enc_sysfs_path);
483
484 if (vd->vdev_fru != NULL)
485 fnvlist_add_string(nv, ZPOOL_CONFIG_FRU, vd->vdev_fru);
486
487 if (vd->vdev_ops->vdev_op_config_generate != NULL)
488 vd->vdev_ops->vdev_op_config_generate(vd, nv);
489
490 if (vd->vdev_wholedisk != -1ULL) {
491 fnvlist_add_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
492 vd->vdev_wholedisk);
493 }
494
495 if (vd->vdev_not_present && !(flags & VDEV_CONFIG_MISSING))
496 fnvlist_add_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, 1);
497
498 if (vd->vdev_isspare)
499 fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_SPARE, 1);
500
501 if (flags & VDEV_CONFIG_L2CACHE)
502 fnvlist_add_uint64(nv, ZPOOL_CONFIG_ASHIFT, vd->vdev_ashift);
503
504 if (!(flags & (VDEV_CONFIG_SPARE | VDEV_CONFIG_L2CACHE)) &&
505 vd == vd->vdev_top) {
506 fnvlist_add_uint64(nv, ZPOOL_CONFIG_METASLAB_ARRAY,
507 vd->vdev_ms_array);
508 fnvlist_add_uint64(nv, ZPOOL_CONFIG_METASLAB_SHIFT,
509 vd->vdev_ms_shift);
510 fnvlist_add_uint64(nv, ZPOOL_CONFIG_ASHIFT, vd->vdev_ashift);
511 fnvlist_add_uint64(nv, ZPOOL_CONFIG_ASIZE,
512 vd->vdev_asize);
513 fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_LOG, vd->vdev_islog);
514 if (vd->vdev_noalloc) {
515 fnvlist_add_uint64(nv, ZPOOL_CONFIG_NONALLOCATING,
516 vd->vdev_noalloc);
517 }
518
519 /*
520 * Slog devices are removed synchronously so don't
521 * persist the vdev_removing flag to the label.
522 */
523 if (vd->vdev_removing && !vd->vdev_islog) {
524 fnvlist_add_uint64(nv, ZPOOL_CONFIG_REMOVING,
525 vd->vdev_removing);
526 }
527
528 /* zpool command expects alloc class data */
529 if (getstats && vd->vdev_alloc_bias != VDEV_BIAS_NONE) {
530 const char *bias = NULL;
531
532 switch (vd->vdev_alloc_bias) {
533 case VDEV_BIAS_LOG:
534 bias = VDEV_ALLOC_BIAS_LOG;
535 break;
536 case VDEV_BIAS_SPECIAL:
537 bias = VDEV_ALLOC_BIAS_SPECIAL;
538 break;
539 case VDEV_BIAS_DEDUP:
540 bias = VDEV_ALLOC_BIAS_DEDUP;
541 break;
542 default:
543 ASSERT3U(vd->vdev_alloc_bias, ==,
544 VDEV_BIAS_NONE);
545 }
546 fnvlist_add_string(nv, ZPOOL_CONFIG_ALLOCATION_BIAS,
547 bias);
548 }
549 }
550
551 if (vd->vdev_dtl_sm != NULL) {
552 fnvlist_add_uint64(nv, ZPOOL_CONFIG_DTL,
553 space_map_object(vd->vdev_dtl_sm));
554 }
555
556 if (vic->vic_mapping_object != 0) {
557 fnvlist_add_uint64(nv, ZPOOL_CONFIG_INDIRECT_OBJECT,
558 vic->vic_mapping_object);
559 }
560
561 if (vic->vic_births_object != 0) {
562 fnvlist_add_uint64(nv, ZPOOL_CONFIG_INDIRECT_BIRTHS,
563 vic->vic_births_object);
564 }
565
566 if (vic->vic_prev_indirect_vdev != UINT64_MAX) {
567 fnvlist_add_uint64(nv, ZPOOL_CONFIG_PREV_INDIRECT_VDEV,
568 vic->vic_prev_indirect_vdev);
569 }
570
571 if (vd->vdev_crtxg)
572 fnvlist_add_uint64(nv, ZPOOL_CONFIG_CREATE_TXG, vd->vdev_crtxg);
573
574 if (vd->vdev_expansion_time)
575 fnvlist_add_uint64(nv, ZPOOL_CONFIG_EXPANSION_TIME,
576 vd->vdev_expansion_time);
577
578 if (flags & VDEV_CONFIG_MOS) {
579 if (vd->vdev_leaf_zap != 0) {
580 ASSERT(vd->vdev_ops->vdev_op_leaf);
581 fnvlist_add_uint64(nv, ZPOOL_CONFIG_VDEV_LEAF_ZAP,
582 vd->vdev_leaf_zap);
583 }
584
585 if (vd->vdev_top_zap != 0) {
586 ASSERT(vd == vd->vdev_top);
587 fnvlist_add_uint64(nv, ZPOOL_CONFIG_VDEV_TOP_ZAP,
588 vd->vdev_top_zap);
589 }
590
591 if (vd->vdev_ops == &vdev_root_ops && vd->vdev_root_zap != 0 &&
592 spa_feature_is_active(vd->vdev_spa, SPA_FEATURE_AVZ_V2)) {
593 fnvlist_add_uint64(nv, ZPOOL_CONFIG_VDEV_ROOT_ZAP,
594 vd->vdev_root_zap);
595 }
596
597 if (vd->vdev_resilver_deferred) {
598 ASSERT(vd->vdev_ops->vdev_op_leaf);
599 ASSERT(spa->spa_resilver_deferred);
600 fnvlist_add_boolean(nv, ZPOOL_CONFIG_RESILVER_DEFER);
601 }
602 }
603
604 if (getstats) {
605 vdev_config_generate_stats(vd, nv);
606
607 root_vdev_actions_getprogress(vd, nv);
608 top_vdev_actions_getprogress(vd, nv);
609
610 /*
611 * Note: this can be called from open context
612 * (spa_get_stats()), so we need the rwlock to prevent
613 * the mapping from being changed by condensing.
614 */
615 rw_enter(&vd->vdev_indirect_rwlock, RW_READER);
616 if (vd->vdev_indirect_mapping != NULL) {
617 ASSERT(vd->vdev_indirect_births != NULL);
618 vdev_indirect_mapping_t *vim =
619 vd->vdev_indirect_mapping;
620 fnvlist_add_uint64(nv, ZPOOL_CONFIG_INDIRECT_SIZE,
621 vdev_indirect_mapping_size(vim));
622 }
623 rw_exit(&vd->vdev_indirect_rwlock);
624 if (vd->vdev_mg != NULL &&
625 vd->vdev_mg->mg_fragmentation != ZFS_FRAG_INVALID) {
626 /*
627 * Compute approximately how much memory would be used
628 * for the indirect mapping if this device were to
629 * be removed.
630 *
631 * Note: If the frag metric is invalid, then not
632 * enough metaslabs have been converted to have
633 * histograms.
634 */
635 uint64_t seg_count = 0;
636 uint64_t to_alloc = vd->vdev_stat.vs_alloc;
637
638 /*
639 * There are the same number of allocated segments
640 * as free segments, so we will have at least one
641 * entry per free segment. However, small free
642 * segments (smaller than vdev_removal_max_span)
643 * will be combined with adjacent allocated segments
644 * as a single mapping.
645 */
646 for (int i = 0; i < RANGE_TREE_HISTOGRAM_SIZE; i++) {
647 if (i + 1 < highbit64(vdev_removal_max_span)
648 - 1) {
649 to_alloc +=
650 vd->vdev_mg->mg_histogram[i] <<
651 (i + 1);
652 } else {
653 seg_count +=
654 vd->vdev_mg->mg_histogram[i];
655 }
656 }
657
658 /*
659 * The maximum length of a mapping is
660 * zfs_remove_max_segment, so we need at least one entry
661 * per zfs_remove_max_segment of allocated data.
662 */
663 seg_count += to_alloc / spa_remove_max_segment(spa);
664
665 fnvlist_add_uint64(nv, ZPOOL_CONFIG_INDIRECT_SIZE,
666 seg_count *
667 sizeof (vdev_indirect_mapping_entry_phys_t));
668 }
669 }
670
671 if (!vd->vdev_ops->vdev_op_leaf) {
672 nvlist_t **child;
673 uint64_t c;
674
675 ASSERT(!vd->vdev_ishole);
676
677 child = kmem_alloc(vd->vdev_children * sizeof (nvlist_t *),
678 KM_SLEEP);
679
680 for (c = 0; c < vd->vdev_children; c++) {
681 child[c] = vdev_config_generate(spa, vd->vdev_child[c],
682 getstats, flags);
683 }
684
685 fnvlist_add_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
686 (const nvlist_t * const *)child, vd->vdev_children);
687
688 for (c = 0; c < vd->vdev_children; c++)
689 nvlist_free(child[c]);
690
691 kmem_free(child, vd->vdev_children * sizeof (nvlist_t *));
692
693 } else {
694 const char *aux = NULL;
695
696 if (vd->vdev_offline && !vd->vdev_tmpoffline)
697 fnvlist_add_uint64(nv, ZPOOL_CONFIG_OFFLINE, B_TRUE);
698 if (vd->vdev_resilver_txg != 0)
699 fnvlist_add_uint64(nv, ZPOOL_CONFIG_RESILVER_TXG,
700 vd->vdev_resilver_txg);
701 if (vd->vdev_rebuild_txg != 0)
702 fnvlist_add_uint64(nv, ZPOOL_CONFIG_REBUILD_TXG,
703 vd->vdev_rebuild_txg);
704 if (vd->vdev_faulted)
705 fnvlist_add_uint64(nv, ZPOOL_CONFIG_FAULTED, B_TRUE);
706 if (vd->vdev_degraded)
707 fnvlist_add_uint64(nv, ZPOOL_CONFIG_DEGRADED, B_TRUE);
708 if (vd->vdev_removed)
709 fnvlist_add_uint64(nv, ZPOOL_CONFIG_REMOVED, B_TRUE);
710 if (vd->vdev_unspare)
711 fnvlist_add_uint64(nv, ZPOOL_CONFIG_UNSPARE, B_TRUE);
712 if (vd->vdev_ishole)
713 fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_HOLE, B_TRUE);
714
715 /* Set the reason why we're FAULTED/DEGRADED. */
716 switch (vd->vdev_stat.vs_aux) {
717 case VDEV_AUX_ERR_EXCEEDED:
718 aux = "err_exceeded";
719 break;
720
721 case VDEV_AUX_EXTERNAL:
722 aux = "external";
723 break;
724 }
725
726 if (aux != NULL && !vd->vdev_tmpoffline) {
727 fnvlist_add_string(nv, ZPOOL_CONFIG_AUX_STATE, aux);
728 } else {
729 /*
730 * We're healthy - clear any previous AUX_STATE values.
731 */
732 if (nvlist_exists(nv, ZPOOL_CONFIG_AUX_STATE))
733 nvlist_remove_all(nv, ZPOOL_CONFIG_AUX_STATE);
734 }
735
736 if (vd->vdev_splitting && vd->vdev_orig_guid != 0LL) {
737 fnvlist_add_uint64(nv, ZPOOL_CONFIG_ORIG_GUID,
738 vd->vdev_orig_guid);
739 }
740 }
741
742 return (nv);
743 }
744
745 /*
746 * Generate a view of the top-level vdevs. If we currently have holes
747 * in the namespace, then generate an array which contains a list of holey
748 * vdevs. Additionally, add the number of top-level children that currently
749 * exist.
750 */
751 void
vdev_top_config_generate(spa_t * spa,nvlist_t * config)752 vdev_top_config_generate(spa_t *spa, nvlist_t *config)
753 {
754 vdev_t *rvd = spa->spa_root_vdev;
755 uint64_t *array;
756 uint_t c, idx;
757
758 array = kmem_alloc(rvd->vdev_children * sizeof (uint64_t), KM_SLEEP);
759
760 for (c = 0, idx = 0; c < rvd->vdev_children; c++) {
761 vdev_t *tvd = rvd->vdev_child[c];
762
763 if (tvd->vdev_ishole) {
764 array[idx++] = c;
765 }
766 }
767
768 if (idx) {
769 VERIFY(nvlist_add_uint64_array(config, ZPOOL_CONFIG_HOLE_ARRAY,
770 array, idx) == 0);
771 }
772
773 VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_VDEV_CHILDREN,
774 rvd->vdev_children) == 0);
775
776 kmem_free(array, rvd->vdev_children * sizeof (uint64_t));
777 }
778
779 /*
780 * Returns the configuration from the label of the given vdev. For vdevs
781 * which don't have a txg value stored on their label (i.e. spares/cache)
782 * or have not been completely initialized (txg = 0) just return
783 * the configuration from the first valid label we find. Otherwise,
784 * find the most up-to-date label that does not exceed the specified
785 * 'txg' value.
786 */
787 nvlist_t *
vdev_label_read_config(vdev_t * vd,uint64_t txg)788 vdev_label_read_config(vdev_t *vd, uint64_t txg)
789 {
790 spa_t *spa = vd->vdev_spa;
791 nvlist_t *config = NULL;
792 vdev_phys_t *vp[VDEV_LABELS];
793 abd_t *vp_abd[VDEV_LABELS];
794 zio_t *zio[VDEV_LABELS];
795 uint64_t best_txg = 0;
796 uint64_t label_txg = 0;
797 int error = 0;
798 int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL |
799 ZIO_FLAG_SPECULATIVE;
800
801 ASSERT(vd->vdev_validate_thread == curthread ||
802 spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);
803
804 if (!vdev_readable(vd))
805 return (NULL);
806
807 /*
808 * The label for a dRAID distributed spare is not stored on disk.
809 * Instead it is generated when needed which allows us to bypass
810 * the pipeline when reading the config from the label.
811 */
812 if (vd->vdev_ops == &vdev_draid_spare_ops)
813 return (vdev_draid_read_config_spare(vd));
814
815 for (int l = 0; l < VDEV_LABELS; l++) {
816 vp_abd[l] = abd_alloc_linear(sizeof (vdev_phys_t), B_TRUE);
817 vp[l] = abd_to_buf(vp_abd[l]);
818 }
819
820 retry:
821 for (int l = 0; l < VDEV_LABELS; l++) {
822 zio[l] = zio_root(spa, NULL, NULL, flags);
823
824 vdev_label_read(zio[l], vd, l, vp_abd[l],
825 offsetof(vdev_label_t, vl_vdev_phys), sizeof (vdev_phys_t),
826 NULL, NULL, flags);
827 }
828 for (int l = 0; l < VDEV_LABELS; l++) {
829 nvlist_t *label = NULL;
830
831 if (zio_wait(zio[l]) == 0 &&
832 nvlist_unpack(vp[l]->vp_nvlist, sizeof (vp[l]->vp_nvlist),
833 &label, 0) == 0) {
834 /*
835 * Auxiliary vdevs won't have txg values in their
836 * labels and newly added vdevs may not have been
837 * completely initialized so just return the
838 * configuration from the first valid label we
839 * encounter.
840 */
841 error = nvlist_lookup_uint64(label,
842 ZPOOL_CONFIG_POOL_TXG, &label_txg);
843 if ((error || label_txg == 0) && !config) {
844 config = label;
845 for (l++; l < VDEV_LABELS; l++)
846 zio_wait(zio[l]);
847 break;
848 } else if (label_txg <= txg && label_txg > best_txg) {
849 best_txg = label_txg;
850 nvlist_free(config);
851 config = fnvlist_dup(label);
852 }
853 }
854
855 if (label != NULL) {
856 nvlist_free(label);
857 label = NULL;
858 }
859 }
860
861 if (config == NULL && !(flags & ZIO_FLAG_TRYHARD)) {
862 flags |= ZIO_FLAG_TRYHARD;
863 goto retry;
864 }
865
866 /*
867 * We found a valid label but it didn't pass txg restrictions.
868 */
869 if (config == NULL && label_txg != 0) {
870 vdev_dbgmsg(vd, "label discarded as txg is too large "
871 "(%llu > %llu)", (u_longlong_t)label_txg,
872 (u_longlong_t)txg);
873 }
874
875 for (int l = 0; l < VDEV_LABELS; l++) {
876 abd_free(vp_abd[l]);
877 }
878
879 return (config);
880 }
881
882 /*
883 * Determine if a device is in use. The 'spare_guid' parameter will be filled
884 * in with the device guid if this spare is active elsewhere on the system.
885 */
886 static boolean_t
vdev_inuse(vdev_t * vd,uint64_t crtxg,vdev_labeltype_t reason,uint64_t * spare_guid,uint64_t * l2cache_guid)887 vdev_inuse(vdev_t *vd, uint64_t crtxg, vdev_labeltype_t reason,
888 uint64_t *spare_guid, uint64_t *l2cache_guid)
889 {
890 spa_t *spa = vd->vdev_spa;
891 uint64_t state, pool_guid, device_guid, txg, spare_pool;
892 uint64_t vdtxg = 0;
893 nvlist_t *label;
894
895 if (spare_guid)
896 *spare_guid = 0ULL;
897 if (l2cache_guid)
898 *l2cache_guid = 0ULL;
899
900 /*
901 * Read the label, if any, and perform some basic sanity checks.
902 */
903 if ((label = vdev_label_read_config(vd, -1ULL)) == NULL)
904 return (B_FALSE);
905
906 (void) nvlist_lookup_uint64(label, ZPOOL_CONFIG_CREATE_TXG,
907 &vdtxg);
908
909 if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_STATE,
910 &state) != 0 ||
911 nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID,
912 &device_guid) != 0) {
913 nvlist_free(label);
914 return (B_FALSE);
915 }
916
917 if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
918 (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_GUID,
919 &pool_guid) != 0 ||
920 nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_TXG,
921 &txg) != 0)) {
922 nvlist_free(label);
923 return (B_FALSE);
924 }
925
926 nvlist_free(label);
927
928 /*
929 * Check to see if this device indeed belongs to the pool it claims to
930 * be a part of. The only way this is allowed is if the device is a hot
931 * spare (which we check for later on).
932 */
933 if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
934 !spa_guid_exists(pool_guid, device_guid) &&
935 !spa_spare_exists(device_guid, NULL, NULL) &&
936 !spa_l2cache_exists(device_guid, NULL))
937 return (B_FALSE);
938
939 /*
940 * If the transaction group is zero, then this an initialized (but
941 * unused) label. This is only an error if the create transaction
942 * on-disk is the same as the one we're using now, in which case the
943 * user has attempted to add the same vdev multiple times in the same
944 * transaction.
945 */
946 if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
947 txg == 0 && vdtxg == crtxg)
948 return (B_TRUE);
949
950 /*
951 * Check to see if this is a spare device. We do an explicit check for
952 * spa_has_spare() here because it may be on our pending list of spares
953 * to add.
954 */
955 if (spa_spare_exists(device_guid, &spare_pool, NULL) ||
956 spa_has_spare(spa, device_guid)) {
957 if (spare_guid)
958 *spare_guid = device_guid;
959
960 switch (reason) {
961 case VDEV_LABEL_CREATE:
962 return (B_TRUE);
963
964 case VDEV_LABEL_REPLACE:
965 return (!spa_has_spare(spa, device_guid) ||
966 spare_pool != 0ULL);
967
968 case VDEV_LABEL_SPARE:
969 return (spa_has_spare(spa, device_guid));
970 default:
971 break;
972 }
973 }
974
975 /*
976 * Check to see if this is an l2cache device.
977 */
978 if (spa_l2cache_exists(device_guid, NULL) ||
979 spa_has_l2cache(spa, device_guid)) {
980 if (l2cache_guid)
981 *l2cache_guid = device_guid;
982
983 switch (reason) {
984 case VDEV_LABEL_CREATE:
985 return (B_TRUE);
986
987 case VDEV_LABEL_REPLACE:
988 return (!spa_has_l2cache(spa, device_guid));
989
990 case VDEV_LABEL_L2CACHE:
991 return (spa_has_l2cache(spa, device_guid));
992 default:
993 break;
994 }
995 }
996
997 /*
998 * We can't rely on a pool's state if it's been imported
999 * read-only. Instead we look to see if the pools is marked
1000 * read-only in the namespace and set the state to active.
1001 */
1002 if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
1003 (spa = spa_by_guid(pool_guid, device_guid)) != NULL &&
1004 spa_mode(spa) == SPA_MODE_READ)
1005 state = POOL_STATE_ACTIVE;
1006
1007 /*
1008 * If the device is marked ACTIVE, then this device is in use by another
1009 * pool on the system.
1010 */
1011 return (state == POOL_STATE_ACTIVE);
1012 }
1013
1014 static nvlist_t *
vdev_aux_label_generate(vdev_t * vd,boolean_t reason_spare)1015 vdev_aux_label_generate(vdev_t *vd, boolean_t reason_spare)
1016 {
1017 /*
1018 * For inactive hot spares and level 2 ARC devices, we generate
1019 * a special label that identifies as a mutually shared hot
1020 * spare or l2cache device. We write the label in case of
1021 * addition or removal of hot spare or l2cache vdev (in which
1022 * case we want to revert the labels).
1023 */
1024 nvlist_t *label = fnvlist_alloc();
1025 fnvlist_add_uint64(label, ZPOOL_CONFIG_VERSION,
1026 spa_version(vd->vdev_spa));
1027 fnvlist_add_uint64(label, ZPOOL_CONFIG_POOL_STATE, reason_spare ?
1028 POOL_STATE_SPARE : POOL_STATE_L2CACHE);
1029 fnvlist_add_uint64(label, ZPOOL_CONFIG_GUID, vd->vdev_guid);
1030
1031 /*
1032 * This is merely to facilitate reporting the ashift of the
1033 * cache device through zdb. The actual retrieval of the
1034 * ashift (in vdev_alloc()) uses the nvlist
1035 * spa->spa_l2cache->sav_config (populated in
1036 * spa_ld_open_aux_vdevs()).
1037 */
1038 if (!reason_spare)
1039 fnvlist_add_uint64(label, ZPOOL_CONFIG_ASHIFT, vd->vdev_ashift);
1040
1041 /*
1042 * Add path information to help find it during pool import
1043 */
1044 if (vd->vdev_path != NULL)
1045 fnvlist_add_string(label, ZPOOL_CONFIG_PATH, vd->vdev_path);
1046 if (vd->vdev_devid != NULL)
1047 fnvlist_add_string(label, ZPOOL_CONFIG_DEVID, vd->vdev_devid);
1048 if (vd->vdev_physpath != NULL) {
1049 fnvlist_add_string(label, ZPOOL_CONFIG_PHYS_PATH,
1050 vd->vdev_physpath);
1051 }
1052 return (label);
1053 }
1054
1055 /*
1056 * Initialize a vdev label. We check to make sure each leaf device is not in
1057 * use, and writable. We put down an initial label which we will later
1058 * overwrite with a complete label. Note that it's important to do this
1059 * sequentially, not in parallel, so that we catch cases of multiple use of the
1060 * same leaf vdev in the vdev we're creating -- e.g. mirroring a disk with
1061 * itself.
1062 */
1063 int
vdev_label_init(vdev_t * vd,uint64_t crtxg,vdev_labeltype_t reason)1064 vdev_label_init(vdev_t *vd, uint64_t crtxg, vdev_labeltype_t reason)
1065 {
1066 spa_t *spa = vd->vdev_spa;
1067 nvlist_t *label;
1068 vdev_phys_t *vp;
1069 abd_t *vp_abd;
1070 abd_t *bootenv;
1071 uberblock_t *ub;
1072 abd_t *ub_abd;
1073 zio_t *zio;
1074 char *buf;
1075 size_t buflen;
1076 int error;
1077 uint64_t spare_guid = 0, l2cache_guid = 0;
1078 int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL;
1079 boolean_t reason_spare = (reason == VDEV_LABEL_SPARE || (reason ==
1080 VDEV_LABEL_REMOVE && vd->vdev_isspare));
1081 boolean_t reason_l2cache = (reason == VDEV_LABEL_L2CACHE || (reason ==
1082 VDEV_LABEL_REMOVE && vd->vdev_isl2cache));
1083
1084 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
1085
1086 for (int c = 0; c < vd->vdev_children; c++)
1087 if ((error = vdev_label_init(vd->vdev_child[c],
1088 crtxg, reason)) != 0)
1089 return (error);
1090
1091 /* Track the creation time for this vdev */
1092 vd->vdev_crtxg = crtxg;
1093
1094 if (!vd->vdev_ops->vdev_op_leaf || !spa_writeable(spa))
1095 return (0);
1096
1097 /*
1098 * Dead vdevs cannot be initialized.
1099 */
1100 if (vdev_is_dead(vd))
1101 return (SET_ERROR(EIO));
1102
1103 /*
1104 * Determine if the vdev is in use.
1105 */
1106 if (reason != VDEV_LABEL_REMOVE && reason != VDEV_LABEL_SPLIT &&
1107 vdev_inuse(vd, crtxg, reason, &spare_guid, &l2cache_guid))
1108 return (SET_ERROR(EBUSY));
1109
1110 /*
1111 * If this is a request to add or replace a spare or l2cache device
1112 * that is in use elsewhere on the system, then we must update the
1113 * guid (which was initialized to a random value) to reflect the
1114 * actual GUID (which is shared between multiple pools).
1115 */
1116 if (reason != VDEV_LABEL_REMOVE && reason != VDEV_LABEL_L2CACHE &&
1117 spare_guid != 0ULL) {
1118 uint64_t guid_delta = spare_guid - vd->vdev_guid;
1119
1120 vd->vdev_guid += guid_delta;
1121
1122 for (vdev_t *pvd = vd; pvd != NULL; pvd = pvd->vdev_parent)
1123 pvd->vdev_guid_sum += guid_delta;
1124
1125 /*
1126 * If this is a replacement, then we want to fallthrough to the
1127 * rest of the code. If we're adding a spare, then it's already
1128 * labeled appropriately and we can just return.
1129 */
1130 if (reason == VDEV_LABEL_SPARE)
1131 return (0);
1132 ASSERT(reason == VDEV_LABEL_REPLACE ||
1133 reason == VDEV_LABEL_SPLIT);
1134 }
1135
1136 if (reason != VDEV_LABEL_REMOVE && reason != VDEV_LABEL_SPARE &&
1137 l2cache_guid != 0ULL) {
1138 uint64_t guid_delta = l2cache_guid - vd->vdev_guid;
1139
1140 vd->vdev_guid += guid_delta;
1141
1142 for (vdev_t *pvd = vd; pvd != NULL; pvd = pvd->vdev_parent)
1143 pvd->vdev_guid_sum += guid_delta;
1144
1145 /*
1146 * If this is a replacement, then we want to fallthrough to the
1147 * rest of the code. If we're adding an l2cache, then it's
1148 * already labeled appropriately and we can just return.
1149 */
1150 if (reason == VDEV_LABEL_L2CACHE)
1151 return (0);
1152 ASSERT(reason == VDEV_LABEL_REPLACE);
1153 }
1154
1155 /*
1156 * Initialize its label.
1157 */
1158 vp_abd = abd_alloc_linear(sizeof (vdev_phys_t), B_TRUE);
1159 abd_zero(vp_abd, sizeof (vdev_phys_t));
1160 vp = abd_to_buf(vp_abd);
1161
1162 /*
1163 * Generate a label describing the pool and our top-level vdev.
1164 * We mark it as being from txg 0 to indicate that it's not
1165 * really part of an active pool just yet. The labels will
1166 * be written again with a meaningful txg by spa_sync().
1167 */
1168 if (reason_spare || reason_l2cache) {
1169 label = vdev_aux_label_generate(vd, reason_spare);
1170
1171 /*
1172 * When spare or l2cache (aux) vdev is added during pool
1173 * creation, spa->spa_uberblock is not written until this
1174 * point. Write it on next config sync.
1175 */
1176 if (uberblock_verify(&spa->spa_uberblock))
1177 spa->spa_aux_sync_uber = B_TRUE;
1178 } else {
1179 uint64_t txg = 0ULL;
1180
1181 if (reason == VDEV_LABEL_SPLIT)
1182 txg = spa->spa_uberblock.ub_txg;
1183 label = spa_config_generate(spa, vd, txg, B_FALSE);
1184
1185 /*
1186 * Add our creation time. This allows us to detect multiple
1187 * vdev uses as described above, and automatically expires if we
1188 * fail.
1189 */
1190 VERIFY(nvlist_add_uint64(label, ZPOOL_CONFIG_CREATE_TXG,
1191 crtxg) == 0);
1192 }
1193
1194 buf = vp->vp_nvlist;
1195 buflen = sizeof (vp->vp_nvlist);
1196
1197 error = nvlist_pack(label, &buf, &buflen, NV_ENCODE_XDR, KM_SLEEP);
1198 if (error != 0) {
1199 nvlist_free(label);
1200 abd_free(vp_abd);
1201 /* EFAULT means nvlist_pack ran out of room */
1202 return (SET_ERROR(error == EFAULT ? ENAMETOOLONG : EINVAL));
1203 }
1204
1205 /*
1206 * Initialize uberblock template.
1207 */
1208 ub_abd = abd_alloc_linear(VDEV_UBERBLOCK_RING, B_TRUE);
1209 abd_copy_from_buf(ub_abd, &spa->spa_uberblock, sizeof (uberblock_t));
1210 abd_zero_off(ub_abd, sizeof (uberblock_t),
1211 VDEV_UBERBLOCK_RING - sizeof (uberblock_t));
1212 ub = abd_to_buf(ub_abd);
1213 ub->ub_txg = 0;
1214
1215 /* Initialize the 2nd padding area. */
1216 bootenv = abd_alloc_for_io(VDEV_PAD_SIZE, B_TRUE);
1217 abd_zero(bootenv, VDEV_PAD_SIZE);
1218
1219 /*
1220 * Write everything in parallel.
1221 */
1222 retry:
1223 zio = zio_root(spa, NULL, NULL, flags);
1224
1225 for (int l = 0; l < VDEV_LABELS; l++) {
1226
1227 vdev_label_write(zio, vd, l, vp_abd,
1228 offsetof(vdev_label_t, vl_vdev_phys),
1229 sizeof (vdev_phys_t), NULL, NULL, flags);
1230
1231 /*
1232 * Skip the 1st padding area.
1233 * Zero out the 2nd padding area where it might have
1234 * left over data from previous filesystem format.
1235 */
1236 vdev_label_write(zio, vd, l, bootenv,
1237 offsetof(vdev_label_t, vl_be),
1238 VDEV_PAD_SIZE, NULL, NULL, flags);
1239
1240 vdev_label_write(zio, vd, l, ub_abd,
1241 offsetof(vdev_label_t, vl_uberblock),
1242 VDEV_UBERBLOCK_RING, NULL, NULL, flags);
1243 }
1244
1245 error = zio_wait(zio);
1246
1247 if (error != 0 && !(flags & ZIO_FLAG_TRYHARD)) {
1248 flags |= ZIO_FLAG_TRYHARD;
1249 goto retry;
1250 }
1251
1252 nvlist_free(label);
1253 abd_free(bootenv);
1254 abd_free(ub_abd);
1255 abd_free(vp_abd);
1256
1257 /*
1258 * If this vdev hasn't been previously identified as a spare, then we
1259 * mark it as such only if a) we are labeling it as a spare, or b) it
1260 * exists as a spare elsewhere in the system. Do the same for
1261 * level 2 ARC devices.
1262 */
1263 if (error == 0 && !vd->vdev_isspare &&
1264 (reason == VDEV_LABEL_SPARE ||
1265 spa_spare_exists(vd->vdev_guid, NULL, NULL)))
1266 spa_spare_add(vd);
1267
1268 if (error == 0 && !vd->vdev_isl2cache &&
1269 (reason == VDEV_LABEL_L2CACHE ||
1270 spa_l2cache_exists(vd->vdev_guid, NULL)))
1271 spa_l2cache_add(vd);
1272
1273 return (error);
1274 }
1275
1276 /*
1277 * Done callback for vdev_label_read_bootenv_impl. If this is the first
1278 * callback to finish, store our abd in the callback pointer. Otherwise, we
1279 * just free our abd and return.
1280 */
1281 static void
vdev_label_read_bootenv_done(zio_t * zio)1282 vdev_label_read_bootenv_done(zio_t *zio)
1283 {
1284 zio_t *rio = zio->io_private;
1285 abd_t **cbp = rio->io_private;
1286
1287 ASSERT3U(zio->io_size, ==, VDEV_PAD_SIZE);
1288
1289 if (zio->io_error == 0) {
1290 mutex_enter(&rio->io_lock);
1291 if (*cbp == NULL) {
1292 /* Will free this buffer in vdev_label_read_bootenv. */
1293 *cbp = zio->io_abd;
1294 } else {
1295 abd_free(zio->io_abd);
1296 }
1297 mutex_exit(&rio->io_lock);
1298 } else {
1299 abd_free(zio->io_abd);
1300 }
1301 }
1302
1303 static void
vdev_label_read_bootenv_impl(zio_t * zio,vdev_t * vd,int flags)1304 vdev_label_read_bootenv_impl(zio_t *zio, vdev_t *vd, int flags)
1305 {
1306 for (int c = 0; c < vd->vdev_children; c++)
1307 vdev_label_read_bootenv_impl(zio, vd->vdev_child[c], flags);
1308
1309 /*
1310 * We just use the first label that has a correct checksum; the
1311 * bootloader should have rewritten them all to be the same on boot,
1312 * and any changes we made since boot have been the same across all
1313 * labels.
1314 */
1315 if (vd->vdev_ops->vdev_op_leaf && vdev_readable(vd)) {
1316 for (int l = 0; l < VDEV_LABELS; l++) {
1317 vdev_label_read(zio, vd, l,
1318 abd_alloc_linear(VDEV_PAD_SIZE, B_FALSE),
1319 offsetof(vdev_label_t, vl_be), VDEV_PAD_SIZE,
1320 vdev_label_read_bootenv_done, zio, flags);
1321 }
1322 }
1323 }
1324
1325 int
vdev_label_read_bootenv(vdev_t * rvd,nvlist_t * bootenv)1326 vdev_label_read_bootenv(vdev_t *rvd, nvlist_t *bootenv)
1327 {
1328 nvlist_t *config;
1329 spa_t *spa = rvd->vdev_spa;
1330 abd_t *abd = NULL;
1331 int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL |
1332 ZIO_FLAG_SPECULATIVE | ZIO_FLAG_TRYHARD;
1333
1334 ASSERT(bootenv);
1335 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
1336
1337 zio_t *zio = zio_root(spa, NULL, &abd, flags);
1338 vdev_label_read_bootenv_impl(zio, rvd, flags);
1339 int err = zio_wait(zio);
1340
1341 if (abd != NULL) {
1342 char *buf;
1343 vdev_boot_envblock_t *vbe = abd_to_buf(abd);
1344
1345 vbe->vbe_version = ntohll(vbe->vbe_version);
1346 switch (vbe->vbe_version) {
1347 case VB_RAW:
1348 /*
1349 * if we have textual data in vbe_bootenv, create nvlist
1350 * with key "envmap".
1351 */
1352 fnvlist_add_uint64(bootenv, BOOTENV_VERSION, VB_RAW);
1353 vbe->vbe_bootenv[sizeof (vbe->vbe_bootenv) - 1] = '\0';
1354 fnvlist_add_string(bootenv, GRUB_ENVMAP,
1355 vbe->vbe_bootenv);
1356 break;
1357
1358 case VB_NVLIST:
1359 err = nvlist_unpack(vbe->vbe_bootenv,
1360 sizeof (vbe->vbe_bootenv), &config, 0);
1361 if (err == 0) {
1362 fnvlist_merge(bootenv, config);
1363 nvlist_free(config);
1364 break;
1365 }
1366 zfs_fallthrough;
1367 default:
1368 /* Check for FreeBSD zfs bootonce command string */
1369 buf = abd_to_buf(abd);
1370 if (*buf == '\0') {
1371 fnvlist_add_uint64(bootenv, BOOTENV_VERSION,
1372 VB_NVLIST);
1373 break;
1374 }
1375 fnvlist_add_string(bootenv, FREEBSD_BOOTONCE, buf);
1376 }
1377
1378 /*
1379 * abd was allocated in vdev_label_read_bootenv_impl()
1380 */
1381 abd_free(abd);
1382 /*
1383 * If we managed to read any successfully,
1384 * return success.
1385 */
1386 return (0);
1387 }
1388 return (err);
1389 }
1390
1391 int
vdev_label_write_bootenv(vdev_t * vd,nvlist_t * env)1392 vdev_label_write_bootenv(vdev_t *vd, nvlist_t *env)
1393 {
1394 zio_t *zio;
1395 spa_t *spa = vd->vdev_spa;
1396 vdev_boot_envblock_t *bootenv;
1397 int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL;
1398 int error;
1399 size_t nvsize;
1400 char *nvbuf;
1401 const char *tmp;
1402
1403 error = nvlist_size(env, &nvsize, NV_ENCODE_XDR);
1404 if (error != 0)
1405 return (SET_ERROR(error));
1406
1407 if (nvsize >= sizeof (bootenv->vbe_bootenv)) {
1408 return (SET_ERROR(E2BIG));
1409 }
1410
1411 ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);
1412
1413 error = ENXIO;
1414 for (int c = 0; c < vd->vdev_children; c++) {
1415 int child_err;
1416
1417 child_err = vdev_label_write_bootenv(vd->vdev_child[c], env);
1418 /*
1419 * As long as any of the disks managed to write all of their
1420 * labels successfully, return success.
1421 */
1422 if (child_err == 0)
1423 error = child_err;
1424 }
1425
1426 if (!vd->vdev_ops->vdev_op_leaf || vdev_is_dead(vd) ||
1427 !vdev_writeable(vd)) {
1428 return (error);
1429 }
1430 ASSERT3U(sizeof (*bootenv), ==, VDEV_PAD_SIZE);
1431 abd_t *abd = abd_alloc_for_io(VDEV_PAD_SIZE, B_TRUE);
1432 abd_zero(abd, VDEV_PAD_SIZE);
1433
1434 bootenv = abd_borrow_buf_copy(abd, VDEV_PAD_SIZE);
1435 nvbuf = bootenv->vbe_bootenv;
1436 nvsize = sizeof (bootenv->vbe_bootenv);
1437
1438 bootenv->vbe_version = fnvlist_lookup_uint64(env, BOOTENV_VERSION);
1439 switch (bootenv->vbe_version) {
1440 case VB_RAW:
1441 if (nvlist_lookup_string(env, GRUB_ENVMAP, &tmp) == 0) {
1442 (void) strlcpy(bootenv->vbe_bootenv, tmp, nvsize);
1443 }
1444 error = 0;
1445 break;
1446
1447 case VB_NVLIST:
1448 error = nvlist_pack(env, &nvbuf, &nvsize, NV_ENCODE_XDR,
1449 KM_SLEEP);
1450 break;
1451
1452 default:
1453 error = EINVAL;
1454 break;
1455 }
1456
1457 if (error == 0) {
1458 bootenv->vbe_version = htonll(bootenv->vbe_version);
1459 abd_return_buf_copy(abd, bootenv, VDEV_PAD_SIZE);
1460 } else {
1461 abd_free(abd);
1462 return (SET_ERROR(error));
1463 }
1464
1465 retry:
1466 zio = zio_root(spa, NULL, NULL, flags);
1467 for (int l = 0; l < VDEV_LABELS; l++) {
1468 vdev_label_write(zio, vd, l, abd,
1469 offsetof(vdev_label_t, vl_be),
1470 VDEV_PAD_SIZE, NULL, NULL, flags);
1471 }
1472
1473 error = zio_wait(zio);
1474 if (error != 0 && !(flags & ZIO_FLAG_TRYHARD)) {
1475 flags |= ZIO_FLAG_TRYHARD;
1476 goto retry;
1477 }
1478
1479 abd_free(abd);
1480 return (error);
1481 }
1482
1483 /*
1484 * ==========================================================================
1485 * uberblock load/sync
1486 * ==========================================================================
1487 */
1488
1489 /*
1490 * Consider the following situation: txg is safely synced to disk. We've
1491 * written the first uberblock for txg + 1, and then we lose power. When we
1492 * come back up, we fail to see the uberblock for txg + 1 because, say,
1493 * it was on a mirrored device and the replica to which we wrote txg + 1
1494 * is now offline. If we then make some changes and sync txg + 1, and then
1495 * the missing replica comes back, then for a few seconds we'll have two
1496 * conflicting uberblocks on disk with the same txg. The solution is simple:
1497 * among uberblocks with equal txg, choose the one with the latest timestamp.
1498 */
1499 static int
vdev_uberblock_compare(const uberblock_t * ub1,const uberblock_t * ub2)1500 vdev_uberblock_compare(const uberblock_t *ub1, const uberblock_t *ub2)
1501 {
1502 int cmp = TREE_CMP(ub1->ub_txg, ub2->ub_txg);
1503
1504 if (likely(cmp))
1505 return (cmp);
1506
1507 cmp = TREE_CMP(ub1->ub_timestamp, ub2->ub_timestamp);
1508 if (likely(cmp))
1509 return (cmp);
1510
1511 /*
1512 * If MMP_VALID(ub) && MMP_SEQ_VALID(ub) then the host has an MMP-aware
1513 * ZFS, e.g. OpenZFS >= 0.7.
1514 *
1515 * If one ub has MMP and the other does not, they were written by
1516 * different hosts, which matters for MMP. So we treat no MMP/no SEQ as
1517 * a 0 value.
1518 *
1519 * Since timestamp and txg are the same if we get this far, either is
1520 * acceptable for importing the pool.
1521 */
1522 unsigned int seq1 = 0;
1523 unsigned int seq2 = 0;
1524
1525 if (MMP_VALID(ub1) && MMP_SEQ_VALID(ub1))
1526 seq1 = MMP_SEQ(ub1);
1527
1528 if (MMP_VALID(ub2) && MMP_SEQ_VALID(ub2))
1529 seq2 = MMP_SEQ(ub2);
1530
1531 return (TREE_CMP(seq1, seq2));
1532 }
1533
1534 struct ubl_cbdata {
1535 uberblock_t ubl_latest; /* Most recent uberblock */
1536 uberblock_t *ubl_ubbest; /* Best uberblock (w/r/t max_txg) */
1537 vdev_t *ubl_vd; /* vdev associated with the above */
1538 };
1539
1540 static void
vdev_uberblock_load_done(zio_t * zio)1541 vdev_uberblock_load_done(zio_t *zio)
1542 {
1543 vdev_t *vd = zio->io_vd;
1544 spa_t *spa = zio->io_spa;
1545 zio_t *rio = zio->io_private;
1546 uberblock_t *ub = abd_to_buf(zio->io_abd);
1547 struct ubl_cbdata *cbp = rio->io_private;
1548
1549 ASSERT3U(zio->io_size, ==, VDEV_UBERBLOCK_SIZE(vd));
1550
1551 if (zio->io_error == 0 && uberblock_verify(ub) == 0) {
1552 mutex_enter(&rio->io_lock);
1553 if (vdev_uberblock_compare(ub, &cbp->ubl_latest) > 0) {
1554 cbp->ubl_latest = *ub;
1555 }
1556 if (ub->ub_txg <= spa->spa_load_max_txg &&
1557 vdev_uberblock_compare(ub, cbp->ubl_ubbest) > 0) {
1558 /*
1559 * Keep track of the vdev in which this uberblock
1560 * was found. We will use this information later
1561 * to obtain the config nvlist associated with
1562 * this uberblock.
1563 */
1564 *cbp->ubl_ubbest = *ub;
1565 cbp->ubl_vd = vd;
1566 }
1567 mutex_exit(&rio->io_lock);
1568 }
1569
1570 abd_free(zio->io_abd);
1571 }
1572
1573 static void
vdev_uberblock_load_impl(zio_t * zio,vdev_t * vd,int flags,struct ubl_cbdata * cbp)1574 vdev_uberblock_load_impl(zio_t *zio, vdev_t *vd, int flags,
1575 struct ubl_cbdata *cbp)
1576 {
1577 for (int c = 0; c < vd->vdev_children; c++)
1578 vdev_uberblock_load_impl(zio, vd->vdev_child[c], flags, cbp);
1579
1580 if (vd->vdev_ops->vdev_op_leaf && vdev_readable(vd) &&
1581 vd->vdev_ops != &vdev_draid_spare_ops) {
1582 for (int l = 0; l < VDEV_LABELS; l++) {
1583 for (int n = 0; n < VDEV_UBERBLOCK_COUNT(vd); n++) {
1584 vdev_label_read(zio, vd, l,
1585 abd_alloc_linear(VDEV_UBERBLOCK_SIZE(vd),
1586 B_TRUE), VDEV_UBERBLOCK_OFFSET(vd, n),
1587 VDEV_UBERBLOCK_SIZE(vd),
1588 vdev_uberblock_load_done, zio, flags);
1589 }
1590 }
1591 }
1592 }
1593
1594 /*
1595 * Reads the 'best' uberblock from disk along with its associated
1596 * configuration. First, we read the uberblock array of each label of each
1597 * vdev, keeping track of the uberblock with the highest txg in each array.
1598 * Then, we read the configuration from the same vdev as the best uberblock.
1599 */
1600 void
vdev_uberblock_load(vdev_t * rvd,uberblock_t * ub,nvlist_t ** config)1601 vdev_uberblock_load(vdev_t *rvd, uberblock_t *ub, nvlist_t **config)
1602 {
1603 zio_t *zio;
1604 spa_t *spa = rvd->vdev_spa;
1605 struct ubl_cbdata cb;
1606 int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL |
1607 ZIO_FLAG_SPECULATIVE | ZIO_FLAG_TRYHARD;
1608
1609 ASSERT(ub);
1610 ASSERT(config);
1611
1612 memset(ub, 0, sizeof (uberblock_t));
1613 memset(&cb, 0, sizeof (cb));
1614 *config = NULL;
1615
1616 cb.ubl_ubbest = ub;
1617
1618 spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
1619 zio = zio_root(spa, NULL, &cb, flags);
1620 vdev_uberblock_load_impl(zio, rvd, flags, &cb);
1621 (void) zio_wait(zio);
1622
1623 /*
1624 * It's possible that the best uberblock was discovered on a label
1625 * that has a configuration which was written in a future txg.
1626 * Search all labels on this vdev to find the configuration that
1627 * matches the txg for our uberblock.
1628 */
1629 if (cb.ubl_vd != NULL) {
1630 vdev_dbgmsg(cb.ubl_vd, "best uberblock found for spa %s. "
1631 "txg %llu", spa->spa_name, (u_longlong_t)ub->ub_txg);
1632
1633 if (ub->ub_raidz_reflow_info !=
1634 cb.ubl_latest.ub_raidz_reflow_info) {
1635 vdev_dbgmsg(cb.ubl_vd,
1636 "spa=%s best uberblock (txg=%llu info=0x%llx) "
1637 "has different raidz_reflow_info than latest "
1638 "uberblock (txg=%llu info=0x%llx)",
1639 spa->spa_name,
1640 (u_longlong_t)ub->ub_txg,
1641 (u_longlong_t)ub->ub_raidz_reflow_info,
1642 (u_longlong_t)cb.ubl_latest.ub_txg,
1643 (u_longlong_t)cb.ubl_latest.ub_raidz_reflow_info);
1644 memset(ub, 0, sizeof (uberblock_t));
1645 spa_config_exit(spa, SCL_ALL, FTAG);
1646 return;
1647 }
1648
1649 *config = vdev_label_read_config(cb.ubl_vd, ub->ub_txg);
1650 if (*config == NULL && spa->spa_extreme_rewind) {
1651 vdev_dbgmsg(cb.ubl_vd, "failed to read label config. "
1652 "Trying again without txg restrictions.");
1653 *config = vdev_label_read_config(cb.ubl_vd, UINT64_MAX);
1654 }
1655 if (*config == NULL) {
1656 vdev_dbgmsg(cb.ubl_vd, "failed to read label config");
1657 }
1658 }
1659 spa_config_exit(spa, SCL_ALL, FTAG);
1660 }
1661
1662 /*
1663 * For use when a leaf vdev is expanded.
1664 * The location of labels 2 and 3 changed, and at the new location the
1665 * uberblock rings are either empty or contain garbage. The sync will write
1666 * new configs there because the vdev is dirty, but expansion also needs the
1667 * uberblock rings copied. Read them from label 0 which did not move.
1668 *
1669 * Since the point is to populate labels {2,3} with valid uberblocks,
1670 * we zero uberblocks we fail to read or which are not valid.
1671 */
1672
1673 static void
vdev_copy_uberblocks(vdev_t * vd)1674 vdev_copy_uberblocks(vdev_t *vd)
1675 {
1676 abd_t *ub_abd;
1677 zio_t *write_zio;
1678 int locks = (SCL_L2ARC | SCL_ZIO);
1679 int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL |
1680 ZIO_FLAG_SPECULATIVE;
1681
1682 ASSERT(spa_config_held(vd->vdev_spa, SCL_STATE, RW_READER) ==
1683 SCL_STATE);
1684 ASSERT(vd->vdev_ops->vdev_op_leaf);
1685
1686 /*
1687 * No uberblocks are stored on distributed spares, they may be
1688 * safely skipped when expanding a leaf vdev.
1689 */
1690 if (vd->vdev_ops == &vdev_draid_spare_ops)
1691 return;
1692
1693 spa_config_enter(vd->vdev_spa, locks, FTAG, RW_READER);
1694
1695 ub_abd = abd_alloc_linear(VDEV_UBERBLOCK_SIZE(vd), B_TRUE);
1696
1697 write_zio = zio_root(vd->vdev_spa, NULL, NULL, flags);
1698 for (int n = 0; n < VDEV_UBERBLOCK_COUNT(vd); n++) {
1699 const int src_label = 0;
1700 zio_t *zio;
1701
1702 zio = zio_root(vd->vdev_spa, NULL, NULL, flags);
1703 vdev_label_read(zio, vd, src_label, ub_abd,
1704 VDEV_UBERBLOCK_OFFSET(vd, n), VDEV_UBERBLOCK_SIZE(vd),
1705 NULL, NULL, flags);
1706
1707 if (zio_wait(zio) || uberblock_verify(abd_to_buf(ub_abd)))
1708 abd_zero(ub_abd, VDEV_UBERBLOCK_SIZE(vd));
1709
1710 for (int l = 2; l < VDEV_LABELS; l++)
1711 vdev_label_write(write_zio, vd, l, ub_abd,
1712 VDEV_UBERBLOCK_OFFSET(vd, n),
1713 VDEV_UBERBLOCK_SIZE(vd), NULL, NULL,
1714 flags | ZIO_FLAG_DONT_PROPAGATE);
1715 }
1716 (void) zio_wait(write_zio);
1717
1718 spa_config_exit(vd->vdev_spa, locks, FTAG);
1719
1720 abd_free(ub_abd);
1721 }
1722
1723 /*
1724 * On success, increment root zio's count of good writes.
1725 * We only get credit for writes to known-visible vdevs; see spa_vdev_add().
1726 */
1727 static void
vdev_uberblock_sync_done(zio_t * zio)1728 vdev_uberblock_sync_done(zio_t *zio)
1729 {
1730 uint64_t *good_writes = zio->io_private;
1731
1732 if (zio->io_error == 0 && zio->io_vd->vdev_top->vdev_ms_array != 0)
1733 atomic_inc_64(good_writes);
1734 }
1735
1736 /*
1737 * Write the uberblock to all labels of all leaves of the specified vdev.
1738 */
1739 static void
vdev_uberblock_sync(zio_t * zio,uint64_t * good_writes,uberblock_t * ub,vdev_t * vd,int flags)1740 vdev_uberblock_sync(zio_t *zio, uint64_t *good_writes,
1741 uberblock_t *ub, vdev_t *vd, int flags)
1742 {
1743 for (uint64_t c = 0; c < vd->vdev_children; c++) {
1744 vdev_uberblock_sync(zio, good_writes,
1745 ub, vd->vdev_child[c], flags);
1746 }
1747
1748 if (!vd->vdev_ops->vdev_op_leaf)
1749 return;
1750
1751 if (!vdev_writeable(vd))
1752 return;
1753
1754 /*
1755 * There's no need to write uberblocks to a distributed spare, they
1756 * are already stored on all the leaves of the parent dRAID. For
1757 * this same reason vdev_uberblock_load_impl() skips distributed
1758 * spares when reading uberblocks.
1759 */
1760 if (vd->vdev_ops == &vdev_draid_spare_ops)
1761 return;
1762
1763 /* If the vdev was expanded, need to copy uberblock rings. */
1764 if (vd->vdev_state == VDEV_STATE_HEALTHY &&
1765 vd->vdev_copy_uberblocks == B_TRUE) {
1766 vdev_copy_uberblocks(vd);
1767 vd->vdev_copy_uberblocks = B_FALSE;
1768 }
1769
1770 /*
1771 * We chose a slot based on the txg. If this uberblock has a special
1772 * RAIDZ expansion state, then it is essentially an update of the
1773 * current uberblock (it has the same txg). However, the current
1774 * state is committed, so we want to write it to a different slot. If
1775 * we overwrote the same slot, and we lose power during the uberblock
1776 * write, and the disk does not do single-sector overwrites
1777 * atomically (even though it is required to - i.e. we should see
1778 * either the old or the new uberblock), then we could lose this
1779 * txg's uberblock. Rewinding to the previous txg's uberblock may not
1780 * be possible because RAIDZ expansion may have already overwritten
1781 * some of the data, so we need the progress indicator in the
1782 * uberblock.
1783 */
1784 int m = spa_multihost(vd->vdev_spa) ? MMP_BLOCKS_PER_LABEL : 0;
1785 int n = (ub->ub_txg - (RRSS_GET_STATE(ub) == RRSS_SCRATCH_VALID)) %
1786 (VDEV_UBERBLOCK_COUNT(vd) - m);
1787
1788 /* Copy the uberblock_t into the ABD */
1789 abd_t *ub_abd = abd_alloc_for_io(VDEV_UBERBLOCK_SIZE(vd), B_TRUE);
1790 abd_copy_from_buf(ub_abd, ub, sizeof (uberblock_t));
1791 abd_zero_off(ub_abd, sizeof (uberblock_t),
1792 VDEV_UBERBLOCK_SIZE(vd) - sizeof (uberblock_t));
1793
1794 for (int l = 0; l < VDEV_LABELS; l++)
1795 vdev_label_write(zio, vd, l, ub_abd,
1796 VDEV_UBERBLOCK_OFFSET(vd, n), VDEV_UBERBLOCK_SIZE(vd),
1797 vdev_uberblock_sync_done, good_writes,
1798 flags | ZIO_FLAG_DONT_PROPAGATE);
1799
1800 abd_free(ub_abd);
1801 }
1802
1803 /* Sync the uberblocks to all vdevs in svd[] */
1804 int
vdev_uberblock_sync_list(vdev_t ** svd,int svdcount,uberblock_t * ub,int flags)1805 vdev_uberblock_sync_list(vdev_t **svd, int svdcount, uberblock_t *ub, int flags)
1806 {
1807 spa_t *spa = svd[0]->vdev_spa;
1808 zio_t *zio;
1809 uint64_t good_writes = 0;
1810
1811 zio = zio_root(spa, NULL, NULL, flags);
1812
1813 for (int v = 0; v < svdcount; v++)
1814 vdev_uberblock_sync(zio, &good_writes, ub, svd[v], flags);
1815
1816 if (spa->spa_aux_sync_uber) {
1817 for (int v = 0; v < spa->spa_spares.sav_count; v++) {
1818 vdev_uberblock_sync(zio, &good_writes, ub,
1819 spa->spa_spares.sav_vdevs[v], flags);
1820 }
1821 for (int v = 0; v < spa->spa_l2cache.sav_count; v++) {
1822 vdev_uberblock_sync(zio, &good_writes, ub,
1823 spa->spa_l2cache.sav_vdevs[v], flags);
1824 }
1825 }
1826 (void) zio_wait(zio);
1827
1828 /*
1829 * Flush the uberblocks to disk. This ensures that the odd labels
1830 * are no longer needed (because the new uberblocks and the even
1831 * labels are safely on disk), so it is safe to overwrite them.
1832 */
1833 zio = zio_root(spa, NULL, NULL, flags);
1834
1835 for (int v = 0; v < svdcount; v++) {
1836 if (vdev_writeable(svd[v])) {
1837 zio_flush(zio, svd[v]);
1838 }
1839 }
1840 if (spa->spa_aux_sync_uber) {
1841 spa->spa_aux_sync_uber = B_FALSE;
1842 for (int v = 0; v < spa->spa_spares.sav_count; v++) {
1843 if (vdev_writeable(spa->spa_spares.sav_vdevs[v])) {
1844 zio_flush(zio, spa->spa_spares.sav_vdevs[v]);
1845 }
1846 }
1847 for (int v = 0; v < spa->spa_l2cache.sav_count; v++) {
1848 if (vdev_writeable(spa->spa_l2cache.sav_vdevs[v])) {
1849 zio_flush(zio, spa->spa_l2cache.sav_vdevs[v]);
1850 }
1851 }
1852 }
1853
1854 (void) zio_wait(zio);
1855
1856 return (good_writes >= 1 ? 0 : EIO);
1857 }
1858
1859 /*
1860 * On success, increment the count of good writes for our top-level vdev.
1861 */
1862 static void
vdev_label_sync_done(zio_t * zio)1863 vdev_label_sync_done(zio_t *zio)
1864 {
1865 uint64_t *good_writes = zio->io_private;
1866
1867 if (zio->io_error == 0)
1868 atomic_inc_64(good_writes);
1869 }
1870
1871 /*
1872 * If there weren't enough good writes, indicate failure to the parent.
1873 */
1874 static void
vdev_label_sync_top_done(zio_t * zio)1875 vdev_label_sync_top_done(zio_t *zio)
1876 {
1877 uint64_t *good_writes = zio->io_private;
1878
1879 if (*good_writes == 0)
1880 zio->io_error = SET_ERROR(EIO);
1881
1882 kmem_free(good_writes, sizeof (uint64_t));
1883 }
1884
1885 /*
1886 * We ignore errors for log and cache devices, simply free the private data.
1887 */
1888 static void
vdev_label_sync_ignore_done(zio_t * zio)1889 vdev_label_sync_ignore_done(zio_t *zio)
1890 {
1891 kmem_free(zio->io_private, sizeof (uint64_t));
1892 }
1893
1894 /*
1895 * Write all even or odd labels to all leaves of the specified vdev.
1896 */
1897 static void
vdev_label_sync(zio_t * zio,uint64_t * good_writes,vdev_t * vd,int l,uint64_t txg,int flags)1898 vdev_label_sync(zio_t *zio, uint64_t *good_writes,
1899 vdev_t *vd, int l, uint64_t txg, int flags)
1900 {
1901 nvlist_t *label;
1902 vdev_phys_t *vp;
1903 abd_t *vp_abd;
1904 char *buf;
1905 size_t buflen;
1906 vdev_t *pvd = vd->vdev_parent;
1907 boolean_t spare_in_use = B_FALSE;
1908
1909 for (int c = 0; c < vd->vdev_children; c++) {
1910 vdev_label_sync(zio, good_writes,
1911 vd->vdev_child[c], l, txg, flags);
1912 }
1913
1914 if (!vd->vdev_ops->vdev_op_leaf)
1915 return;
1916
1917 if (!vdev_writeable(vd))
1918 return;
1919
1920 /*
1921 * The top-level config never needs to be written to a distributed
1922 * spare. When read vdev_dspare_label_read_config() will generate
1923 * the config for the vdev_label_read_config().
1924 */
1925 if (vd->vdev_ops == &vdev_draid_spare_ops)
1926 return;
1927
1928 if (pvd && pvd->vdev_ops == &vdev_spare_ops)
1929 spare_in_use = B_TRUE;
1930
1931 /*
1932 * Generate a label describing the top-level config to which we belong.
1933 */
1934 if ((vd->vdev_isspare && !spare_in_use) || vd->vdev_isl2cache) {
1935 label = vdev_aux_label_generate(vd, vd->vdev_isspare);
1936 } else {
1937 label = spa_config_generate(vd->vdev_spa, vd, txg, B_FALSE);
1938 }
1939
1940 vp_abd = abd_alloc_linear(sizeof (vdev_phys_t), B_TRUE);
1941 abd_zero(vp_abd, sizeof (vdev_phys_t));
1942 vp = abd_to_buf(vp_abd);
1943
1944 buf = vp->vp_nvlist;
1945 buflen = sizeof (vp->vp_nvlist);
1946
1947 if (!nvlist_pack(label, &buf, &buflen, NV_ENCODE_XDR, KM_SLEEP)) {
1948 for (; l < VDEV_LABELS; l += 2) {
1949 vdev_label_write(zio, vd, l, vp_abd,
1950 offsetof(vdev_label_t, vl_vdev_phys),
1951 sizeof (vdev_phys_t),
1952 vdev_label_sync_done, good_writes,
1953 flags | ZIO_FLAG_DONT_PROPAGATE);
1954 }
1955 }
1956
1957 abd_free(vp_abd);
1958 nvlist_free(label);
1959 }
1960
1961 static int
vdev_label_sync_list(spa_t * spa,int l,uint64_t txg,int flags)1962 vdev_label_sync_list(spa_t *spa, int l, uint64_t txg, int flags)
1963 {
1964 list_t *dl = &spa->spa_config_dirty_list;
1965 vdev_t *vd;
1966 zio_t *zio;
1967 int error;
1968
1969 /*
1970 * Write the new labels to disk.
1971 */
1972 zio = zio_root(spa, NULL, NULL, flags);
1973
1974 for (vd = list_head(dl); vd != NULL; vd = list_next(dl, vd)) {
1975 uint64_t *good_writes;
1976
1977 ASSERT(!vd->vdev_ishole);
1978
1979 good_writes = kmem_zalloc(sizeof (uint64_t), KM_SLEEP);
1980 zio_t *vio = zio_null(zio, spa, NULL,
1981 (vd->vdev_islog || vd->vdev_aux != NULL) ?
1982 vdev_label_sync_ignore_done : vdev_label_sync_top_done,
1983 good_writes, flags);
1984 vdev_label_sync(vio, good_writes, vd, l, txg, flags);
1985 zio_nowait(vio);
1986 }
1987
1988 /*
1989 * AUX path may have changed during import
1990 */
1991 spa_aux_vdev_t *sav[2] = {&spa->spa_spares, &spa->spa_l2cache};
1992 for (int i = 0; i < 2; i++) {
1993 for (int v = 0; v < sav[i]->sav_count; v++) {
1994 uint64_t *good_writes;
1995 if (!sav[i]->sav_label_sync)
1996 continue;
1997 good_writes = kmem_zalloc(sizeof (uint64_t), KM_SLEEP);
1998 zio_t *vio = zio_null(zio, spa, NULL,
1999 vdev_label_sync_ignore_done, good_writes, flags);
2000 vdev_label_sync(vio, good_writes, sav[i]->sav_vdevs[v],
2001 l, txg, flags);
2002 zio_nowait(vio);
2003 }
2004 }
2005
2006 error = zio_wait(zio);
2007
2008 /*
2009 * Flush the new labels to disk.
2010 */
2011 zio = zio_root(spa, NULL, NULL, flags);
2012
2013 for (vd = list_head(dl); vd != NULL; vd = list_next(dl, vd))
2014 zio_flush(zio, vd);
2015
2016 for (int i = 0; i < 2; i++) {
2017 if (!sav[i]->sav_label_sync)
2018 continue;
2019 for (int v = 0; v < sav[i]->sav_count; v++)
2020 zio_flush(zio, sav[i]->sav_vdevs[v]);
2021 if (l == 1)
2022 sav[i]->sav_label_sync = B_FALSE;
2023 }
2024
2025 (void) zio_wait(zio);
2026
2027 return (error);
2028 }
2029
2030 /*
2031 * Sync the uberblock and any changes to the vdev configuration.
2032 *
2033 * The order of operations is carefully crafted to ensure that
2034 * if the system panics or loses power at any time, the state on disk
2035 * is still transactionally consistent. The in-line comments below
2036 * describe the failure semantics at each stage.
2037 *
2038 * Moreover, vdev_config_sync() is designed to be idempotent: if it fails
2039 * at any time, you can just call it again, and it will resume its work.
2040 */
2041 int
vdev_config_sync(vdev_t ** svd,int svdcount,uint64_t txg)2042 vdev_config_sync(vdev_t **svd, int svdcount, uint64_t txg)
2043 {
2044 spa_t *spa = svd[0]->vdev_spa;
2045 uberblock_t *ub = &spa->spa_uberblock;
2046 int error = 0;
2047 int flags = ZIO_FLAG_CONFIG_WRITER | ZIO_FLAG_CANFAIL;
2048
2049 ASSERT(svdcount != 0);
2050 retry:
2051 /*
2052 * Normally, we don't want to try too hard to write every label and
2053 * uberblock. If there is a flaky disk, we don't want the rest of the
2054 * sync process to block while we retry. But if we can't write a
2055 * single label out, we should retry with ZIO_FLAG_TRYHARD before
2056 * bailing out and declaring the pool faulted.
2057 */
2058 if (error != 0) {
2059 if ((flags & ZIO_FLAG_TRYHARD) != 0)
2060 return (error);
2061 flags |= ZIO_FLAG_TRYHARD;
2062 }
2063
2064 ASSERT(ub->ub_txg <= txg);
2065
2066 /*
2067 * If this isn't a resync due to I/O errors,
2068 * and nothing changed in this transaction group,
2069 * and multihost protection isn't enabled,
2070 * and the vdev configuration hasn't changed,
2071 * then there's nothing to do.
2072 */
2073 if (ub->ub_txg < txg) {
2074 boolean_t changed = uberblock_update(ub, spa->spa_root_vdev,
2075 txg, spa->spa_mmp.mmp_delay);
2076
2077 if (!changed && list_is_empty(&spa->spa_config_dirty_list) &&
2078 !spa_multihost(spa))
2079 return (0);
2080 }
2081
2082 if (txg > spa_freeze_txg(spa))
2083 return (0);
2084
2085 ASSERT(txg <= spa->spa_final_txg);
2086
2087 /*
2088 * Flush the write cache of every disk that's been written to
2089 * in this transaction group. This ensures that all blocks
2090 * written in this txg will be committed to stable storage
2091 * before any uberblock that references them.
2092 */
2093 zio_t *zio = zio_root(spa, NULL, NULL, flags);
2094
2095 for (vdev_t *vd =
2096 txg_list_head(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)); vd != NULL;
2097 vd = txg_list_next(&spa->spa_vdev_txg_list, vd, TXG_CLEAN(txg)))
2098 zio_flush(zio, vd);
2099
2100 (void) zio_wait(zio);
2101
2102 /*
2103 * Sync out the even labels (L0, L2) for every dirty vdev. If the
2104 * system dies in the middle of this process, that's OK: all of the
2105 * even labels that made it to disk will be newer than any uberblock,
2106 * and will therefore be considered invalid. The odd labels (L1, L3),
2107 * which have not yet been touched, will still be valid. We flush
2108 * the new labels to disk to ensure that all even-label updates
2109 * are committed to stable storage before the uberblock update.
2110 */
2111 if ((error = vdev_label_sync_list(spa, 0, txg, flags)) != 0) {
2112 if ((flags & ZIO_FLAG_TRYHARD) != 0) {
2113 zfs_dbgmsg("vdev_label_sync_list() returned error %d "
2114 "for pool '%s' when syncing out the even labels "
2115 "of dirty vdevs", error, spa_name(spa));
2116 }
2117 goto retry;
2118 }
2119
2120 /*
2121 * Sync the uberblocks to all vdevs in svd[].
2122 * If the system dies in the middle of this step, there are two cases
2123 * to consider, and the on-disk state is consistent either way:
2124 *
2125 * (1) If none of the new uberblocks made it to disk, then the
2126 * previous uberblock will be the newest, and the odd labels
2127 * (which had not yet been touched) will be valid with respect
2128 * to that uberblock.
2129 *
2130 * (2) If one or more new uberblocks made it to disk, then they
2131 * will be the newest, and the even labels (which had all
2132 * been successfully committed) will be valid with respect
2133 * to the new uberblocks.
2134 */
2135 if ((error = vdev_uberblock_sync_list(svd, svdcount, ub, flags)) != 0) {
2136 if ((flags & ZIO_FLAG_TRYHARD) != 0) {
2137 zfs_dbgmsg("vdev_uberblock_sync_list() returned error "
2138 "%d for pool '%s'", error, spa_name(spa));
2139 }
2140 goto retry;
2141 }
2142
2143 if (spa_multihost(spa))
2144 mmp_update_uberblock(spa, ub);
2145
2146 /*
2147 * Sync out odd labels for every dirty vdev. If the system dies
2148 * in the middle of this process, the even labels and the new
2149 * uberblocks will suffice to open the pool. The next time
2150 * the pool is opened, the first thing we'll do -- before any
2151 * user data is modified -- is mark every vdev dirty so that
2152 * all labels will be brought up to date. We flush the new labels
2153 * to disk to ensure that all odd-label updates are committed to
2154 * stable storage before the next transaction group begins.
2155 */
2156 if ((error = vdev_label_sync_list(spa, 1, txg, flags)) != 0) {
2157 if ((flags & ZIO_FLAG_TRYHARD) != 0) {
2158 zfs_dbgmsg("vdev_label_sync_list() returned error %d "
2159 "for pool '%s' when syncing out the odd labels of "
2160 "dirty vdevs", error, spa_name(spa));
2161 }
2162 goto retry;
2163 }
2164
2165 return (0);
2166 }
2167