cmd/zinject/zinject.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  * Copyright (c) 2012 by Delphix. All rights reserved.
  24  */
  25
  26 /*
  27  * ZFS Fault Injector
  28  *
  29  * This userland component takes a set of options and uses libzpool to translate
  30  * from a user-visible object type and name to an internal representation.
  31  * There are two basic types of faults: device faults and data faults.
  32  *
  33  *
  34  * DEVICE FAULTS
  35  *
  36  * Errors can be injected into a particular vdev using the '-d' option.  This
  37  * option takes a path or vdev GUID to uniquely identify the device within a
  38  * pool.  There are two types of errors that can be injected, EIO and ENXIO,
  39  * that can be controlled through the '-e' option.  The default is ENXIO.  For
  40  * EIO failures, any attempt to read data from the device will return EIO, but
  41  * subsequent attempt to reopen the device will succeed.  For ENXIO failures,
  42  * any attempt to read from the device will return EIO, but any attempt to
  43  * reopen the device will also return ENXIO.
  44  * For label faults, the -L option must be specified. This allows faults
  45  * to be injected into either the nvlist, uberblock, pad1, or pad2 region
  46  * of all the labels for the specified device.
  47  *
  48  * This form of the command looks like:
  49  *
  50  *      zinject -d device [-e errno] [-L <uber | nvlist | pad1 | pad2>] pool
  51  *
  52  *
  53  * DATA FAULTS
  54  *
  55  * We begin with a tuple of the form:
  56  *
  57  *      <type,level,range,object>
  58  *
  59  *      type    A string describing the type of data to target.  Each type
  60  *              implicitly describes how to interpret 'object'. Currently,
  61  *              the following values are supported:
  62  *
  63  *              data            User data for a file
  64  *              dnode           Dnode for a file or directory
  65  *
  66  *              The following MOS objects are special.  Instead of injecting
  67  *              errors on a particular object or blkid, we inject errors across
  68  *              all objects of the given type.
  69  *
  70  *              mos             Any data in the MOS
  71  *              mosdir          object directory
  72  *              config          pool configuration
  73  *              bpobj           blkptr list
  74  *              spacemap        spacemap
  75  *              metaslab        metaslab
  76  *              errlog          persistent error log
  77  *
  78  *      level   Object level.  Defaults to '0', not applicable to all types.  If
  79  *              a range is given, this corresponds to the indirect block
  80  *              corresponding to the specific range.
  81  *
  82  *      range   A numerical range [start,end) within the object.  Defaults to
  83  *              the full size of the file.
  84  *
  85  *      object  A string describing the logical location of the object.  For
  86  *              files and directories (currently the only supported types),
  87  *              this is the path of the object on disk.
  88  *
  89  * This is translated, via libzpool, into the following internal representation:
  90  *
  91  *      <type,objset,object,level,range>
  92  *
  93  * These types should be self-explanatory.  This tuple is then passed to the
  94  * kernel via a special ioctl() to initiate fault injection for the given
  95  * object.  Note that 'type' is not strictly necessary for fault injection, but
  96  * is used when translating existing faults into a human-readable string.
  97  *
  98  *
  99  * The command itself takes one of the forms:
 100  *
 101  *      zinject
 102  *      zinject <-a | -u pool>
 103  *      zinject -c <id|all>
 104  *      zinject [-q] <-t type> [-f freq] [-u] [-a] [-m] [-e errno] [-l level]
 105  *          [-r range] <object>
 106  *      zinject [-f freq] [-a] [-m] [-u] -b objset:object:level:start:end pool
 107  *
 108  * With no arguments, the command prints all currently registered injection
 109  * handlers, with their numeric identifiers.
 110  *
 111  * The '-c' option will clear the given handler, or all handlers if 'all' is
 112  * specified.
 113  *
 114  * The '-e' option takes a string describing the errno to simulate.  This must
 115  * be either 'io' or 'checksum'.  In most cases this will result in the same
 116  * behavior, but RAID-Z will produce a different set of ereports for this
 117  * situation.
 118  *
 119  * The '-a', '-u', and '-m' flags toggle internal flush behavior.  If '-a' is
 120  * specified, then the ARC cache is flushed appropriately.  If '-u' is
 121  * specified, then the underlying SPA is unloaded.  Either of these flags can be
 122  * specified independently of any other handlers.  The '-m' flag automatically
 123  * does an unmount and remount of the underlying dataset to aid in flushing the
 124  * cache.
 125  *
 126  * The '-f' flag controls the frequency of errors injected, expressed as a
 127  * integer percentage between 1 and 100.  The default is 100.
 128  *
 129  * The this form is responsible for actually injecting the handler into the
 130  * framework.  It takes the arguments described above, translates them to the
 131  * internal tuple using libzpool, and then issues an ioctl() to register the
 132  * handler.
 133  *
 134  * The final form can target a specific bookmark, regardless of whether a
 135  * human-readable interface has been designed.  It allows developers to specify
 136  * a particular block by number.
 137  */
 138
 139 #include <errno.h>
 140 #include <fcntl.h>
 141 #include <stdio.h>
 142 #include <stdlib.h>
 143 #include <strings.h>
 144 #include <unistd.h>
 145
 146 #include <sys/fs/zfs.h>
 147 #include <sys/mount.h>
 148
 149 #include <libzfs.h>
 150
 151 #undef verify   /* both libzfs.h and zfs_context.h want to define this */
 152
 153 #include "zinject.h"
 154
 155 libzfs_handle_t *g_zfs;
 156 int zfs_fd;
 157
 158 #define ECKSUM  EBADE
 159
 160 static const char *errtable[TYPE_INVAL] = {
 161         "data",
 162         "dnode",
 163         "mos",
 164         "mosdir",
 165         "metaslab",
 166         "config",
 167         "bpobj",
 168         "spacemap",
 169         "errlog",
 170         "uber",
 171         "nvlist",
 172         "pad1",
 173         "pad2"
 174 };
 175
 176 static err_type_t
 177 name_to_type(const char *arg)
 178 {
 179         int i;
 180         for (i = 0; i < TYPE_INVAL; i++)
 181                 if (strcmp(errtable[i], arg) == 0)
 182                         return (i);
 183
 184         return (TYPE_INVAL);
 185 }
 186
 187 static const char *
 188 type_to_name(uint64_t type)
 189 {
 190         switch (type) {
 191         case DMU_OT_OBJECT_DIRECTORY:
 192                 return ("mosdir");
 193         case DMU_OT_OBJECT_ARRAY:
 194                 return ("metaslab");
 195         case DMU_OT_PACKED_NVLIST:
 196                 return ("config");
 197         case DMU_OT_BPOBJ:
 198                 return ("bpobj");
 199         case DMU_OT_SPACE_MAP:
 200                 return ("spacemap");
 201         case DMU_OT_ERROR_LOG:
 202                 return ("errlog");
 203         default:
 204                 return ("-");
 205         }
 206 }
 207
 208
 209 /*
 210  * Print usage message.
 211  */
 212 void
 213 usage(void)
 214 {
 215         (void) printf(
 216             "usage:\n"
 217             "\n"
 218             "\tzinject\n"
 219             "\n"
 220             "\t\tList all active injection records.\n"
 221             "\n"
 222             "\tzinject -c <id|all>\n"
 223             "\n"
 224             "\t\tClear the particular record (if given a numeric ID), or\n"
 225             "\t\tall records if 'all' is specificed.\n"
 226             "\n"
 227             "\tzinject -p <function name> pool\n"
 228             "\t\tInject a panic fault at the specified function. Only \n"
 229             "\t\tfunctions which call spa_vdev_config_exit(), or \n"
 230             "\t\tspa_vdev_exit() will trigger a panic.\n"
 231             "\n"
 232             "\tzinject -d device [-e errno] [-L <nvlist|uber|pad1|pad2>] [-F]\n"
 233             "\t    [-T <read|write|free|claim|all> pool\n"
 234             "\t\tInject a fault into a particular device or the device's\n"
 235             "\t\tlabel.  Label injection can either be 'nvlist', 'uber',\n "
 236             "\t\t'pad1', or 'pad2'.\n"
 237             "\t\t'errno' can be 'nxio' (the default), 'io', or 'dtl'.\n"
 238             "\n"
 239             "\tzinject -d device -A <degrade|fault> -D <delay secs> pool\n"
 240             "\t\tPerform a specific action on a particular device.\n"
 241             "\n"
 242             "\tzinject -I [-s <seconds> | -g <txgs>] pool\n"
 243             "\t\tCause the pool to stop writing blocks yet not\n"
 244             "\t\treport errors for a duration.  Simulates buggy hardware\n"
 245             "\t\tthat fails to honor cache flush requests.\n"
 246             "\t\tDefault duration is 30 seconds.  The machine is panicked\n"
 247             "\t\tat the end of the duration.\n"
 248             "\n"
 249             "\tzinject -b objset:object:level:blkid pool\n"
 250             "\n"
 251             "\t\tInject an error into pool 'pool' with the numeric bookmark\n"
 252             "\t\tspecified by the remaining tuple.  Each number is in\n"
 253             "\t\thexidecimal, and only one block can be specified.\n"
 254             "\n"
 255             "\tzinject [-q] <-t type> [-e errno] [-l level] [-r range]\n"
 256             "\t    [-a] [-m] [-u] [-f freq] <object>\n"
 257             "\n"
 258             "\t\tInject an error into the object specified by the '-t' option\n"
 259             "\t\tand the object descriptor.  The 'object' parameter is\n"
 260             "\t\tinterperted depending on the '-t' option.\n"
 261             "\n"
 262             "\t\t-q\tQuiet mode.  Only print out the handler number added.\n"
 263             "\t\t-e\tInject a specific error.  Must be either 'io' or\n"
 264             "\t\t\t'checksum'.  Default is 'io'.\n"
 265             "\t\t-l\tInject error at a particular block level. Default is "
 266             "0.\n"
 267             "\t\t-m\tAutomatically remount underlying filesystem.\n"
 268             "\t\t-r\tInject error over a particular logical range of an\n"
 269             "\t\t\tobject.  Will be translated to the appropriate blkid\n"
 270             "\t\t\trange according to the object's properties.\n"
 271             "\t\t-a\tFlush the ARC cache.  Can be specified without any\n"
 272             "\t\t\tassociated object.\n"
 273             "\t\t-u\tUnload the associated pool.  Can be specified with only\n"
 274             "\t\t\ta pool object.\n"
 275             "\t\t-f\tOnly inject errors a fraction of the time.  Expressed as\n"
 276             "\t\t\ta percentage between 1 and 100.\n"
 277             "\n"
 278             "\t-t data\t\tInject an error into the plain file contents of a\n"
 279             "\t\t\tfile.  The object must be specified as a complete path\n"
 280             "\t\t\tto a file on a ZFS filesystem.\n"
 281             "\n"
 282             "\t-t dnode\tInject an error into the metadnode in the block\n"
 283             "\t\t\tcorresponding to the dnode for a file or directory.  The\n"
 284             "\t\t\t'-r' option is incompatible with this mode.  The object\n"
 285             "\t\t\tis specified as a complete path to a file or directory\n"
 286             "\t\t\ton a ZFS filesystem.\n"
 287             "\n"
 288             "\t-t <mos>\tInject errors into the MOS for objects of the given\n"
 289             "\t\t\ttype.  Valid types are: mos, mosdir, config, bpobj,\n"
 290             "\t\t\tspacemap, metaslab, errlog.  The only valid <object> is\n"
 291             "\t\t\tthe poolname.\n");
 292 }
 293
 294 static int
 295 iter_handlers(int (*func)(int, const char *, zinject_record_t *, void *),
 296     void *data)
 297 {
 298         zfs_cmd_t zc;
 299         int ret;
 300
 301         zc.zc_guid = 0;
 302
 303         while (ioctl(zfs_fd, ZFS_IOC_INJECT_LIST_NEXT, &zc) == 0)
 304                 if ((ret = func((int)zc.zc_guid, zc.zc_name,
 305                     &zc.zc_inject_record, data)) != 0)
 306                         return (ret);
 307
 308         if (errno != ENOENT) {
 309                 (void) fprintf(stderr, "Unable to list handlers: %s\n",
 310                     strerror(errno));
 311                 return (-1);
 312         }
 313
 314         return (0);
 315 }
 316
 317 static int
 318 print_data_handler(int id, const char *pool, zinject_record_t *record,
 319     void *data)
 320 {
 321         int *count = data;
 322
 323         if (record->zi_guid != 0 || record->zi_func[0] != '\0')
 324                 return (0);
 325
 326         if (*count == 0) {
 327                 (void) printf("%3s  %-15s  %-6s  %-6s  %-8s  %3s  %-15s\n",
 328                     "ID", "POOL", "OBJSET", "OBJECT", "TYPE", "LVL",  "RANGE");
 329                 (void) printf("---  ---------------  ------  "
 330                     "------  --------  ---  ---------------\n");
 331         }
 332
 333         *count += 1;
 334
 335         (void) printf("%3d  %-15s  %-6llu  %-6llu  %-8s  %3d  ", id, pool,
 336             (u_longlong_t)record->zi_objset, (u_longlong_t)record->zi_object,
 337             type_to_name(record->zi_type), record->zi_level);
 338
 339         if (record->zi_start == 0 &&
 340             record->zi_end == -1ULL)
 341                 (void) printf("all\n");
 342         else
 343                 (void) printf("[%llu, %llu]\n", (u_longlong_t)record->zi_start,
 344                     (u_longlong_t)record->zi_end);
 345
 346         return (0);
 347 }
 348
 349 static int
 350 print_device_handler(int id, const char *pool, zinject_record_t *record,
 351     void *data)
 352 {
 353         int *count = data;
 354
 355         if (record->zi_guid == 0 || record->zi_func[0] != '\0')
 356                 return (0);
 357
 358         if (*count == 0) {
 359                 (void) printf("%3s  %-15s  %s\n", "ID", "POOL", "GUID");
 360                 (void) printf("---  ---------------  ----------------\n");
 361         }
 362
 363         *count += 1;
 364
 365         (void) printf("%3d  %-15s  %llx\n", id, pool,
 366             (u_longlong_t)record->zi_guid);
 367
 368         return (0);
 369 }
 370
 371 static int
 372 print_panic_handler(int id, const char *pool, zinject_record_t *record,
 373     void *data)
 374 {
 375         int *count = data;
 376
 377         if (record->zi_func[0] == '\0')
 378                 return (0);
 379
 380         if (*count == 0) {
 381                 (void) printf("%3s  %-15s  %s\n", "ID", "POOL", "FUNCTION");
 382                 (void) printf("---  ---------------  ----------------\n");
 383         }
 384
 385         *count += 1;
 386
 387         (void) printf("%3d  %-15s  %s\n", id, pool, record->zi_func);
 388
 389         return (0);
 390 }
 391
 392 /*
 393  * Print all registered error handlers.  Returns the number of handlers
 394  * registered.
 395  */
 396 static int
 397 print_all_handlers(void)
 398 {
 399         int count = 0, total = 0;
 400
 401         (void) iter_handlers(print_device_handler, &count);
 402         if (count > 0) {
 403                 total += count;
 404                 (void) printf("\n");
 405                 count = 0;
 406         }
 407
 408         (void) iter_handlers(print_data_handler, &count);
 409         if (count > 0) {
 410                 total += count;
 411                 (void) printf("\n");
 412                 count = 0;
 413         }
 414
 415         (void) iter_handlers(print_panic_handler, &count);
 416
 417         return (count + total);
 418 }
 419
 420 /* ARGSUSED */
 421 static int
 422 cancel_one_handler(int id, const char *pool, zinject_record_t *record,
 423     void *data)
 424 {
 425         zfs_cmd_t zc;
 426
 427         zc.zc_guid = (uint64_t)id;
 428
 429         if (ioctl(zfs_fd, ZFS_IOC_CLEAR_FAULT, &zc) != 0) {
 430                 (void) fprintf(stderr, "failed to remove handler %d: %s\n",
 431                     id, strerror(errno));
 432                 return (1);
 433         }
 434
 435         return (0);
 436 }
 437
 438 /*
 439  * Remove all fault injection handlers.
 440  */
 441 static int
 442 cancel_all_handlers(void)
 443 {
 444         int ret = iter_handlers(cancel_one_handler, NULL);
 445
 446         if (ret == 0)
 447                 (void) printf("removed all registered handlers\n");
 448
 449         return (ret);
 450 }
 451
 452 /*
 453  * Remove a specific fault injection handler.
 454  */
 455 static int
 456 cancel_handler(int id)
 457 {
 458         zfs_cmd_t zc;
 459
 460         zc.zc_guid = (uint64_t)id;
 461
 462         if (ioctl(zfs_fd, ZFS_IOC_CLEAR_FAULT, &zc) != 0) {
 463                 (void) fprintf(stderr, "failed to remove handler %d: %s\n",
 464                     id, strerror(errno));
 465                 return (1);
 466         }
 467
 468         (void) printf("removed handler %d\n", id);
 469
 470         return (0);
 471 }
 472
 473 /*
 474  * Register a new fault injection handler.
 475  */
 476 static int
 477 register_handler(const char *pool, int flags, zinject_record_t *record,
 478     int quiet)
 479 {
 480         zfs_cmd_t zc;
 481
 482         (void) strcpy(zc.zc_name, pool);
 483         zc.zc_inject_record = *record;
 484         zc.zc_guid = flags;
 485
 486         if (ioctl(zfs_fd, ZFS_IOC_INJECT_FAULT, &zc) != 0) {
 487                 (void) fprintf(stderr, "failed to add handler: %s\n",
 488                     strerror(errno));
 489                 return (1);
 490         }
 491
 492         if (flags & ZINJECT_NULL)
 493                 return (0);
 494
 495         if (quiet) {
 496                 (void) printf("%llu\n", (u_longlong_t)zc.zc_guid);
 497         } else {
 498                 (void) printf("Added handler %llu with the following "
 499                     "properties:\n", (u_longlong_t)zc.zc_guid);
 500                 (void) printf("  pool: %s\n", pool);
 501                 if (record->zi_guid) {
 502                         (void) printf("  vdev: %llx\n",
 503                             (u_longlong_t)record->zi_guid);
 504                 } else if (record->zi_func[0] != '\0') {
 505                         (void) printf("  panic function: %s\n",
 506                             record->zi_func);
 507                 } else if (record->zi_duration > 0) {
 508                         (void) printf(" time: %lld seconds\n",
 509                             (u_longlong_t)record->zi_duration);
 510                 } else if (record->zi_duration < 0) {
 511                         (void) printf(" txgs: %lld \n",
 512                             (u_longlong_t)-record->zi_duration);
 513                 } else {
 514                         (void) printf("objset: %llu\n",
 515                             (u_longlong_t)record->zi_objset);
 516                         (void) printf("object: %llu\n",
 517                             (u_longlong_t)record->zi_object);
 518                         (void) printf("  type: %llu\n",
 519                             (u_longlong_t)record->zi_type);
 520                         (void) printf(" level: %d\n", record->zi_level);
 521                         if (record->zi_start == 0 &&
 522                             record->zi_end == -1ULL)
 523                                 (void) printf(" range: all\n");
 524                         else
 525                                 (void) printf(" range: [%llu, %llu)\n",
 526                                     (u_longlong_t)record->zi_start,
 527                                     (u_longlong_t)record->zi_end);
 528                 }
 529         }
 530
 531         return (0);
 532 }
 533
 534 int
 535 perform_action(const char *pool, zinject_record_t *record, int cmd)
 536 {
 537         zfs_cmd_t zc;
 538
 539         ASSERT(cmd == VDEV_STATE_DEGRADED || cmd == VDEV_STATE_FAULTED);
 540         (void) strlcpy(zc.zc_name, pool, sizeof (zc.zc_name));
 541         zc.zc_guid = record->zi_guid;
 542         zc.zc_cookie = cmd;
 543
 544         if (ioctl(zfs_fd, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
 545                 return (0);
 546
 547         return (1);
 548 }
 549
 550 int
 551 main(int argc, char **argv)
 552 {
 553         int c;
 554         char *range = NULL;
 555         char *cancel = NULL;
 556         char *end;
 557         char *raw = NULL;
 558         char *device = NULL;
 559         int level = 0;
 560         int quiet = 0;
 561         int error = 0;
 562         int domount = 0;
 563         int io_type = ZIO_TYPES;
 564         int action = VDEV_STATE_UNKNOWN;
 565         err_type_t type = TYPE_INVAL;
 566         err_type_t label = TYPE_INVAL;
 567         zinject_record_t record = { 0 };
 568         char pool[MAXNAMELEN];
 569         char dataset[MAXNAMELEN];
 570         zfs_handle_t *zhp = NULL;
 571         int nowrites = 0;
 572         int dur_txg = 0;
 573         int dur_secs = 0;
 574         int ret;
 575         int flags = 0;
 576
 577         if ((g_zfs = libzfs_init()) == NULL)
 578                 return (1);
 579
 580         libzfs_print_on_error(g_zfs, B_TRUE);
 581
 582         if ((zfs_fd = open(ZFS_DEV, O_RDWR)) < 0) {
 583                 (void) fprintf(stderr, "failed to open ZFS device\n");
 584                 return (1);
 585         }
 586
 587         if (argc == 1) {
 588                 /*
 589                  * No arguments.  Print the available handlers.  If there are no
 590                  * available handlers, direct the user to '-h' for help
 591                  * information.
 592                  */
 593                 if (print_all_handlers() == 0) {
 594                         (void) printf("No handlers registered.\n");
 595                         (void) printf("Run 'zinject -h' for usage "
 596                             "information.\n");
 597                 }
 598
 599                 return (0);
 600         }
 601
 602         while ((c = getopt(argc, argv,
 603             ":aA:b:d:D:f:Fg:qhIc:t:T:l:mr:s:e:uL:p:")) != -1) {
 604                 switch (c) {
 605                 case 'a':
 606                         flags |= ZINJECT_FLUSH_ARC;
 607                         break;
 608                 case 'A':
 609                         if (strcasecmp(optarg, "degrade") == 0) {
 610                                 action = VDEV_STATE_DEGRADED;
 611                         } else if (strcasecmp(optarg, "fault") == 0) {
 612                                 action = VDEV_STATE_FAULTED;
 613                         } else {
 614                                 (void) fprintf(stderr, "invalid action '%s': "
 615                                     "must be 'degrade' or 'fault'\n", optarg);
 616                                 usage();
 617                                 return (1);
 618                         }
 619                         break;
 620                 case 'b':
 621                         raw = optarg;
 622                         break;
 623                 case 'c':
 624                         cancel = optarg;
 625                         break;
 626                 case 'd':
 627                         device = optarg;
 628                         break;
 629                 case 'D':
 630                         errno = 0;
 631                         record.zi_timer = strtoull(optarg, &end, 10);
 632                         if (errno != 0 || *end != '\0') {
 633                                 (void) fprintf(stderr, "invalid i/o delay "
 634                                     "value: '%s'\n", optarg);
 635                                 usage();
 636                                 return (1);
 637                         }
 638                         break;
 639                 case 'e':
 640                         if (strcasecmp(optarg, "io") == 0) {
 641                                 error = EIO;
 642                         } else if (strcasecmp(optarg, "checksum") == 0) {
 643                                 error = ECKSUM;
 644                         } else if (strcasecmp(optarg, "nxio") == 0) {
 645                                 error = ENXIO;
 646                         } else if (strcasecmp(optarg, "dtl") == 0) {
 647                                 error = ECHILD;
 648                         } else {
 649                                 (void) fprintf(stderr, "invalid error type "
 650                                     "'%s': must be 'io', 'checksum' or "
 651                                     "'nxio'\n", optarg);
 652                                 usage();
 653                                 return (1);
 654                         }
 655                         break;
 656                 case 'f':
 657                         record.zi_freq = atoi(optarg);
 658                         if (record.zi_freq < 1 || record.zi_freq > 100) {
 659                                 (void) fprintf(stderr, "frequency range must "
 660                                     "be in the range (0, 100]\n");
 661                                 return (1);
 662                         }
 663                         break;
 664                 case 'F':
 665                         record.zi_failfast = B_TRUE;
 666                         break;
 667                 case 'g':
 668                         dur_txg = 1;
 669                         record.zi_duration = (int)strtol(optarg, &end, 10);
 670                         if (record.zi_duration <= 0 || *end != '\0') {
 671                                 (void) fprintf(stderr, "invalid duration '%s': "
 672                                     "must be a positive integer\n", optarg);
 673                                 usage();
 674                                 return (1);
 675                         }
 676                         /* store duration of txgs as its negative */
 677                         record.zi_duration *= -1;
 678                         break;
 679                 case 'h':
 680                         usage();
 681                         return (0);
 682                 case 'I':
 683                         /* default duration, if one hasn't yet been defined */
 684                         nowrites = 1;
 685                         if (dur_secs == 0 && dur_txg == 0)
 686                                 record.zi_duration = 30;
 687                         break;
 688                 case 'l':
 689                         level = (int)strtol(optarg, &end, 10);
 690                         if (*end != '\0') {
 691                                 (void) fprintf(stderr, "invalid level '%s': "
 692                                     "must be an integer\n", optarg);
 693                                 usage();
 694                                 return (1);
 695                         }
 696                         break;
 697                 case 'm':
 698                         domount = 1;
 699                         break;
 700                 case 'p':
 701                         (void) strlcpy(record.zi_func, optarg,
 702                             sizeof (record.zi_func));
 703                         record.zi_cmd = ZINJECT_PANIC;
 704                         break;
 705                 case 'q':
 706                         quiet = 1;
 707                         break;
 708                 case 'r':
 709                         range = optarg;
 710                         break;
 711                 case 's':
 712                         dur_secs = 1;
 713                         record.zi_duration = (int)strtol(optarg, &end, 10);
 714                         if (record.zi_duration <= 0 || *end != '\0') {
 715                                 (void) fprintf(stderr, "invalid duration '%s': "
 716                                     "must be a positive integer\n", optarg);
 717                                 usage();
 718                                 return (1);
 719                         }
 720                         break;
 721                 case 'T':
 722                         if (strcasecmp(optarg, "read") == 0) {
 723                                 io_type = ZIO_TYPE_READ;
 724                         } else if (strcasecmp(optarg, "write") == 0) {
 725                                 io_type = ZIO_TYPE_WRITE;
 726                         } else if (strcasecmp(optarg, "free") == 0) {
 727                                 io_type = ZIO_TYPE_FREE;
 728                         } else if (strcasecmp(optarg, "claim") == 0) {
 729                                 io_type = ZIO_TYPE_CLAIM;
 730                         } else if (strcasecmp(optarg, "all") == 0) {
 731                                 io_type = ZIO_TYPES;
 732                         } else {
 733                                 (void) fprintf(stderr, "invalid I/O type "
 734                                     "'%s': must be 'read', 'write', 'free', "
 735                                     "'claim' or 'all'\n", optarg);
 736                                 usage();
 737                                 return (1);
 738                         }
 739                         break;
 740                 case 't':
 741                         if ((type = name_to_type(optarg)) == TYPE_INVAL &&
 742                             !MOS_TYPE(type)) {
 743                                 (void) fprintf(stderr, "invalid type '%s'\n",
 744                                     optarg);
 745                                 usage();
 746                                 return (1);
 747                         }
 748                         break;
 749                 case 'u':
 750                         flags |= ZINJECT_UNLOAD_SPA;
 751                         break;
 752                 case 'L':
 753                         if ((label = name_to_type(optarg)) == TYPE_INVAL &&
 754                             !LABEL_TYPE(type)) {
 755                                 (void) fprintf(stderr, "invalid label type "
 756                                     "'%s'\n", optarg);
 757                                 usage();
 758                                 return (1);
 759                         }
 760                         break;
 761                 case ':':
 762                         (void) fprintf(stderr, "option -%c requires an "
 763                             "operand\n", optopt);
 764                         usage();
 765                         return (1);
 766                 case '?':
 767                         (void) fprintf(stderr, "invalid option '%c'\n",
 768                             optopt);
 769                         usage();
 770                         return (2);
 771                 }
 772         }
 773
 774         argc -= optind;
 775         argv += optind;
 776
 777         if (record.zi_duration != 0)
 778                 record.zi_cmd = ZINJECT_IGNORED_WRITES;
 779
 780         if (cancel != NULL) {
 781                 /*
 782                  * '-c' is invalid with any other options.
 783                  */
 784                 if (raw != NULL || range != NULL || type != TYPE_INVAL ||
 785                     level != 0 || record.zi_cmd != ZINJECT_UNINITIALIZED) {
 786                         (void) fprintf(stderr, "cancel (-c) incompatible with "
 787                             "any other options\n");
 788                         usage();
 789                         return (2);
 790                 }
 791                 if (argc != 0) {
 792                         (void) fprintf(stderr, "extraneous argument to '-c'\n");
 793                         usage();
 794                         return (2);
 795                 }
 796
 797                 if (strcmp(cancel, "all") == 0) {
 798                         return (cancel_all_handlers());
 799                 } else {
 800                         int id = (int)strtol(cancel, &end, 10);
 801                         if (*end != '\0') {
 802                                 (void) fprintf(stderr, "invalid handle id '%s':"
 803                                     " must be an integer or 'all'\n", cancel);
 804                                 usage();
 805                                 return (1);
 806                         }
 807                         return (cancel_handler(id));
 808                 }
 809         }
 810
 811         if (device != NULL) {
 812                 /*
 813                  * Device (-d) injection uses a completely different mechanism
 814                  * for doing injection, so handle it separately here.
 815                  */
 816                 if (raw != NULL || range != NULL || type != TYPE_INVAL ||
 817                     level != 0 || record.zi_cmd != ZINJECT_UNINITIALIZED) {
 818                         (void) fprintf(stderr, "device (-d) incompatible with "
 819                             "data error injection\n");
 820                         usage();
 821                         return (2);
 822                 }
 823
 824                 if (argc != 1) {
 825                         (void) fprintf(stderr, "device (-d) injection requires "
 826                             "a single pool name\n");
 827                         usage();
 828                         return (2);
 829                 }
 830
 831                 (void) strcpy(pool, argv[0]);
 832                 dataset[0] = '\0';
 833
 834                 if (error == ECKSUM) {
 835                         (void) fprintf(stderr, "device error type must be "
 836                             "'io' or 'nxio'\n");
 837                         return (1);
 838                 }
 839
 840                 record.zi_iotype = io_type;
 841                 if (translate_device(pool, device, label, &record) != 0)
 842                         return (1);
 843                 if (!error)
 844                         error = ENXIO;
 845
 846                 if (action != VDEV_STATE_UNKNOWN)
 847                         return (perform_action(pool, &record, action));
 848
 849         } else if (raw != NULL) {
 850                 if (range != NULL || type != TYPE_INVAL || level != 0 ||
 851                     record.zi_cmd != ZINJECT_UNINITIALIZED) {
 852                         (void) fprintf(stderr, "raw (-b) format with "
 853                             "any other options\n");
 854                         usage();
 855                         return (2);
 856                 }
 857
 858                 if (argc != 1) {
 859                         (void) fprintf(stderr, "raw (-b) format expects a "
 860                             "single pool name\n");
 861                         usage();
 862                         return (2);
 863                 }
 864
 865                 (void) strcpy(pool, argv[0]);
 866                 dataset[0] = '\0';
 867
 868                 if (error == ENXIO) {
 869                         (void) fprintf(stderr, "data error type must be "
 870                             "'checksum' or 'io'\n");
 871                         return (1);
 872                 }
 873
 874                 record.zi_cmd = ZINJECT_DATA_FAULT;
 875                 if (translate_raw(raw, &record) != 0)
 876                         return (1);
 877                 if (!error)
 878                         error = EIO;
 879         } else if (record.zi_cmd == ZINJECT_PANIC) {
 880                 if (raw != NULL || range != NULL || type != TYPE_INVAL ||
 881                     level != 0 || device != NULL) {
 882                         (void) fprintf(stderr, "panic (-p) incompatible with "
 883                             "other options\n");
 884                         usage();
 885                         return (2);
 886                 }
 887
 888                 if (argc < 1 || argc > 2) {
 889                         (void) fprintf(stderr, "panic (-p) injection requires "
 890                             "a single pool name and an optional id\n");
 891                         usage();
 892                         return (2);
 893                 }
 894
 895                 (void) strcpy(pool, argv[0]);
 896                 if (argv[1] != NULL)
 897                         record.zi_type = atoi(argv[1]);
 898                 dataset[0] = '\0';
 899         } else if (record.zi_cmd == ZINJECT_IGNORED_WRITES) {
 900                 if (nowrites == 0) {
 901                         (void) fprintf(stderr, "-s or -g meaningless "
 902                             "without -I (ignore writes)\n");
 903                         usage();
 904                         return (2);
 905                 } else if (dur_secs && dur_txg) {
 906                         (void) fprintf(stderr, "choose a duration either "
 907                             "in seconds (-s) or a number of txgs (-g) "
 908                             "but not both\n");
 909                         usage();
 910                         return (2);
 911                 } else if (argc != 1) {
 912                         (void) fprintf(stderr, "ignore writes (-I) "
 913                             "injection requires a single pool name\n");
 914                         usage();
 915                         return (2);
 916                 }
 917
 918                 (void) strcpy(pool, argv[0]);
 919                 dataset[0] = '\0';
 920         } else if (type == TYPE_INVAL) {
 921                 if (flags == 0) {
 922                         (void) fprintf(stderr, "at least one of '-b', '-d', "
 923                             "'-t', '-a', '-p', '-I' or '-u' "
 924                             "must be specified\n");
 925                         usage();
 926                         return (2);
 927                 }
 928
 929                 if (argc == 1 && (flags & ZINJECT_UNLOAD_SPA)) {
 930                         (void) strcpy(pool, argv[0]);
 931                         dataset[0] = '\0';
 932                 } else if (argc != 0) {
 933                         (void) fprintf(stderr, "extraneous argument for "
 934                             "'-f'\n");
 935                         usage();
 936                         return (2);
 937                 }
 938
 939                 flags |= ZINJECT_NULL;
 940         } else {
 941                 if (argc != 1) {
 942                         (void) fprintf(stderr, "missing object\n");
 943                         usage();
 944                         return (2);
 945                 }
 946
 947                 if (error == ENXIO) {
 948                         (void) fprintf(stderr, "data error type must be "
 949                             "'checksum' or 'io'\n");
 950                         return (1);
 951                 }
 952
 953                 record.zi_cmd = ZINJECT_DATA_FAULT;
 954                 if (translate_record(type, argv[0], range, level, &record, pool,
 955                     dataset) != 0)
 956                         return (1);
 957                 if (!error)
 958                         error = EIO;
 959         }
 960
 961         /*
 962          * If this is pool-wide metadata, unmount everything.  The ioctl() will
 963          * unload the pool, so that we trigger spa-wide reopen of metadata next
 964          * time we access the pool.
 965          */
 966         if (dataset[0] != '\0' && domount) {
 967                 if ((zhp = zfs_open(g_zfs, dataset, ZFS_TYPE_DATASET)) == NULL)
 968                         return (1);
 969                 if (zfs_unmount(zhp, NULL, 0) != 0)
 970                         return (1);
 971         }
 972
 973         record.zi_error = error;
 974
 975         ret = register_handler(pool, flags, &record, quiet);
 976
 977         if (dataset[0] != '\0' && domount)
 978                 ret = (zfs_mount(zhp, NULL, 0) != 0);
 979
 980         libzfs_fini(g_zfs);
 981
 982         return (ret);
 983 }