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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <sys/zfs_context.h>
30 #include <sys/spa.h>
31 #include <sys/vdev_impl.h>
32 #include <sys/zio.h>
33 #include <sys/fs/zfs.h>
34 
35 /*
36  * Virtual device vector for mirroring.
37  */
38 
39 typedef struct mirror_map {
40 	int	mm_error;
41 	short	mm_tried;
42 	short	mm_skipped;
43 } mirror_map_t;
44 
45 static mirror_map_t *
46 vdev_mirror_map_alloc(zio_t *zio)
47 {
48 	zio->io_vsd = kmem_zalloc(zio->io_vd->vdev_children *
49 	    sizeof (mirror_map_t), KM_SLEEP);
50 	return (zio->io_vsd);
51 }
52 
53 static void
54 vdev_mirror_map_free(zio_t *zio)
55 {
56 	kmem_free(zio->io_vsd,
57 	    zio->io_vd->vdev_children * sizeof (mirror_map_t));
58 	zio->io_vsd = NULL;
59 }
60 
61 static int
62 vdev_mirror_open(vdev_t *vd, uint64_t *asize, uint64_t *ashift)
63 {
64 	vdev_t *cvd;
65 	uint64_t c;
66 	int numerrors = 0;
67 	int ret, lasterror = 0;
68 
69 	if (vd->vdev_children == 0) {
70 		vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
71 		return (EINVAL);
72 	}
73 
74 	for (c = 0; c < vd->vdev_children; c++) {
75 		cvd = vd->vdev_child[c];
76 
77 		if ((ret = vdev_open(cvd)) != 0) {
78 			lasterror = ret;
79 			numerrors++;
80 			continue;
81 		}
82 
83 		*asize = MIN(*asize - 1, cvd->vdev_asize - 1) + 1;
84 		*ashift = cvd->vdev_ashift;
85 	}
86 
87 	if (numerrors == vd->vdev_children) {
88 		vd->vdev_stat.vs_aux = VDEV_AUX_NO_REPLICAS;
89 		return (lasterror);
90 	}
91 
92 	return (0);
93 }
94 
95 static void
96 vdev_mirror_close(vdev_t *vd)
97 {
98 	uint64_t c;
99 
100 	for (c = 0; c < vd->vdev_children; c++)
101 		vdev_close(vd->vdev_child[c]);
102 }
103 
104 static void
105 vdev_mirror_child_done(zio_t *zio)
106 {
107 	mirror_map_t *mm = zio->io_private;
108 
109 	mm->mm_error = zio->io_error;
110 	mm->mm_tried = 1;
111 	mm->mm_skipped = 0;
112 }
113 
114 static void
115 vdev_mirror_scrub_done(zio_t *zio)
116 {
117 	mirror_map_t *mm = zio->io_private;
118 
119 	if (zio->io_error == 0) {
120 		zio_t *pio = zio->io_parent;
121 		mutex_enter(&pio->io_lock);
122 		bcopy(zio->io_data, pio->io_data, pio->io_size);
123 		mutex_exit(&pio->io_lock);
124 	}
125 
126 	zio_buf_free(zio->io_data, zio->io_size);
127 
128 	mm->mm_error = zio->io_error;
129 	mm->mm_tried = 1;
130 	mm->mm_skipped = 0;
131 }
132 
133 /*
134  * Try to find a child whose DTL doesn't contain the block we want to read.
135  * If we can't, try the read on any vdev we haven't already tried.
136  */
137 static int
138 vdev_mirror_child_select(zio_t *zio)
139 {
140 	mirror_map_t *mm = zio->io_vsd;
141 	vdev_t *vd = zio->io_vd;
142 	vdev_t *cvd;
143 	uint64_t txg = zio->io_txg;
144 	int i, c;
145 
146 	ASSERT(zio->io_bp == NULL || zio->io_bp->blk_birth == txg);
147 
148 	/*
149 	 * Select the child we'd like to read from absent any errors.
150 	 * The current policy is to alternate sides at 8M granularity.
151 	 * XXX -- investigate other policies for read distribution.
152 	 */
153 	c = (zio->io_offset >> (SPA_MAXBLOCKSHIFT + 6)) % vd->vdev_children;
154 
155 	/*
156 	 * If this is a replacing vdev, always try child 0 (the source) first.
157 	 */
158 	if (vd->vdev_ops == &vdev_replacing_ops)
159 		c = 0;
160 
161 	/*
162 	 * Try to find a child whose DTL doesn't contain the block to read.
163 	 * If a child is known to be completely inaccessible (indicated by
164 	 * vdev_is_dead() returning B_TRUE), don't even try.
165 	 */
166 	for (i = 0; i < vd->vdev_children; i++, c++) {
167 		if (c >= vd->vdev_children)
168 			c = 0;
169 		if (mm[c].mm_tried || mm[c].mm_skipped)
170 			continue;
171 		cvd = vd->vdev_child[c];
172 		if (vdev_is_dead(cvd)) {
173 			mm[c].mm_error = ENXIO;
174 			mm[c].mm_tried = 1;	/* don't even try */
175 			mm[c].mm_skipped = 1;
176 			continue;
177 		}
178 		if (!vdev_dtl_contains(&cvd->vdev_dtl_map, txg, 1))
179 			return (c);
180 		mm[c].mm_error = ESTALE;
181 		mm[c].mm_skipped = 1;
182 	}
183 
184 	/*
185 	 * Every device is either missing or has this txg in its DTL.
186 	 * If we don't have any sibling replicas to consult, look for
187 	 * any child we haven't already tried before giving up.
188 	 */
189 	if (vd == vd->vdev_top || vd->vdev_parent->vdev_children <= 1) {
190 		for (c = 0; c < vd->vdev_children; c++) {
191 			if (!mm[c].mm_tried)
192 				return (c);
193 		}
194 	}
195 
196 	/*
197 	 * Every child failed.  There's no place left to look.
198 	 */
199 	return (-1);
200 }
201 
202 static void
203 vdev_mirror_io_start(zio_t *zio)
204 {
205 	vdev_t *vd = zio->io_vd;
206 	mirror_map_t *mm;
207 	int c, children;
208 
209 	mm = vdev_mirror_map_alloc(zio);
210 
211 	if (zio->io_type == ZIO_TYPE_READ) {
212 		if (zio->io_flags & ZIO_FLAG_SCRUB) {
213 			/*
214 			 * For scrubbing reads we need to allocate a read
215 			 * buffer for each child and issue reads to all
216 			 * children.  If any child succeeds, it will copy its
217 			 * data into zio->io_data in vdev_mirror_scrub_done.
218 			 */
219 			for (c = 0; c < vd->vdev_children; c++) {
220 				zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
221 				    vd->vdev_child[c], zio->io_offset,
222 				    zio_buf_alloc(zio->io_size), zio->io_size,
223 				    zio->io_type, zio->io_priority,
224 				    ZIO_FLAG_CANFAIL, vdev_mirror_scrub_done,
225 				    &mm[c]));
226 			}
227 			zio_wait_children_done(zio);
228 			return;
229 		}
230 		/*
231 		 * For normal reads just pick one child.
232 		 */
233 		c = vdev_mirror_child_select(zio);
234 		children = (c >= 0);
235 	} else {
236 		ASSERT(zio->io_type == ZIO_TYPE_WRITE);
237 
238 		/*
239 		 * If this is a resilvering I/O to a replacing vdev,
240 		 * only the last child should be written -- unless the
241 		 * first child happens to have a DTL entry here as well.
242 		 * All other writes go to all children.
243 		 */
244 		if ((zio->io_flags & ZIO_FLAG_RESILVER) &&
245 		    vd->vdev_ops == &vdev_replacing_ops &&
246 		    !vdev_dtl_contains(&vd->vdev_child[0]->vdev_dtl_map,
247 		    zio->io_txg, 1)) {
248 			c = vd->vdev_children - 1;
249 			children = 1;
250 		} else {
251 			c = 0;
252 			children = vd->vdev_children;
253 		}
254 	}
255 
256 	while (children--) {
257 		zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
258 		    vd->vdev_child[c], zio->io_offset, zio->io_data,
259 		    zio->io_size, zio->io_type, zio->io_priority,
260 		    ZIO_FLAG_CANFAIL, vdev_mirror_child_done, &mm[c]));
261 		c++;
262 	}
263 
264 	zio_wait_children_done(zio);
265 }
266 
267 static void
268 vdev_mirror_io_done(zio_t *zio)
269 {
270 	vdev_t *vd = zio->io_vd;
271 	vdev_t *cvd;
272 	mirror_map_t *mm = zio->io_vsd;
273 	int c;
274 	int good_copies = 0;
275 	int unexpected_errors = 0;
276 
277 	ASSERT(mm != NULL);
278 
279 	zio->io_error = 0;
280 	zio->io_numerrors = 0;
281 
282 	for (c = 0; c < vd->vdev_children; c++) {
283 		if (mm[c].mm_tried && mm[c].mm_error == 0) {
284 			good_copies++;
285 			continue;
286 		}
287 
288 		/*
289 		 * We preserve any EIOs because those may be worth retrying;
290 		 * whereas ECKSUM and ENXIO are more likely to be persistent.
291 		 */
292 		if (mm[c].mm_error) {
293 			if (zio->io_error != EIO)
294 				zio->io_error = mm[c].mm_error;
295 			if (!mm[c].mm_skipped)
296 				unexpected_errors++;
297 			zio->io_numerrors++;
298 		}
299 	}
300 
301 	if (zio->io_type == ZIO_TYPE_WRITE) {
302 		/*
303 		 * XXX -- for now, treat partial writes as success.
304 		 */
305 		/* XXPOLICY */
306 		if (good_copies != 0)
307 			zio->io_error = 0;
308 		ASSERT(mm != NULL);
309 		vdev_mirror_map_free(zio);
310 		zio_next_stage(zio);
311 		return;
312 	}
313 
314 	ASSERT(zio->io_type == ZIO_TYPE_READ);
315 
316 	/*
317 	 * If we don't have a good copy yet, keep trying other children.
318 	 */
319 	/* XXPOLICY */
320 	if (good_copies == 0 && (c = vdev_mirror_child_select(zio)) != -1) {
321 		ASSERT(c >= 0 && c < vd->vdev_children);
322 		cvd = vd->vdev_child[c];
323 		dprintf("%s: retrying i/o (err=%d) on child %s\n",
324 		    vdev_description(zio->io_vd), zio->io_error,
325 		    vdev_description(cvd));
326 		zio->io_error = 0;
327 		zio_vdev_io_redone(zio);
328 		zio_nowait(zio_vdev_child_io(zio, zio->io_bp, cvd,
329 		    zio->io_offset, zio->io_data, zio->io_size,
330 		    ZIO_TYPE_READ, zio->io_priority, ZIO_FLAG_CANFAIL,
331 		    vdev_mirror_child_done, &mm[c]));
332 		zio_wait_children_done(zio);
333 		return;
334 	}
335 
336 	/* XXPOLICY */
337 	if (good_copies)
338 		zio->io_error = 0;
339 	else
340 		ASSERT(zio->io_error != 0);
341 
342 	if (good_copies && (spa_mode & FWRITE) &&
343 	    (unexpected_errors || (zio->io_flags & ZIO_FLAG_RESILVER))) {
344 		/*
345 		 * Use the good data we have in hand to repair damaged children.
346 		 */
347 		for (c = 0; c < vd->vdev_children; c++) {
348 			/*
349 			 * Don't rewrite known good children.
350 			 * Not only is it unnecessary, it could
351 			 * actually be harmful: if the system lost
352 			 * power while rewriting the only good copy,
353 			 * there would be no good copies left!
354 			 */
355 			cvd = vd->vdev_child[c];
356 
357 			if (mm[c].mm_error == 0) {
358 				if (mm[c].mm_tried)
359 					continue;
360 				if (!vdev_dtl_contains(&cvd->vdev_dtl_map,
361 				    zio->io_txg, 1))
362 					continue;
363 				mm[c].mm_error = ESTALE;
364 			}
365 
366 			dprintf("%s resilvered %s @ 0x%llx error %d\n",
367 			    vdev_description(vd),
368 			    vdev_description(cvd),
369 			    zio->io_offset, mm[c].mm_error);
370 
371 			zio_nowait(zio_vdev_child_io(zio, zio->io_bp, cvd,
372 			    zio->io_offset, zio->io_data, zio->io_size,
373 			    ZIO_TYPE_WRITE, zio->io_priority,
374 			    ZIO_FLAG_IO_REPAIR | ZIO_FLAG_CANFAIL |
375 			    ZIO_FLAG_DONT_PROPAGATE, NULL, NULL));
376 		}
377 	}
378 
379 	vdev_mirror_map_free(zio);
380 	zio_next_stage(zio);
381 }
382 
383 static void
384 vdev_mirror_state_change(vdev_t *vd, int faulted, int degraded)
385 {
386 	if (faulted == vd->vdev_children)
387 		vdev_set_state(vd, VDEV_STATE_CANT_OPEN, VDEV_AUX_NO_REPLICAS);
388 	else if (degraded + faulted != 0)
389 		vdev_set_state(vd, VDEV_STATE_DEGRADED, VDEV_AUX_NONE);
390 	else
391 		vdev_set_state(vd, VDEV_STATE_HEALTHY, VDEV_AUX_NONE);
392 }
393 
394 vdev_ops_t vdev_mirror_ops = {
395 	vdev_mirror_open,
396 	vdev_mirror_close,
397 	vdev_default_asize,
398 	vdev_mirror_io_start,
399 	vdev_mirror_io_done,
400 	vdev_mirror_state_change,
401 	VDEV_TYPE_MIRROR,	/* name of this vdev type */
402 	B_FALSE			/* not a leaf vdev */
403 };
404 
405 vdev_ops_t vdev_replacing_ops = {
406 	vdev_mirror_open,
407 	vdev_mirror_close,
408 	vdev_default_asize,
409 	vdev_mirror_io_start,
410 	vdev_mirror_io_done,
411 	vdev_mirror_state_change,
412 	VDEV_TYPE_REPLACING,	/* name of this vdev type */
413 	B_FALSE			/* not a leaf vdev */
414 };
415