sys/cam/ctl/ctl_ioctl.h

   1 /*-
   2  * Copyright (c) 2003 Silicon Graphics International Corp.
   3  * Copyright (c) 2011 Spectra Logic Corporation
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions, and the following disclaimer,
  11  *    without modification.
  12  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  13  *    substantially similar to the "NO WARRANTY" disclaimer below
  14  *    ("Disclaimer") and any redistribution must be conditioned upon
  15  *    including a substantially similar Disclaimer requirement for further
  16  *    binary redistribution.
  17  *
  18  * NO WARRANTY
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  27  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  28  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGES.
  30  *
  31  * $Id: //depot/users/kenm/FreeBSD-test2/sys/cam/ctl/ctl_ioctl.h#4 $
  32  * $FreeBSD$
  33  */
  34 /*
  35  * CAM Target Layer ioctl interface.
  36  *
  37  * Author: Ken Merry <ken@FreeBSD.org>
  38  */
  39
  40 #ifndef _CTL_IOCTL_H_
  41 #define _CTL_IOCTL_H_
  42
  43 #define CTL_DEFAULT_DEV         "/dev/cam/ctl"
  44 /*
  45  * Maximum number of targets we support.
  46  */
  47 #define CTL_MAX_TARGETS         1
  48
  49 /*
  50  * Maximum target ID we support.
  51  */
  52 #define CTL_MAX_TARGID          15
  53
  54 /*
  55  * Maximum number of LUNs we support at the moment.  MUST be a power of 2.
  56  */
  57 #define CTL_MAX_LUNS            256
  58
  59 /*
  60  * Maximum number of initiators per port.
  61  */
  62 #define CTL_MAX_INIT_PER_PORT   2048 // Was 16
  63
  64 /*
  65  * Maximum number of ports registered at one time.
  66  */
  67 #define CTL_MAX_PORTS           32
  68
  69 /*
  70  * Maximum number of initiators we support.
  71  */
  72 #define CTL_MAX_INITIATORS      (CTL_MAX_INIT_PER_PORT * CTL_MAX_PORTS)
  73
  74 /* Hopefully this won't conflict with new misc devices that pop up */
  75 #define CTL_MINOR       225
  76
  77 typedef enum {
  78         CTL_OOA_INVALID_LUN,
  79         CTL_OOA_SUCCESS
  80 } ctl_ooa_status;
  81
  82 struct ctl_ooa_info {
  83         uint32_t target_id;     /* Passed in to CTL */
  84         uint32_t lun_id;        /* Passed in to CTL */
  85         uint32_t num_entries;   /* Returned from CTL */
  86         ctl_ooa_status status;  /* Returned from CTL */
  87 };
  88
  89 struct ctl_hard_startstop_info {
  90         cfi_mt_status status;
  91         int total_luns;
  92         int luns_complete;
  93         int luns_failed;
  94 };
  95
  96 struct ctl_bbrread_info {
  97         int                     lun_num;        /* Passed in to CTL */
  98         uint64_t                lba;            /* Passed in to CTL */
  99         int                     len;            /* Passed in to CTL */
 100         cfi_mt_status           status;         /* Returned from CTL */
 101         cfi_bbrread_status      bbr_status;     /* Returned from CTL */
 102         uint8_t                 scsi_status;    /* Returned from CTL */
 103         struct scsi_sense_data  sense_data;     /* Returned from CTL */
 104 };
 105
 106 typedef enum {
 107         CTL_DELAY_TYPE_NONE,
 108         CTL_DELAY_TYPE_CONT,
 109         CTL_DELAY_TYPE_ONESHOT
 110 } ctl_delay_type;
 111
 112 typedef enum {
 113         CTL_DELAY_LOC_NONE,
 114         CTL_DELAY_LOC_DATAMOVE,
 115         CTL_DELAY_LOC_DONE,
 116 } ctl_delay_location;
 117
 118 typedef enum {
 119         CTL_DELAY_STATUS_NONE,
 120         CTL_DELAY_STATUS_OK,
 121         CTL_DELAY_STATUS_INVALID_LUN,
 122         CTL_DELAY_STATUS_INVALID_TYPE,
 123         CTL_DELAY_STATUS_INVALID_LOC,
 124         CTL_DELAY_STATUS_NOT_IMPLEMENTED
 125 } ctl_delay_status;
 126
 127 struct ctl_io_delay_info {
 128         uint32_t                target_id;
 129         uint32_t                lun_id;
 130         ctl_delay_type          delay_type;
 131         ctl_delay_location      delay_loc;
 132         uint32_t                delay_secs;
 133         ctl_delay_status        status;
 134 };
 135
 136 typedef enum {
 137         CTL_GS_SYNC_NONE,
 138         CTL_GS_SYNC_OK,
 139         CTL_GS_SYNC_NO_LUN
 140 } ctl_gs_sync_status;
 141
 142 /*
 143  * The target and LUN id specify which device to modify.  The sync interval
 144  * means that we will let through every N SYNCHRONIZE CACHE commands.
 145  */
 146 struct ctl_sync_info {
 147         uint32_t                target_id;      /* passed to kernel */
 148         uint32_t                lun_id;         /* passed to kernel */
 149         int                     sync_interval;  /* depends on whether get/set */
 150         ctl_gs_sync_status      status;         /* passed from kernel */
 151 };
 152
 153 typedef enum {
 154         CTL_STATS_NO_IO,
 155         CTL_STATS_READ,
 156         CTL_STATS_WRITE
 157 } ctl_stat_types;
 158 #define CTL_STATS_NUM_TYPES     3
 159
 160 typedef enum {
 161         CTL_LUN_STATS_NO_BLOCKSIZE      = 0x01
 162 } ctl_lun_stats_flags;
 163
 164 struct ctl_lun_io_port_stats {
 165         uint32_t                        targ_port;
 166         uint64_t                        bytes[CTL_STATS_NUM_TYPES];
 167         uint64_t                        operations[CTL_STATS_NUM_TYPES];
 168         struct bintime                  time[CTL_STATS_NUM_TYPES];
 169         uint64_t                        num_dmas[CTL_STATS_NUM_TYPES];
 170         struct bintime                  dma_time[CTL_STATS_NUM_TYPES];
 171 };
 172
 173 struct ctl_lun_io_stats {
 174         uint8_t                         device_type;
 175         uint64_t                        lun_number;
 176         uint32_t                        blocksize;
 177         ctl_lun_stats_flags             flags;
 178         struct ctl_lun_io_port_stats    ports[CTL_MAX_PORTS];
 179 };
 180
 181 typedef enum {
 182         CTL_SS_OK,
 183         CTL_SS_NEED_MORE_SPACE,
 184         CTL_SS_ERROR
 185 } ctl_stats_status;
 186
 187 typedef enum {
 188         CTL_STATS_FLAG_NONE             = 0x00,
 189         CTL_STATS_FLAG_TIME_VALID       = 0x01
 190 } ctl_stats_flags;
 191
 192 struct ctl_stats {
 193         int                     alloc_len;      /* passed to kernel */
 194         struct ctl_lun_io_stats *lun_stats;     /* passed to/from kernel */
 195         int                     fill_len;       /* passed to userland */
 196         int                     num_luns;       /* passed to userland */
 197         ctl_stats_status        status;         /* passed to userland */
 198         ctl_stats_flags         flags;          /* passed to userland */
 199         struct timespec         timestamp;      /* passed to userland */
 200 };
 201
 202 /*
 203  * The types of errors that can be injected:
 204  *
 205  * NONE:        No error specified.
 206  * ABORTED:     SSD_KEY_ABORTED_COMMAND, 0x45, 0x00
 207  * MEDIUM_ERR:  Medium error, different asc/ascq depending on read/write.
 208  * UA:          Unit attention.
 209  * CUSTOM:      User specifies the sense data.
 210  * TYPE:        Mask to use with error types.
 211  *
 212  * Flags that affect injection behavior:
 213  * CONTINUOUS:  This error will stay around until explicitly cleared.
 214  * DESCRIPTOR:  Use descriptor sense instead of fixed sense.
 215  */
 216 typedef enum {
 217         CTL_LUN_INJ_NONE                = 0x000,
 218         CTL_LUN_INJ_ABORTED             = 0x001,
 219         CTL_LUN_INJ_MEDIUM_ERR          = 0x002,
 220         CTL_LUN_INJ_UA                  = 0x003,
 221         CTL_LUN_INJ_CUSTOM              = 0x004,
 222         CTL_LUN_INJ_TYPE                = 0x0ff,
 223         CTL_LUN_INJ_CONTINUOUS          = 0x100,
 224         CTL_LUN_INJ_DESCRIPTOR          = 0x200
 225 } ctl_lun_error;
 226
 227 /*
 228  * Flags to specify what type of command the given error pattern will
 229  * execute on.  The first group of types can be ORed together.
 230  *
 231  * READ:        Any read command.
 232  * WRITE:       Any write command.
 233  * READWRITE:   Any read or write command.
 234  * READCAP:     Any read capacity command.
 235  * TUR:         Test Unit Ready.
 236  * ANY:         Any command.
 237  * MASK:        Mask for basic command patterns.
 238  *
 239  * Special types:
 240  *
 241  * CMD:         The CDB to act on is specified in struct ctl_error_desc_cmd.
 242  * RANGE:       For read/write commands, act when the LBA is in the
 243  *              specified range.
 244  */
 245 typedef enum {
 246         CTL_LUN_PAT_NONE        = 0x000,
 247         CTL_LUN_PAT_READ        = 0x001,
 248         CTL_LUN_PAT_WRITE       = 0x002,
 249         CTL_LUN_PAT_READWRITE   = CTL_LUN_PAT_READ | CTL_LUN_PAT_WRITE,
 250         CTL_LUN_PAT_READCAP     = 0x004,
 251         CTL_LUN_PAT_TUR         = 0x008,
 252         CTL_LUN_PAT_ANY         = 0x0ff,
 253         CTL_LUN_PAT_MASK        = 0x0ff,
 254         CTL_LUN_PAT_CMD         = 0x100,
 255         CTL_LUN_PAT_RANGE       = 0x200
 256 } ctl_lun_error_pattern;
 257
 258 /*
 259  * This structure allows the user to specify a particular CDB pattern to
 260  * look for.
 261  *
 262  * cdb_pattern:         Fill in the relevant bytes to look for in the CDB.
 263  * cdb_valid_bytes:     Bitmask specifying valid bytes in the cdb_pattern.
 264  * flags:               Specify any command flags (see ctl_io_flags) that
 265  *                      should be set.
 266  */
 267 struct ctl_error_desc_cmd {
 268         uint8_t         cdb_pattern[CTL_MAX_CDBLEN];
 269         uint32_t        cdb_valid_bytes;
 270         uint32_t        flags;
 271 };
 272
 273 /*
 274  * Error injection descriptor.
 275  *
 276  * target_id:      Target ID to act on.
 277  * lun_id          LUN to act on.
 278  * lun_error:      The type of error to inject.  See above for descriptions.
 279  * error_pattern:  What kind of command to act on.  See above.
 280  * cmd_desc:       For CTL_LUN_PAT_CMD only.
 281  * lba_range:      For CTL_LUN_PAT_RANGE only.
 282  * custom_sense:   Specify sense.  For CTL_LUN_INJ_CUSTOM only.
 283  * serial:         Serial number returned by the kernel.  Use for deletion.
 284  * links:          Kernel use only.
 285  */
 286 struct ctl_error_desc {
 287         uint32_t                        target_id;      /* To kernel */
 288         uint32_t                        lun_id;         /* To kernel */
 289         ctl_lun_error                   lun_error;      /* To kernel */
 290         ctl_lun_error_pattern           error_pattern;  /* To kernel */
 291         struct ctl_error_desc_cmd       cmd_desc;       /* To kernel */
 292         struct ctl_lba_len              lba_range;      /* To kernel */
 293         struct scsi_sense_data          custom_sense;   /* To kernel */
 294         uint64_t                        serial;         /* From kernel */
 295         STAILQ_ENTRY(ctl_error_desc)    links;          /* Kernel use only */
 296 };
 297
 298 typedef enum {
 299         CTL_OOA_FLAG_NONE       = 0x00,
 300         CTL_OOA_FLAG_ALL_LUNS   = 0x01
 301 } ctl_ooa_flags;
 302
 303 typedef enum {
 304         CTL_OOA_OK,
 305         CTL_OOA_NEED_MORE_SPACE,
 306         CTL_OOA_ERROR
 307 } ctl_get_ooa_status;
 308
 309 typedef enum {
 310         CTL_OOACMD_FLAG_NONE            = 0x00,
 311         CTL_OOACMD_FLAG_DMA             = 0x01,
 312         CTL_OOACMD_FLAG_BLOCKED         = 0x02,
 313         CTL_OOACMD_FLAG_ABORT           = 0x04,
 314         CTL_OOACMD_FLAG_RTR             = 0x08,
 315         CTL_OOACMD_FLAG_DMA_QUEUED      = 0x10
 316 } ctl_ooa_cmd_flags;
 317
 318 struct ctl_ooa_entry {
 319         ctl_ooa_cmd_flags       cmd_flags;
 320         uint8_t                 cdb[CTL_MAX_CDBLEN];
 321         uint8_t                 cdb_len;
 322         uint32_t                tag_num;
 323         uint32_t                lun_num;
 324         struct bintime          start_bt;
 325 };
 326
 327 struct ctl_ooa {
 328         ctl_ooa_flags           flags;          /* passed to kernel */
 329         uint64_t                lun_num;        /* passed to kernel */
 330         uint32_t                alloc_len;      /* passed to kernel */
 331         uint32_t                alloc_num;      /* passed to kernel */
 332         struct ctl_ooa_entry    *entries;       /* filled in kernel */
 333         uint32_t                fill_len;       /* passed to userland */
 334         uint32_t                fill_num;       /* passed to userland */
 335         uint32_t                dropped_num;    /* passed to userland */
 336         struct bintime          cur_bt;         /* passed to userland */
 337         ctl_get_ooa_status      status;         /* passed to userland */
 338 };
 339
 340 typedef enum {
 341         CTL_PORT_LIST_NONE,
 342         CTL_PORT_LIST_OK,
 343         CTL_PORT_LIST_NEED_MORE_SPACE,
 344         CTL_PORT_LIST_ERROR
 345 } ctl_port_list_status;
 346
 347 struct ctl_port_list {
 348         uint32_t                alloc_len;      /* passed to kernel */
 349         uint32_t                alloc_num;      /* passed to kernel */
 350         struct ctl_port_entry   *entries;       /* filled in kernel */
 351         uint32_t                fill_len;       /* passed to userland */
 352         uint32_t                fill_num;       /* passed to userland */
 353         uint32_t                dropped_num;    /* passed to userland */
 354         ctl_port_list_status    status;         /* passed to userland */
 355 };
 356
 357 typedef enum {
 358         CTL_LUN_NOSTATUS,
 359         CTL_LUN_OK,
 360         CTL_LUN_ERROR
 361 } ctl_lun_status;
 362
 363 #define CTL_ERROR_STR_LEN       160
 364
 365 #define CTL_BEARG_RD            0x01
 366 #define CTL_BEARG_WR            0x02
 367 #define CTL_BEARG_RW            (CTL_BEARG_RD|CTL_BEARG_WR)
 368 #define CTL_BEARG_ASCII         0x04
 369
 370 /*
 371  * Backend Argument:
 372  *
 373  * namelen:     Length of the name field, including the terminating NUL.
 374  *
 375  * name:        Name of the paramter.  This must be NUL-terminated.
 376  *
 377  * flags:       Flags for the parameter, see above for values.
 378  *
 379  * vallen:      Length of the value in bytes.
 380  *
 381  * value:       Value to be set/fetched.
 382  *
 383  * kname:       For kernel use only.
 384  *
 385  * kvalue:      For kernel use only.
 386  */
 387 struct ctl_be_arg {
 388         int     namelen;
 389         char    *name;
 390         int     flags;
 391         int     vallen;
 392         void    *value;
 393
 394         char    *kname;
 395         void    *kvalue;
 396 };
 397
 398 typedef enum {
 399         CTL_LUNREQ_CREATE,
 400         CTL_LUNREQ_RM,
 401         CTL_LUNREQ_MODIFY,
 402 } ctl_lunreq_type;
 403
 404
 405 /*
 406  * LUN creation parameters:
 407  *
 408  * flags:               Various LUN flags, see ctl_backend.h for a
 409  *                      description of the flag values and meanings.
 410  *
 411  * device_type:         The SCSI device type.  e.g. 0 for Direct Access,
 412  *                      3 for Processor, etc.  Only certain backends may
 413  *                      support setting this field.  The CTL_LUN_FLAG_DEV_TYPE
 414  *                      flag should be set in the flags field if the device
 415  *                      type is set.
 416  *
 417  * lun_size_bytes:      The size of the LUN in bytes.  For some backends
 418  *                      this is relevant (e.g. ramdisk), for others, it may
 419  *                      be ignored in favor of using the properties of the
 420  *                      backing store.  If specified, this should be a
 421  *                      multiple of the blocksize.
 422  *
 423  *                      The actual size of the LUN is returned in this
 424  *                      field.
 425  *
 426  * blocksize_bytes:     The LUN blocksize in bytes.  For some backends this
 427  *                      is relevant, for others it may be ignored in
 428  *                      favor of using the properties of the backing store.
 429  *
 430  *                      The actual blocksize of the LUN is returned in this
 431  *                      field.
 432  *
 433  * req_lun_id:          The requested LUN ID.  The CTL_LUN_FLAG_ID_REQ flag
 434  *                      should be set if this is set.  The request will be
 435  *                      granted if the LUN number is available, otherwise
 436  *                      the LUN addition request will fail.
 437  *
 438  *                      The allocated LUN number is returned in this field.
 439  *
 440  * serial_num:          This is the value returned in SCSI INQUIRY VPD page
 441  *                      0x80.  If it is specified, the CTL_LUN_FLAG_SERIAL_NUM
 442  *                      flag should be set.
 443  *
 444  *                      The serial number value used is returned in this
 445  *                      field.
 446  *
 447  * device_id:           This is the value returned in the T10 vendor ID
 448  *                      based DESIGNATOR field in the SCSI INQUIRY VPD page
 449  *                      0x83 data.  If it is specified, the CTL_LUN_FLAG_DEVID
 450  *                      flag should be set.
 451  *
 452  *                      The device id value used is returned in this field.
 453  */
 454 struct ctl_lun_create_params {
 455         ctl_backend_lun_flags   flags;
 456         uint8_t                 device_type;
 457         uint64_t                lun_size_bytes;
 458         uint32_t                blocksize_bytes;
 459         uint32_t                req_lun_id;
 460         uint8_t                 serial_num[CTL_SN_LEN];
 461         uint8_t                 device_id[CTL_DEVID_LEN];
 462 };
 463
 464 /*
 465  * LUN removal parameters:
 466  *
 467  * lun_id:              The number of the LUN to delete.  This must be set.
 468  *                      The LUN must be backed by the given backend.
 469  */
 470 struct ctl_lun_rm_params {
 471         uint32_t                lun_id;
 472 };
 473
 474 /*
 475  * LUN modification parameters:
 476  *
 477  * lun_id:              The number of the LUN to modify.  This must be set.
 478  *                      The LUN must be backed by the given backend.
 479  *
 480  * lun_size_bytes:      The size of the LUN in bytes.  If zero, update
 481  *                      the size using the backing file size, if possible.
 482  */
 483 struct ctl_lun_modify_params {
 484         uint32_t                lun_id;
 485         uint64_t                lun_size_bytes;
 486 };
 487
 488 /*
 489  * Union of request type data.  Fill in the appropriate union member for
 490  * the request type.
 491  */
 492 union ctl_lunreq_data {
 493         struct ctl_lun_create_params    create;
 494         struct ctl_lun_rm_params        rm;
 495         struct ctl_lun_modify_params    modify;
 496 };
 497
 498 /*
 499  * LUN request interface:
 500  *
 501  * backend:             This is required, and is NUL-terminated a string
 502  *                      that is the name of the backend, like "ramdisk" or
 503  *                      "block".
 504  *
 505  * reqtype:             The type of request, CTL_LUNREQ_CREATE to create a
 506  *                      LUN, CTL_LUNREQ_RM to delete a LUN.
 507  *
 508  * reqdata:             Request type-specific information.  See the
 509  *                      description of individual the union members above
 510  *                      for more information.
 511  *
 512  * num_be_args:         This is the number of backend-specific arguments
 513  *                      in the be_args array.
 514  *
 515  * be_args:             This is an array of backend-specific arguments.
 516  *                      See above for a description of the fields in this
 517  *                      structure.
 518  *
 519  * status:              Status of the LUN request.
 520  *
 521  * error_str:           If the status is CTL_LUN_ERROR, this will
 522  *                      contain a string describing the error.
 523  *
 524  * kern_be_args:        For kernel use only.
 525  */
 526 struct ctl_lun_req {
 527         char                    backend[CTL_BE_NAME_LEN];
 528         ctl_lunreq_type         reqtype;
 529         union ctl_lunreq_data   reqdata;
 530         int                     num_be_args;
 531         struct ctl_be_arg       *be_args;
 532         ctl_lun_status          status;
 533         char                    error_str[CTL_ERROR_STR_LEN];
 534         struct ctl_be_arg       *kern_be_args;
 535 };
 536
 537 /*
 538  * LUN list status:
 539  *
 540  * NONE:                No status.
 541  *
 542  * OK:                  Request completed successfully.
 543  *
 544  * NEED_MORE_SPACE:     The allocated length of the entries field is too
 545  *                      small for the available data.
 546  *
 547  * ERROR:               An error occured, look at the error string for a
 548  *                      description of the error.
 549  */
 550 typedef enum {
 551         CTL_LUN_LIST_NONE,
 552         CTL_LUN_LIST_OK,
 553         CTL_LUN_LIST_NEED_MORE_SPACE,
 554         CTL_LUN_LIST_ERROR
 555 } ctl_lun_list_status;
 556
 557 /*
 558  * LUN list interface
 559  *
 560  * backend_name:        This is a NUL-terminated string.  If the string
 561  *                      length is 0, then all LUNs on all backends will
 562  *                      be enumerated.  Otherwise this is the name of the
 563  *                      backend to be enumerated, like "ramdisk" or "block".
 564  *
 565  * alloc_len:           The length of the data buffer allocated for entries.
 566  *                      In order to properly size the buffer, make one call
 567  *                      with alloc_len set to 0, and then use the returned
 568  *                      dropped_len as the buffer length to allocate and
 569  *                      pass in on a subsequent call.
 570  *
 571  * lun_xml:             XML-formatted information on the requested LUNs.
 572  *
 573  * fill_len:            The amount of data filled in the storage for entries.
 574  *
 575  * status:              The status of the request.  See above for the
 576  *                      description of the values of this field.
 577  *
 578  * error_str:           If the status indicates an error, this string will
 579  *                      be filled in to describe the error.
 580  */
 581 struct ctl_lun_list {
 582         char                    backend[CTL_BE_NAME_LEN]; /* passed to kernel*/
 583         uint32_t                alloc_len;      /* passed to kernel */
 584         char                   *lun_xml;        /* filled in kernel */
 585         uint32_t                fill_len;       /* passed to userland */
 586         ctl_lun_list_status     status;         /* passed to userland */
 587         char                    error_str[CTL_ERROR_STR_LEN];
 588                                                 /* passed to userland */
 589 };
 590
 591 #define CTL_IO                  _IOWR(CTL_MINOR, 0x00, union ctl_io)
 592 #define CTL_ENABLE_PORT         _IOW(CTL_MINOR, 0x04, struct ctl_port_entry)
 593 #define CTL_DISABLE_PORT        _IOW(CTL_MINOR, 0x05, struct ctl_port_entry)
 594 #define CTL_DUMP_OOA            _IO(CTL_MINOR, 0x06)
 595 #define CTL_CHECK_OOA           _IOWR(CTL_MINOR, 0x07, struct ctl_ooa_info)
 596 #define CTL_HARD_STOP           _IOR(CTL_MINOR, 0x08, \
 597                                      struct ctl_hard_startstop_info)
 598 #define CTL_HARD_START          _IOR(CTL_MINOR, 0x09, \
 599                                      struct ctl_hard_startstop_info)
 600 #define CTL_DELAY_IO            _IOWR(CTL_MINOR, 0x10, struct ctl_io_delay_info)
 601 #define CTL_REALSYNC_GET        _IOR(CTL_MINOR, 0x11, int)
 602 #define CTL_REALSYNC_SET        _IOW(CTL_MINOR, 0x12, int)
 603 #define CTL_SETSYNC             _IOWR(CTL_MINOR, 0x13, struct ctl_sync_info)
 604 #define CTL_GETSYNC             _IOWR(CTL_MINOR, 0x14, struct ctl_sync_info)
 605 #define CTL_GETSTATS            _IOWR(CTL_MINOR, 0x15, struct ctl_stats)
 606 #define CTL_ERROR_INJECT        _IOWR(CTL_MINOR, 0x16, struct ctl_error_desc)
 607 #define CTL_BBRREAD             _IOWR(CTL_MINOR, 0x17, struct ctl_bbrread_info)
 608 #define CTL_GET_OOA             _IOWR(CTL_MINOR, 0x18, struct ctl_ooa)
 609 #define CTL_DUMP_STRUCTS        _IO(CTL_MINOR, 0x19)
 610 #define CTL_GET_PORT_LIST       _IOWR(CTL_MINOR, 0x20, struct ctl_port_list)
 611 #define CTL_LUN_REQ             _IOWR(CTL_MINOR, 0x21, struct ctl_lun_req)
 612 #define CTL_LUN_LIST            _IOWR(CTL_MINOR, 0x22, struct ctl_lun_list)
 613 #define CTL_ERROR_INJECT_DELETE _IOW(CTL_MINOR, 0x23, struct ctl_error_desc)
 614 #define CTL_SET_PORT_WWNS       _IOW(CTL_MINOR, 0x24, struct ctl_port_entry)
 615
 616 #endif /* _CTL_IOCTL_H_ */
 617
 618 /*
 619  * vim: ts=8
 620  */