xref: /titanic_41/usr/src/uts/common/fs/zfs/zio_inject.c (revision b959b0b3b1c09d9e744c4cbdac35429511cbcf86)
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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23  * Copyright (c) 2012, 2014 by Delphix. All rights reserved.
24  */
25 
26 /*
27  * ZFS fault injection
28  *
29  * To handle fault injection, we keep track of a series of zinject_record_t
30  * structures which describe which logical block(s) should be injected with a
31  * fault.  These are kept in a global list.  Each record corresponds to a given
32  * spa_t and maintains a special hold on the spa_t so that it cannot be deleted
33  * or exported while the injection record exists.
34  *
35  * Device level injection is done using the 'zi_guid' field.  If this is set, it
36  * means that the error is destined for a particular device, not a piece of
37  * data.
38  *
39  * This is a rather poor data structure and algorithm, but we don't expect more
40  * than a few faults at any one time, so it should be sufficient for our needs.
41  */
42 
43 #include <sys/arc.h>
44 #include <sys/zio_impl.h>
45 #include <sys/zfs_ioctl.h>
46 #include <sys/vdev_impl.h>
47 #include <sys/dmu_objset.h>
48 #include <sys/fs/zfs.h>
49 
50 uint32_t zio_injection_enabled;
51 
52 typedef struct inject_handler {
53 	int			zi_id;
54 	spa_t			*zi_spa;
55 	zinject_record_t	zi_record;
56 	list_node_t		zi_link;
57 } inject_handler_t;
58 
59 static list_t inject_handlers;
60 static krwlock_t inject_lock;
61 static int inject_next_id = 1;
62 
63 /*
64  * Returns true if the given record matches the I/O in progress.
65  */
66 static boolean_t
zio_match_handler(zbookmark_phys_t * zb,uint64_t type,zinject_record_t * record,int error)67 zio_match_handler(zbookmark_phys_t *zb, uint64_t type,
68     zinject_record_t *record, int error)
69 {
70 	/*
71 	 * Check for a match against the MOS, which is based on type
72 	 */
73 	if (zb->zb_objset == DMU_META_OBJSET &&
74 	    record->zi_objset == DMU_META_OBJSET &&
75 	    record->zi_object == DMU_META_DNODE_OBJECT) {
76 		if (record->zi_type == DMU_OT_NONE ||
77 		    type == record->zi_type)
78 			return (record->zi_freq == 0 ||
79 			    spa_get_random(100) < record->zi_freq);
80 		else
81 			return (B_FALSE);
82 	}
83 
84 	/*
85 	 * Check for an exact match.
86 	 */
87 	if (zb->zb_objset == record->zi_objset &&
88 	    zb->zb_object == record->zi_object &&
89 	    zb->zb_level == record->zi_level &&
90 	    zb->zb_blkid >= record->zi_start &&
91 	    zb->zb_blkid <= record->zi_end &&
92 	    error == record->zi_error)
93 		return (record->zi_freq == 0 ||
94 		    spa_get_random(100) < record->zi_freq);
95 
96 	return (B_FALSE);
97 }
98 
99 /*
100  * Panic the system when a config change happens in the function
101  * specified by tag.
102  */
103 void
zio_handle_panic_injection(spa_t * spa,char * tag,uint64_t type)104 zio_handle_panic_injection(spa_t *spa, char *tag, uint64_t type)
105 {
106 	inject_handler_t *handler;
107 
108 	rw_enter(&inject_lock, RW_READER);
109 
110 	for (handler = list_head(&inject_handlers); handler != NULL;
111 	    handler = list_next(&inject_handlers, handler)) {
112 
113 		if (spa != handler->zi_spa)
114 			continue;
115 
116 		if (handler->zi_record.zi_type == type &&
117 		    strcmp(tag, handler->zi_record.zi_func) == 0)
118 			panic("Panic requested in function %s\n", tag);
119 	}
120 
121 	rw_exit(&inject_lock);
122 }
123 
124 /*
125  * Determine if the I/O in question should return failure.  Returns the errno
126  * to be returned to the caller.
127  */
128 int
zio_handle_fault_injection(zio_t * zio,int error)129 zio_handle_fault_injection(zio_t *zio, int error)
130 {
131 	int ret = 0;
132 	inject_handler_t *handler;
133 
134 	/*
135 	 * Ignore I/O not associated with any logical data.
136 	 */
137 	if (zio->io_logical == NULL)
138 		return (0);
139 
140 	/*
141 	 * Currently, we only support fault injection on reads.
142 	 */
143 	if (zio->io_type != ZIO_TYPE_READ)
144 		return (0);
145 
146 	rw_enter(&inject_lock, RW_READER);
147 
148 	for (handler = list_head(&inject_handlers); handler != NULL;
149 	    handler = list_next(&inject_handlers, handler)) {
150 
151 		if (zio->io_spa != handler->zi_spa ||
152 		    handler->zi_record.zi_cmd != ZINJECT_DATA_FAULT)
153 			continue;
154 
155 		/* If this handler matches, return EIO */
156 		if (zio_match_handler(&zio->io_logical->io_bookmark,
157 		    zio->io_bp ? BP_GET_TYPE(zio->io_bp) : DMU_OT_NONE,
158 		    &handler->zi_record, error)) {
159 			ret = error;
160 			break;
161 		}
162 	}
163 
164 	rw_exit(&inject_lock);
165 
166 	return (ret);
167 }
168 
169 /*
170  * Determine if the zio is part of a label update and has an injection
171  * handler associated with that portion of the label. Currently, we
172  * allow error injection in either the nvlist or the uberblock region of
173  * of the vdev label.
174  */
175 int
zio_handle_label_injection(zio_t * zio,int error)176 zio_handle_label_injection(zio_t *zio, int error)
177 {
178 	inject_handler_t *handler;
179 	vdev_t *vd = zio->io_vd;
180 	uint64_t offset = zio->io_offset;
181 	int label;
182 	int ret = 0;
183 
184 	if (offset >= VDEV_LABEL_START_SIZE &&
185 	    offset < vd->vdev_psize - VDEV_LABEL_END_SIZE)
186 		return (0);
187 
188 	rw_enter(&inject_lock, RW_READER);
189 
190 	for (handler = list_head(&inject_handlers); handler != NULL;
191 	    handler = list_next(&inject_handlers, handler)) {
192 		uint64_t start = handler->zi_record.zi_start;
193 		uint64_t end = handler->zi_record.zi_end;
194 
195 		if (handler->zi_record.zi_cmd != ZINJECT_LABEL_FAULT)
196 			continue;
197 
198 		/*
199 		 * The injection region is the relative offsets within a
200 		 * vdev label. We must determine the label which is being
201 		 * updated and adjust our region accordingly.
202 		 */
203 		label = vdev_label_number(vd->vdev_psize, offset);
204 		start = vdev_label_offset(vd->vdev_psize, label, start);
205 		end = vdev_label_offset(vd->vdev_psize, label, end);
206 
207 		if (zio->io_vd->vdev_guid == handler->zi_record.zi_guid &&
208 		    (offset >= start && offset <= end)) {
209 			ret = error;
210 			break;
211 		}
212 	}
213 	rw_exit(&inject_lock);
214 	return (ret);
215 }
216 
217 
218 int
zio_handle_device_injection(vdev_t * vd,zio_t * zio,int error)219 zio_handle_device_injection(vdev_t *vd, zio_t *zio, int error)
220 {
221 	inject_handler_t *handler;
222 	int ret = 0;
223 
224 	/*
225 	 * We skip over faults in the labels unless it's during
226 	 * device open (i.e. zio == NULL).
227 	 */
228 	if (zio != NULL) {
229 		uint64_t offset = zio->io_offset;
230 
231 		if (offset < VDEV_LABEL_START_SIZE ||
232 		    offset >= vd->vdev_psize - VDEV_LABEL_END_SIZE)
233 			return (0);
234 	}
235 
236 	rw_enter(&inject_lock, RW_READER);
237 
238 	for (handler = list_head(&inject_handlers); handler != NULL;
239 	    handler = list_next(&inject_handlers, handler)) {
240 
241 		if (handler->zi_record.zi_cmd != ZINJECT_DEVICE_FAULT)
242 			continue;
243 
244 		if (vd->vdev_guid == handler->zi_record.zi_guid) {
245 			if (handler->zi_record.zi_failfast &&
246 			    (zio == NULL || (zio->io_flags &
247 			    (ZIO_FLAG_IO_RETRY | ZIO_FLAG_TRYHARD)))) {
248 				continue;
249 			}
250 
251 			/* Handle type specific I/O failures */
252 			if (zio != NULL &&
253 			    handler->zi_record.zi_iotype != ZIO_TYPES &&
254 			    handler->zi_record.zi_iotype != zio->io_type)
255 				continue;
256 
257 			if (handler->zi_record.zi_error == error) {
258 				/*
259 				 * For a failed open, pretend like the device
260 				 * has gone away.
261 				 */
262 				if (error == ENXIO)
263 					vd->vdev_stat.vs_aux =
264 					    VDEV_AUX_OPEN_FAILED;
265 
266 				/*
267 				 * Treat these errors as if they had been
268 				 * retried so that all the appropriate stats
269 				 * and FMA events are generated.
270 				 */
271 				if (!handler->zi_record.zi_failfast &&
272 				    zio != NULL)
273 					zio->io_flags |= ZIO_FLAG_IO_RETRY;
274 
275 				ret = error;
276 				break;
277 			}
278 			if (handler->zi_record.zi_error == ENXIO) {
279 				ret = SET_ERROR(EIO);
280 				break;
281 			}
282 		}
283 	}
284 
285 	rw_exit(&inject_lock);
286 
287 	return (ret);
288 }
289 
290 /*
291  * Simulate hardware that ignores cache flushes.  For requested number
292  * of seconds nix the actual writing to disk.
293  */
294 void
zio_handle_ignored_writes(zio_t * zio)295 zio_handle_ignored_writes(zio_t *zio)
296 {
297 	inject_handler_t *handler;
298 
299 	rw_enter(&inject_lock, RW_READER);
300 
301 	for (handler = list_head(&inject_handlers); handler != NULL;
302 	    handler = list_next(&inject_handlers, handler)) {
303 
304 		/* Ignore errors not destined for this pool */
305 		if (zio->io_spa != handler->zi_spa ||
306 		    handler->zi_record.zi_cmd != ZINJECT_IGNORED_WRITES)
307 			continue;
308 
309 		/*
310 		 * Positive duration implies # of seconds, negative
311 		 * a number of txgs
312 		 */
313 		if (handler->zi_record.zi_timer == 0) {
314 			if (handler->zi_record.zi_duration > 0)
315 				handler->zi_record.zi_timer = ddi_get_lbolt64();
316 			else
317 				handler->zi_record.zi_timer = zio->io_txg;
318 		}
319 
320 		/* Have a "problem" writing 60% of the time */
321 		if (spa_get_random(100) < 60)
322 			zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES;
323 		break;
324 	}
325 
326 	rw_exit(&inject_lock);
327 }
328 
329 void
spa_handle_ignored_writes(spa_t * spa)330 spa_handle_ignored_writes(spa_t *spa)
331 {
332 	inject_handler_t *handler;
333 
334 	if (zio_injection_enabled == 0)
335 		return;
336 
337 	rw_enter(&inject_lock, RW_READER);
338 
339 	for (handler = list_head(&inject_handlers); handler != NULL;
340 	    handler = list_next(&inject_handlers, handler)) {
341 
342 		if (spa != handler->zi_spa ||
343 		    handler->zi_record.zi_cmd != ZINJECT_IGNORED_WRITES)
344 			continue;
345 
346 		if (handler->zi_record.zi_duration > 0) {
347 			VERIFY(handler->zi_record.zi_timer == 0 ||
348 			    handler->zi_record.zi_timer +
349 			    handler->zi_record.zi_duration * hz >
350 			    ddi_get_lbolt64());
351 		} else {
352 			/* duration is negative so the subtraction here adds */
353 			VERIFY(handler->zi_record.zi_timer == 0 ||
354 			    handler->zi_record.zi_timer -
355 			    handler->zi_record.zi_duration >=
356 			    spa_syncing_txg(spa));
357 		}
358 	}
359 
360 	rw_exit(&inject_lock);
361 }
362 
363 uint64_t
zio_handle_io_delay(zio_t * zio)364 zio_handle_io_delay(zio_t *zio)
365 {
366 	vdev_t *vd = zio->io_vd;
367 	inject_handler_t *handler;
368 	uint64_t seconds = 0;
369 
370 	if (zio_injection_enabled == 0)
371 		return (0);
372 
373 	rw_enter(&inject_lock, RW_READER);
374 
375 	for (handler = list_head(&inject_handlers); handler != NULL;
376 	    handler = list_next(&inject_handlers, handler)) {
377 
378 		if (handler->zi_record.zi_cmd != ZINJECT_DELAY_IO)
379 			continue;
380 
381 		if (vd->vdev_guid == handler->zi_record.zi_guid) {
382 			seconds = handler->zi_record.zi_timer;
383 			break;
384 		}
385 
386 	}
387 	rw_exit(&inject_lock);
388 	return (seconds);
389 }
390 
391 /*
392  * Create a new handler for the given record.  We add it to the list, adding
393  * a reference to the spa_t in the process.  We increment zio_injection_enabled,
394  * which is the switch to trigger all fault injection.
395  */
396 int
zio_inject_fault(char * name,int flags,int * id,zinject_record_t * record)397 zio_inject_fault(char *name, int flags, int *id, zinject_record_t *record)
398 {
399 	inject_handler_t *handler;
400 	int error;
401 	spa_t *spa;
402 
403 	/*
404 	 * If this is pool-wide metadata, make sure we unload the corresponding
405 	 * spa_t, so that the next attempt to load it will trigger the fault.
406 	 * We call spa_reset() to unload the pool appropriately.
407 	 */
408 	if (flags & ZINJECT_UNLOAD_SPA)
409 		if ((error = spa_reset(name)) != 0)
410 			return (error);
411 
412 	if (!(flags & ZINJECT_NULL)) {
413 		/*
414 		 * spa_inject_ref() will add an injection reference, which will
415 		 * prevent the pool from being removed from the namespace while
416 		 * still allowing it to be unloaded.
417 		 */
418 		if ((spa = spa_inject_addref(name)) == NULL)
419 			return (SET_ERROR(ENOENT));
420 
421 		handler = kmem_alloc(sizeof (inject_handler_t), KM_SLEEP);
422 
423 		rw_enter(&inject_lock, RW_WRITER);
424 
425 		*id = handler->zi_id = inject_next_id++;
426 		handler->zi_spa = spa;
427 		handler->zi_record = *record;
428 		list_insert_tail(&inject_handlers, handler);
429 		atomic_inc_32(&zio_injection_enabled);
430 
431 		rw_exit(&inject_lock);
432 	}
433 
434 	/*
435 	 * Flush the ARC, so that any attempts to read this data will end up
436 	 * going to the ZIO layer.  Note that this is a little overkill, but
437 	 * we don't have the necessary ARC interfaces to do anything else, and
438 	 * fault injection isn't a performance critical path.
439 	 */
440 	if (flags & ZINJECT_FLUSH_ARC)
441 		/*
442 		 * We must use FALSE to ensure arc_flush returns, since
443 		 * we're not preventing concurrent ARC insertions.
444 		 */
445 		arc_flush(NULL, FALSE);
446 
447 	return (0);
448 }
449 
450 /*
451  * Returns the next record with an ID greater than that supplied to the
452  * function.  Used to iterate over all handlers in the system.
453  */
454 int
zio_inject_list_next(int * id,char * name,size_t buflen,zinject_record_t * record)455 zio_inject_list_next(int *id, char *name, size_t buflen,
456     zinject_record_t *record)
457 {
458 	inject_handler_t *handler;
459 	int ret;
460 
461 	mutex_enter(&spa_namespace_lock);
462 	rw_enter(&inject_lock, RW_READER);
463 
464 	for (handler = list_head(&inject_handlers); handler != NULL;
465 	    handler = list_next(&inject_handlers, handler))
466 		if (handler->zi_id > *id)
467 			break;
468 
469 	if (handler) {
470 		*record = handler->zi_record;
471 		*id = handler->zi_id;
472 		(void) strncpy(name, spa_name(handler->zi_spa), buflen);
473 		ret = 0;
474 	} else {
475 		ret = SET_ERROR(ENOENT);
476 	}
477 
478 	rw_exit(&inject_lock);
479 	mutex_exit(&spa_namespace_lock);
480 
481 	return (ret);
482 }
483 
484 /*
485  * Clear the fault handler with the given identifier, or return ENOENT if none
486  * exists.
487  */
488 int
zio_clear_fault(int id)489 zio_clear_fault(int id)
490 {
491 	inject_handler_t *handler;
492 
493 	rw_enter(&inject_lock, RW_WRITER);
494 
495 	for (handler = list_head(&inject_handlers); handler != NULL;
496 	    handler = list_next(&inject_handlers, handler))
497 		if (handler->zi_id == id)
498 			break;
499 
500 	if (handler == NULL) {
501 		rw_exit(&inject_lock);
502 		return (SET_ERROR(ENOENT));
503 	}
504 
505 	list_remove(&inject_handlers, handler);
506 	rw_exit(&inject_lock);
507 
508 	spa_inject_delref(handler->zi_spa);
509 	kmem_free(handler, sizeof (inject_handler_t));
510 	atomic_dec_32(&zio_injection_enabled);
511 
512 	return (0);
513 }
514 
515 void
zio_inject_init(void)516 zio_inject_init(void)
517 {
518 	rw_init(&inject_lock, NULL, RW_DEFAULT, NULL);
519 	list_create(&inject_handlers, sizeof (inject_handler_t),
520 	    offsetof(inject_handler_t, zi_link));
521 }
522 
523 void
zio_inject_fini(void)524 zio_inject_fini(void)
525 {
526 	list_destroy(&inject_handlers);
527 	rw_destroy(&inject_lock);
528 }
529