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