usr/src/uts/common/fs/zfs/zio_inject.c

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