xref: /illumos-gate/usr/src/uts/common/fs/zfs/vdev_mirror.c (revision ac04831df9010f533275633d3bb9829b86c171d3)
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  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
28  * Copyright 2019 Joyent, Inc.
29  */
30 
31 #include <sys/zfs_context.h>
32 #include <sys/spa.h>
33 #include <sys/spa_impl.h>
34 #include <sys/dsl_pool.h>
35 #include <sys/dsl_scan.h>
36 #include <sys/vdev_impl.h>
37 #include <sys/zio.h>
38 #include <sys/abd.h>
39 #include <sys/fs/zfs.h>
40 
41 /*
42  * Vdev mirror kstats
43  */
44 static kstat_t *mirror_ksp = NULL;
45 
46 typedef struct mirror_stats {
47 	kstat_named_t vdev_mirror_stat_rotating_linear;
48 	kstat_named_t vdev_mirror_stat_rotating_offset;
49 	kstat_named_t vdev_mirror_stat_rotating_seek;
50 	kstat_named_t vdev_mirror_stat_non_rotating_linear;
51 	kstat_named_t vdev_mirror_stat_non_rotating_seek;
52 
53 	kstat_named_t vdev_mirror_stat_preferred_found;
54 	kstat_named_t vdev_mirror_stat_preferred_not_found;
55 } mirror_stats_t;
56 
57 static mirror_stats_t mirror_stats = {
58 	/* New I/O follows directly the last I/O */
59 	{ "rotating_linear",			KSTAT_DATA_UINT64 },
60 	/* New I/O is within zfs_vdev_mirror_rotating_seek_offset of the last */
61 	{ "rotating_offset",			KSTAT_DATA_UINT64 },
62 	/* New I/O requires random seek */
63 	{ "rotating_seek",			KSTAT_DATA_UINT64 },
64 	/* New I/O follows directly the last I/O  (nonrot) */
65 	{ "non_rotating_linear",		KSTAT_DATA_UINT64 },
66 	/* New I/O requires random seek (nonrot) */
67 	{ "non_rotating_seek",			KSTAT_DATA_UINT64 },
68 	/* Preferred child vdev found */
69 	{ "preferred_found",			KSTAT_DATA_UINT64 },
70 	/* Preferred child vdev not found or equal load  */
71 	{ "preferred_not_found",		KSTAT_DATA_UINT64 },
72 
73 };
74 
75 #define	MIRROR_STAT(stat)		(mirror_stats.stat.value.ui64)
76 #define	MIRROR_INCR(stat, val)		atomic_add_64(&MIRROR_STAT(stat), val)
77 #define	MIRROR_BUMP(stat)		MIRROR_INCR(stat, 1)
78 
79 void
vdev_mirror_stat_init(void)80 vdev_mirror_stat_init(void)
81 {
82 	mirror_ksp = kstat_create("zfs", 0, "vdev_mirror_stats",
83 	    "misc", KSTAT_TYPE_NAMED,
84 	    sizeof (mirror_stats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL);
85 	if (mirror_ksp != NULL) {
86 		mirror_ksp->ks_data = &mirror_stats;
87 		kstat_install(mirror_ksp);
88 	}
89 }
90 
91 void
vdev_mirror_stat_fini(void)92 vdev_mirror_stat_fini(void)
93 {
94 	if (mirror_ksp != NULL) {
95 		kstat_delete(mirror_ksp);
96 		mirror_ksp = NULL;
97 	}
98 }
99 
100 /*
101  * Virtual device vector for mirroring.
102  */
103 
104 typedef struct mirror_child {
105 	vdev_t		*mc_vd;
106 	uint64_t	mc_offset;
107 	int		mc_error;
108 	int		mc_load;
109 	uint8_t		mc_tried;
110 	uint8_t		mc_skipped;
111 	uint8_t		mc_speculative;
112 } mirror_child_t;
113 
114 typedef struct mirror_map {
115 	int		*mm_preferred;
116 	int		mm_preferred_cnt;
117 	int		mm_children;
118 	int		mm_resilvering;
119 	int		mm_root;
120 	mirror_child_t	mm_child[];
121 } mirror_map_t;
122 
123 int vdev_mirror_shift = 21;
124 
125 /*
126  * The load configuration settings below are tuned by default for
127  * the case where all devices are of the same rotational type.
128  *
129  * If there is a mixture of rotating and non-rotating media, setting
130  * zfs_vdev_mirror_non_rotating_seek_inc to 0 may well provide better results
131  * as it will direct more reads to the non-rotating vdevs which are more likely
132  * to have a higher performance.
133  */
134 
135 /* Rotating media load calculation configuration. */
136 static int zfs_vdev_mirror_rotating_inc = 0;
137 static int zfs_vdev_mirror_rotating_seek_inc = 5;
138 static int zfs_vdev_mirror_rotating_seek_offset = 1 * 1024 * 1024;
139 
140 /* Non-rotating media load calculation configuration. */
141 static int zfs_vdev_mirror_non_rotating_inc = 0;
142 static int zfs_vdev_mirror_non_rotating_seek_inc = 1;
143 
144 static inline size_t
vdev_mirror_map_size(int children)145 vdev_mirror_map_size(int children)
146 {
147 	return (offsetof(mirror_map_t, mm_child[children]) +
148 	    sizeof (int) * children);
149 }
150 
151 static inline mirror_map_t *
vdev_mirror_map_alloc(int children,boolean_t resilvering,boolean_t root)152 vdev_mirror_map_alloc(int children, boolean_t resilvering, boolean_t root)
153 {
154 	mirror_map_t *mm;
155 
156 	mm = kmem_zalloc(vdev_mirror_map_size(children), KM_SLEEP);
157 	mm->mm_children = children;
158 	mm->mm_resilvering = resilvering;
159 	mm->mm_root = root;
160 	mm->mm_preferred = (int *)((uintptr_t)mm +
161 	    offsetof(mirror_map_t, mm_child[children]));
162 
163 	return (mm);
164 }
165 
166 static void
vdev_mirror_map_free(zio_t * zio)167 vdev_mirror_map_free(zio_t *zio)
168 {
169 	mirror_map_t *mm = zio->io_vsd;
170 
171 	kmem_free(mm, vdev_mirror_map_size(mm->mm_children));
172 }
173 
174 static const zio_vsd_ops_t vdev_mirror_vsd_ops = {
175 	.vsd_free = vdev_mirror_map_free,
176 	.vsd_cksum_report = zio_vsd_default_cksum_report
177 };
178 
179 static int
vdev_mirror_load(mirror_map_t * mm,vdev_t * vd,uint64_t zio_offset)180 vdev_mirror_load(mirror_map_t *mm, vdev_t *vd, uint64_t zio_offset)
181 {
182 	uint64_t last_offset;
183 	int64_t offset_diff;
184 	int load;
185 
186 	/* All DVAs have equal weight at the root. */
187 	if (mm->mm_root)
188 		return (INT_MAX);
189 
190 	/*
191 	 * We don't return INT_MAX if the device is resilvering i.e.
192 	 * vdev_resilver_txg != 0 as when tested performance was slightly
193 	 * worse overall when resilvering with compared to without.
194 	 */
195 
196 	/* Fix zio_offset for leaf vdevs */
197 	if (vd->vdev_ops->vdev_op_leaf)
198 		zio_offset += VDEV_LABEL_START_SIZE;
199 
200 	/* Standard load based on pending queue length. */
201 	load = vdev_queue_length(vd);
202 	last_offset = vdev_queue_last_offset(vd);
203 
204 	if (vd->vdev_nonrot) {
205 		/* Non-rotating media. */
206 		if (last_offset == zio_offset) {
207 			MIRROR_BUMP(vdev_mirror_stat_non_rotating_linear);
208 			return (load + zfs_vdev_mirror_non_rotating_inc);
209 		}
210 
211 		/*
212 		 * Apply a seek penalty even for non-rotating devices as
213 		 * sequential I/O's can be aggregated into fewer operations on
214 		 * the device, thus avoiding unnecessary per-command overhead
215 		 * and boosting performance.
216 		 */
217 		MIRROR_BUMP(vdev_mirror_stat_non_rotating_seek);
218 		return (load + zfs_vdev_mirror_non_rotating_seek_inc);
219 	}
220 
221 	/* Rotating media I/O's which directly follow the last I/O. */
222 	if (last_offset == zio_offset) {
223 		MIRROR_BUMP(vdev_mirror_stat_rotating_linear);
224 		return (load + zfs_vdev_mirror_rotating_inc);
225 	}
226 
227 	/*
228 	 * Apply half the seek increment to I/O's within seek offset
229 	 * of the last I/O issued to this vdev as they should incur less
230 	 * of a seek increment.
231 	 */
232 	offset_diff = (int64_t)(last_offset - zio_offset);
233 	if (ABS(offset_diff) < zfs_vdev_mirror_rotating_seek_offset) {
234 		MIRROR_BUMP(vdev_mirror_stat_rotating_offset);
235 		return (load + (zfs_vdev_mirror_rotating_seek_inc / 2));
236 	}
237 
238 	/* Apply the full seek increment to all other I/O's. */
239 	MIRROR_BUMP(vdev_mirror_stat_rotating_seek);
240 	return (load + zfs_vdev_mirror_rotating_seek_inc);
241 }
242 
243 static mirror_map_t *
vdev_mirror_map_init(zio_t * zio)244 vdev_mirror_map_init(zio_t *zio)
245 {
246 	mirror_map_t *mm = NULL;
247 	mirror_child_t *mc;
248 	vdev_t *vd = zio->io_vd;
249 	int c;
250 
251 	if (vd == NULL) {
252 		dva_t *dva = zio->io_bp->blk_dva;
253 		spa_t *spa = zio->io_spa;
254 		dsl_scan_t *scn = NULL;
255 		dva_t dva_copy[SPA_DVAS_PER_BP];
256 
257 		if (spa->spa_dsl_pool != NULL) {
258 			scn = spa->spa_dsl_pool->dp_scan;
259 		}
260 		/*
261 		 * The sequential scrub code sorts and issues all DVAs
262 		 * of a bp separately. Each of these IOs includes all
263 		 * original DVA copies so that repairs can be performed
264 		 * in the event of an error, but we only actually want
265 		 * to check the first DVA since the others will be
266 		 * checked by their respective sorted IOs. Only if we
267 		 * hit an error will we try all DVAs upon retrying.
268 		 *
269 		 * Note: This check is safe even if the user switches
270 		 * from a legacy scrub to a sequential one in the middle
271 		 * of processing, since scn_is_sorted isn't updated until
272 		 * all outstanding IOs from the previous scrub pass
273 		 * complete.
274 		 */
275 		if ((zio->io_flags & ZIO_FLAG_SCRUB) &&
276 		    !(zio->io_flags & ZIO_FLAG_IO_RETRY) &&
277 		    scn != NULL &&
278 		    scn->scn_is_sorted &&
279 		    dsl_scan_scrubbing(spa->spa_dsl_pool)) {
280 			c = 1;
281 		} else {
282 			c = BP_GET_NDVAS(zio->io_bp);
283 		}
284 
285 		/*
286 		 * If we do not trust the pool config, some DVAs might be
287 		 * invalid or point to vdevs that do not exist. We skip them.
288 		 */
289 		if (!spa_trust_config(spa)) {
290 			ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
291 			int j = 0;
292 			for (int i = 0; i < c; i++) {
293 				if (zfs_dva_valid(spa, &dva[i], zio->io_bp))
294 					dva_copy[j++] = dva[i];
295 			}
296 			if (j == 0) {
297 				zio->io_vsd = NULL;
298 				zio->io_error = ENXIO;
299 				return (NULL);
300 			}
301 			if (j < c) {
302 				dva = dva_copy;
303 				c = j;
304 			}
305 		}
306 
307 		mm = vdev_mirror_map_alloc(c, B_FALSE, B_TRUE);
308 		for (c = 0; c < mm->mm_children; c++) {
309 			mc = &mm->mm_child[c];
310 
311 			mc->mc_vd = vdev_lookup_top(spa, DVA_GET_VDEV(&dva[c]));
312 			mc->mc_offset = DVA_GET_OFFSET(&dva[c]);
313 		}
314 	} else {
315 		/*
316 		 * If we are resilvering, then we should handle scrub reads
317 		 * differently; we shouldn't issue them to the resilvering
318 		 * device because it might not have those blocks.
319 		 *
320 		 * We are resilvering iff:
321 		 * 1) We are a replacing vdev (ie our name is "replacing-1" or
322 		 *    "spare-1" or something like that), and
323 		 * 2) The pool is currently being resilvered.
324 		 *
325 		 * We cannot simply check vd->vdev_resilver_txg, because it's
326 		 * not set in this path.
327 		 *
328 		 * Nor can we just check our vdev_ops; there are cases (such as
329 		 * when a user types "zpool replace pool odev spare_dev" and
330 		 * spare_dev is in the spare list, or when a spare device is
331 		 * automatically used to replace a DEGRADED device) when
332 		 * resilvering is complete but both the original vdev and the
333 		 * spare vdev remain in the pool.  That behavior is intentional.
334 		 * It helps implement the policy that a spare should be
335 		 * automatically removed from the pool after the user replaces
336 		 * the device that originally failed.
337 		 */
338 		boolean_t replacing = (vd->vdev_ops == &vdev_replacing_ops ||
339 		    vd->vdev_ops == &vdev_spare_ops) &&
340 		    spa_load_state(vd->vdev_spa) == SPA_LOAD_NONE &&
341 		    dsl_scan_resilvering(vd->vdev_spa->spa_dsl_pool);
342 		mm = vdev_mirror_map_alloc(vd->vdev_children, replacing,
343 		    B_FALSE);
344 		for (c = 0; c < mm->mm_children; c++) {
345 			mc = &mm->mm_child[c];
346 			mc->mc_vd = vd->vdev_child[c];
347 			mc->mc_offset = zio->io_offset;
348 		}
349 	}
350 
351 	zio->io_vsd = mm;
352 	zio->io_vsd_ops = &vdev_mirror_vsd_ops;
353 	return (mm);
354 }
355 
356 static int
vdev_mirror_open(vdev_t * vd,uint64_t * asize,uint64_t * max_asize,uint64_t * ashift)357 vdev_mirror_open(vdev_t *vd, uint64_t *asize, uint64_t *max_asize,
358     uint64_t *ashift)
359 {
360 	int numerrors = 0;
361 	int lasterror = 0;
362 
363 	if (vd->vdev_children == 0) {
364 		vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
365 		return (SET_ERROR(EINVAL));
366 	}
367 
368 	vdev_open_children(vd);
369 
370 	for (int c = 0; c < vd->vdev_children; c++) {
371 		vdev_t *cvd = vd->vdev_child[c];
372 
373 		if (cvd->vdev_open_error) {
374 			lasterror = cvd->vdev_open_error;
375 			numerrors++;
376 			continue;
377 		}
378 
379 		*asize = MIN(*asize - 1, cvd->vdev_asize - 1) + 1;
380 		*max_asize = MIN(*max_asize - 1, cvd->vdev_max_asize - 1) + 1;
381 		*ashift = MAX(*ashift, cvd->vdev_ashift);
382 	}
383 
384 	if (numerrors == vd->vdev_children) {
385 		if (vdev_children_are_offline(vd))
386 			vd->vdev_stat.vs_aux = VDEV_AUX_CHILDREN_OFFLINE;
387 		else
388 			vd->vdev_stat.vs_aux = VDEV_AUX_NO_REPLICAS;
389 		return (lasterror);
390 	}
391 
392 	return (0);
393 }
394 
395 static void
vdev_mirror_close(vdev_t * vd)396 vdev_mirror_close(vdev_t *vd)
397 {
398 	for (int c = 0; c < vd->vdev_children; c++)
399 		vdev_close(vd->vdev_child[c]);
400 }
401 
402 static void
vdev_mirror_child_done(zio_t * zio)403 vdev_mirror_child_done(zio_t *zio)
404 {
405 	mirror_child_t *mc = zio->io_private;
406 
407 	mc->mc_error = zio->io_error;
408 	mc->mc_tried = 1;
409 	mc->mc_skipped = 0;
410 }
411 
412 static void
vdev_mirror_scrub_done(zio_t * zio)413 vdev_mirror_scrub_done(zio_t *zio)
414 {
415 	mirror_child_t *mc = zio->io_private;
416 
417 	if (zio->io_error == 0) {
418 		zio_t *pio;
419 		zio_link_t *zl = NULL;
420 
421 		mutex_enter(&zio->io_lock);
422 		while ((pio = zio_walk_parents(zio, &zl)) != NULL) {
423 			mutex_enter(&pio->io_lock);
424 			ASSERT3U(zio->io_size, >=, pio->io_size);
425 			abd_copy(pio->io_abd, zio->io_abd, pio->io_size);
426 			mutex_exit(&pio->io_lock);
427 		}
428 		mutex_exit(&zio->io_lock);
429 	}
430 
431 	abd_free(zio->io_abd);
432 
433 	mc->mc_error = zio->io_error;
434 	mc->mc_tried = 1;
435 	mc->mc_skipped = 0;
436 }
437 
438 /*
439  * Check the other, lower-index DVAs to see if they're on the same
440  * vdev as the child we picked.  If they are, use them since they
441  * are likely to have been allocated from the primary metaslab in
442  * use at the time, and hence are more likely to have locality with
443  * single-copy data.
444  */
445 static int
vdev_mirror_dva_select(zio_t * zio,int p)446 vdev_mirror_dva_select(zio_t *zio, int p)
447 {
448 	dva_t *dva = zio->io_bp->blk_dva;
449 	mirror_map_t *mm = zio->io_vsd;
450 	int preferred;
451 	int c;
452 
453 	preferred = mm->mm_preferred[p];
454 	for (p--; p >= 0; p--) {
455 		c = mm->mm_preferred[p];
456 		if (DVA_GET_VDEV(&dva[c]) == DVA_GET_VDEV(&dva[preferred]))
457 			preferred = c;
458 	}
459 	return (preferred);
460 }
461 
462 static int
vdev_mirror_preferred_child_randomize(zio_t * zio)463 vdev_mirror_preferred_child_randomize(zio_t *zio)
464 {
465 	mirror_map_t *mm = zio->io_vsd;
466 	int p;
467 
468 	if (mm->mm_root) {
469 		p = spa_get_random(mm->mm_preferred_cnt);
470 		return (vdev_mirror_dva_select(zio, p));
471 	}
472 
473 	/*
474 	 * To ensure we don't always favour the first matching vdev,
475 	 * which could lead to wear leveling issues on SSD's, we
476 	 * use the I/O offset as a pseudo random seed into the vdevs
477 	 * which have the lowest load.
478 	 */
479 	p = (zio->io_offset >> vdev_mirror_shift) % mm->mm_preferred_cnt;
480 	return (mm->mm_preferred[p]);
481 }
482 
483 /*
484  * Try to find a vdev whose DTL doesn't contain the block we want to read
485  * prefering vdevs based on determined load.
486  *
487  * Try to find a child whose DTL doesn't contain the block we want to read.
488  * If we can't, try the read on any vdev we haven't already tried.
489  */
490 static int
vdev_mirror_child_select(zio_t * zio)491 vdev_mirror_child_select(zio_t *zio)
492 {
493 	mirror_map_t *mm = zio->io_vsd;
494 	uint64_t txg = zio->io_txg;
495 	int c, lowest_load;
496 
497 	ASSERT(zio->io_bp == NULL || BP_PHYSICAL_BIRTH(zio->io_bp) == txg);
498 
499 	lowest_load = INT_MAX;
500 	mm->mm_preferred_cnt = 0;
501 	for (c = 0; c < mm->mm_children; c++) {
502 		mirror_child_t *mc;
503 
504 		mc = &mm->mm_child[c];
505 		if (mc->mc_tried || mc->mc_skipped)
506 			continue;
507 
508 		if (mc->mc_vd == NULL || !vdev_readable(mc->mc_vd)) {
509 			mc->mc_error = SET_ERROR(ENXIO);
510 			mc->mc_tried = 1;	/* don't even try */
511 			mc->mc_skipped = 1;
512 			continue;
513 		}
514 
515 		if (vdev_dtl_contains(mc->mc_vd, DTL_MISSING, txg, 1)) {
516 			mc->mc_error = SET_ERROR(ESTALE);
517 			mc->mc_skipped = 1;
518 			mc->mc_speculative = 1;
519 			continue;
520 		}
521 
522 		mc->mc_load = vdev_mirror_load(mm, mc->mc_vd, mc->mc_offset);
523 		if (mc->mc_load > lowest_load)
524 			continue;
525 
526 		if (mc->mc_load < lowest_load) {
527 			lowest_load = mc->mc_load;
528 			mm->mm_preferred_cnt = 0;
529 		}
530 		mm->mm_preferred[mm->mm_preferred_cnt] = c;
531 		mm->mm_preferred_cnt++;
532 	}
533 
534 	if (mm->mm_preferred_cnt == 1) {
535 		MIRROR_BUMP(vdev_mirror_stat_preferred_found);
536 		return (mm->mm_preferred[0]);
537 	}
538 
539 	if (mm->mm_preferred_cnt > 1) {
540 		MIRROR_BUMP(vdev_mirror_stat_preferred_not_found);
541 		return (vdev_mirror_preferred_child_randomize(zio));
542 	}
543 
544 	/*
545 	 * Every device is either missing or has this txg in its DTL.
546 	 * Look for any child we haven't already tried before giving up.
547 	 */
548 	for (c = 0; c < mm->mm_children; c++) {
549 		if (!mm->mm_child[c].mc_tried)
550 			return (c);
551 	}
552 
553 	/*
554 	 * Every child failed.  There's no place left to look.
555 	 */
556 	return (-1);
557 }
558 
559 static void
vdev_mirror_io_start(zio_t * zio)560 vdev_mirror_io_start(zio_t *zio)
561 {
562 	mirror_map_t *mm;
563 	mirror_child_t *mc;
564 	int c, children;
565 
566 	mm = vdev_mirror_map_init(zio);
567 
568 	if (mm == NULL) {
569 		ASSERT(!spa_trust_config(zio->io_spa));
570 		ASSERT(zio->io_type == ZIO_TYPE_READ);
571 		zio_execute(zio);
572 		return;
573 	}
574 
575 	if (zio->io_type == ZIO_TYPE_READ) {
576 		if (zio->io_bp != NULL &&
577 		    (zio->io_flags & ZIO_FLAG_SCRUB) && !mm->mm_resilvering) {
578 			/*
579 			 * For scrubbing reads (if we can verify the
580 			 * checksum here, as indicated by io_bp being
581 			 * non-NULL) we need to allocate a read buffer for
582 			 * each child and issue reads to all children.  If
583 			 * any child succeeds, it will copy its data into
584 			 * zio->io_data in vdev_mirror_scrub_done.
585 			 */
586 			for (c = 0; c < mm->mm_children; c++) {
587 				mc = &mm->mm_child[c];
588 				zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
589 				    mc->mc_vd, mc->mc_offset,
590 				    abd_alloc_sametype(zio->io_abd,
591 				    zio->io_size), zio->io_size,
592 				    zio->io_type, zio->io_priority, 0,
593 				    vdev_mirror_scrub_done, mc));
594 			}
595 			zio_execute(zio);
596 			return;
597 		}
598 		/*
599 		 * For normal reads just pick one child.
600 		 */
601 		c = vdev_mirror_child_select(zio);
602 		children = (c >= 0);
603 	} else {
604 		ASSERT(zio->io_type == ZIO_TYPE_WRITE);
605 
606 		/*
607 		 * Writes go to all children.
608 		 */
609 		c = 0;
610 		children = mm->mm_children;
611 	}
612 
613 	while (children--) {
614 		mc = &mm->mm_child[c];
615 		zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
616 		    mc->mc_vd, mc->mc_offset, zio->io_abd, zio->io_size,
617 		    zio->io_type, zio->io_priority, 0,
618 		    vdev_mirror_child_done, mc));
619 		c++;
620 	}
621 
622 	zio_execute(zio);
623 }
624 
625 static int
vdev_mirror_worst_error(mirror_map_t * mm)626 vdev_mirror_worst_error(mirror_map_t *mm)
627 {
628 	int error[2] = { 0, 0 };
629 
630 	for (int c = 0; c < mm->mm_children; c++) {
631 		mirror_child_t *mc = &mm->mm_child[c];
632 		int s = mc->mc_speculative;
633 		error[s] = zio_worst_error(error[s], mc->mc_error);
634 	}
635 
636 	return (error[0] ? error[0] : error[1]);
637 }
638 
639 static void
vdev_mirror_io_done(zio_t * zio)640 vdev_mirror_io_done(zio_t *zio)
641 {
642 	mirror_map_t *mm = zio->io_vsd;
643 	mirror_child_t *mc;
644 	int c;
645 	int good_copies = 0;
646 	int unexpected_errors = 0;
647 
648 	if (mm == NULL)
649 		return;
650 
651 	for (c = 0; c < mm->mm_children; c++) {
652 		mc = &mm->mm_child[c];
653 
654 		if (mc->mc_error) {
655 			if (!mc->mc_skipped)
656 				unexpected_errors++;
657 		} else if (mc->mc_tried) {
658 			good_copies++;
659 		}
660 	}
661 
662 	if (zio->io_type == ZIO_TYPE_WRITE) {
663 		/*
664 		 * XXX -- for now, treat partial writes as success.
665 		 *
666 		 * Now that we support write reallocation, it would be better
667 		 * to treat partial failure as real failure unless there are
668 		 * no non-degraded top-level vdevs left, and not update DTLs
669 		 * if we intend to reallocate.
670 		 */
671 		/* XXPOLICY */
672 		if (good_copies != mm->mm_children) {
673 			/*
674 			 * Always require at least one good copy.
675 			 *
676 			 * For ditto blocks (io_vd == NULL), require
677 			 * all copies to be good.
678 			 *
679 			 * XXX -- for replacing vdevs, there's no great answer.
680 			 * If the old device is really dead, we may not even
681 			 * be able to access it -- so we only want to
682 			 * require good writes to the new device.  But if
683 			 * the new device turns out to be flaky, we want
684 			 * to be able to detach it -- which requires all
685 			 * writes to the old device to have succeeded.
686 			 */
687 			if (good_copies == 0 || zio->io_vd == NULL)
688 				zio->io_error = vdev_mirror_worst_error(mm);
689 		}
690 		return;
691 	}
692 
693 	ASSERT(zio->io_type == ZIO_TYPE_READ);
694 
695 	/*
696 	 * If we don't have a good copy yet, keep trying other children.
697 	 */
698 	/* XXPOLICY */
699 	if (good_copies == 0 && (c = vdev_mirror_child_select(zio)) != -1) {
700 		ASSERT(c >= 0 && c < mm->mm_children);
701 		mc = &mm->mm_child[c];
702 		zio_vdev_io_redone(zio);
703 		zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
704 		    mc->mc_vd, mc->mc_offset, zio->io_abd, zio->io_size,
705 		    ZIO_TYPE_READ, zio->io_priority, 0,
706 		    vdev_mirror_child_done, mc));
707 		return;
708 	}
709 
710 	/* XXPOLICY */
711 	if (good_copies == 0) {
712 		zio->io_error = vdev_mirror_worst_error(mm);
713 		ASSERT(zio->io_error != 0);
714 	}
715 
716 	if (good_copies && spa_writeable(zio->io_spa) &&
717 	    (unexpected_errors ||
718 	    (zio->io_flags & ZIO_FLAG_RESILVER) ||
719 	    ((zio->io_flags & ZIO_FLAG_SCRUB) && mm->mm_resilvering))) {
720 		/*
721 		 * Use the good data we have in hand to repair damaged children.
722 		 */
723 		for (c = 0; c < mm->mm_children; c++) {
724 			/*
725 			 * Don't rewrite known good children.
726 			 * Not only is it unnecessary, it could
727 			 * actually be harmful: if the system lost
728 			 * power while rewriting the only good copy,
729 			 * there would be no good copies left!
730 			 */
731 			mc = &mm->mm_child[c];
732 
733 			if (mc->mc_error == 0) {
734 				if (mc->mc_tried)
735 					continue;
736 				/*
737 				 * We didn't try this child.  We need to
738 				 * repair it if:
739 				 * 1. it's a scrub (in which case we have
740 				 * tried everything that was healthy)
741 				 *  - or -
742 				 * 2. it's an indirect vdev (in which case
743 				 * it could point to any other vdev, which
744 				 * might have a bad DTL)
745 				 *  - or -
746 				 * 3. the DTL indicates that this data is
747 				 * missing from this vdev
748 				 */
749 				if (!(zio->io_flags & ZIO_FLAG_SCRUB) &&
750 				    mc->mc_vd->vdev_ops != &vdev_indirect_ops &&
751 				    !vdev_dtl_contains(mc->mc_vd, DTL_PARTIAL,
752 				    zio->io_txg, 1))
753 					continue;
754 				mc->mc_error = SET_ERROR(ESTALE);
755 			}
756 
757 			zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
758 			    mc->mc_vd, mc->mc_offset,
759 			    zio->io_abd, zio->io_size,
760 			    ZIO_TYPE_WRITE, ZIO_PRIORITY_ASYNC_WRITE,
761 			    ZIO_FLAG_IO_REPAIR | (unexpected_errors ?
762 			    ZIO_FLAG_SELF_HEAL : 0), NULL, NULL));
763 		}
764 	}
765 }
766 
767 static void
vdev_mirror_state_change(vdev_t * vd,int faulted,int degraded)768 vdev_mirror_state_change(vdev_t *vd, int faulted, int degraded)
769 {
770 	if (faulted == vd->vdev_children) {
771 		if (vdev_children_are_offline(vd)) {
772 			vdev_set_state(vd, B_FALSE, VDEV_STATE_OFFLINE,
773 			    VDEV_AUX_CHILDREN_OFFLINE);
774 		} else {
775 			vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
776 			    VDEV_AUX_NO_REPLICAS);
777 		}
778 	} else if (degraded + faulted != 0) {
779 		vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED, VDEV_AUX_NONE);
780 	} else {
781 		vdev_set_state(vd, B_FALSE, VDEV_STATE_HEALTHY, VDEV_AUX_NONE);
782 	}
783 }
784 
785 static int
vdev_mirror_dumpio(vdev_t * vd,caddr_t data,size_t size,uint64_t offset,uint64_t origoffset,boolean_t doread,boolean_t isdump)786 vdev_mirror_dumpio(vdev_t *vd, caddr_t data, size_t size,
787     uint64_t offset, uint64_t origoffset, boolean_t doread, boolean_t isdump)
788 {
789 	uint64_t numerrors;
790 	int err = EIO;
791 
792 	for (uint64_t c = 0; c < vd->vdev_children; c++) {
793 		vdev_t *cvd = vd->vdev_child[c];
794 
795 		if (cvd->vdev_ops->vdev_op_dumpio == NULL) {
796 			err = EINVAL;
797 		} else {
798 			err = cvd->vdev_ops->vdev_op_dumpio(cvd, data, size,
799 			    offset, origoffset, doread, isdump);
800 		}
801 		if (err != 0) {
802 			numerrors++;
803 		} else if (doread) {
804 			break;
805 		}
806 	}
807 	if (err != 0) {
808 		return (SET_ERROR(err));
809 	}
810 
811 	return (0);
812 }
813 
814 vdev_ops_t vdev_mirror_ops = {
815 	.vdev_op_open = vdev_mirror_open,
816 	.vdev_op_close = vdev_mirror_close,
817 	.vdev_op_asize = vdev_default_asize,
818 	.vdev_op_io_start = vdev_mirror_io_start,
819 	.vdev_op_io_done = vdev_mirror_io_done,
820 	.vdev_op_state_change = vdev_mirror_state_change,
821 	.vdev_op_need_resilver = NULL,
822 	.vdev_op_hold = NULL,
823 	.vdev_op_rele = NULL,
824 	.vdev_op_remap = NULL,
825 	.vdev_op_xlate = vdev_default_xlate,
826 	.vdev_op_dumpio = vdev_mirror_dumpio,
827 	.vdev_op_type = VDEV_TYPE_MIRROR,	/* name of this vdev type */
828 	.vdev_op_leaf = B_FALSE			/* not a leaf vdev */
829 };
830 
831 vdev_ops_t vdev_replacing_ops = {
832 	.vdev_op_open = vdev_mirror_open,
833 	.vdev_op_close = vdev_mirror_close,
834 	.vdev_op_asize = vdev_default_asize,
835 	.vdev_op_io_start = vdev_mirror_io_start,
836 	.vdev_op_io_done = vdev_mirror_io_done,
837 	.vdev_op_state_change = vdev_mirror_state_change,
838 	.vdev_op_need_resilver = NULL,
839 	.vdev_op_hold = NULL,
840 	.vdev_op_rele = NULL,
841 	.vdev_op_remap = NULL,
842 	.vdev_op_xlate = vdev_default_xlate,
843 	.vdev_op_dumpio = vdev_mirror_dumpio,
844 	.vdev_op_type = VDEV_TYPE_REPLACING,	/* name of this vdev type */
845 	.vdev_op_leaf = B_FALSE			/* not a leaf vdev */
846 };
847 
848 vdev_ops_t vdev_spare_ops = {
849 	.vdev_op_open = vdev_mirror_open,
850 	.vdev_op_close = vdev_mirror_close,
851 	.vdev_op_asize = vdev_default_asize,
852 	.vdev_op_io_start = vdev_mirror_io_start,
853 	.vdev_op_io_done = vdev_mirror_io_done,
854 	.vdev_op_state_change = vdev_mirror_state_change,
855 	.vdev_op_need_resilver = NULL,
856 	.vdev_op_hold = NULL,
857 	.vdev_op_rele = NULL,
858 	.vdev_op_remap = NULL,
859 	.vdev_op_xlate = vdev_default_xlate,
860 	.vdev_op_dumpio = vdev_mirror_dumpio,
861 	.vdev_op_type = VDEV_TYPE_SPARE,	/* name of this vdev type */
862 	.vdev_op_leaf = B_FALSE			/* not a leaf vdev */
863 };
864