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