sys/cam/ctl/ctl_ioctl.h

   1 /*-
   2  * Copyright (c) 2003 Silicon Graphics International Corp.
   3  * Copyright (c) 2011 Spectra Logic Corporation
   4  * Copyright (c) 2014-2017 Alexander Motin <mav@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions, and the following disclaimer,
  12  *    without modification.
  13  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  14  *    substantially similar to the "NO WARRANTY" disclaimer below
  15  *    ("Disclaimer") and any redistribution must be conditioned upon
  16  *    including a substantially similar Disclaimer requirement for further
  17  *    binary redistribution.
  18  *
  19  * NO WARRANTY
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  28  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  29  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGES.
  31  *
  32  * $Id: //depot/users/kenm/FreeBSD-test2/sys/cam/ctl/ctl_ioctl.h#4 $
  33  * $FreeBSD$
  34  */
  35 /*
  36  * CAM Target Layer ioctl interface.
  37  *
  38  * Author: Ken Merry <ken@FreeBSD.org>
  39  */
  40
  41 #ifndef _CTL_IOCTL_H_
  42 #define _CTL_IOCTL_H_
  43
  44 #ifdef ICL_KERNEL_PROXY
  45 #include <sys/socket.h>
  46 #endif
  47
  48 #include <sys/ioccom.h>
  49
  50 #define CTL_DEFAULT_DEV         "/dev/cam/ctl"
  51 /*
  52  * Maximum number of targets we support.
  53  */
  54 #define CTL_MAX_TARGETS         1
  55
  56 /*
  57  * Maximum target ID we support.
  58  */
  59 #define CTL_MAX_TARGID          15
  60
  61 /*
  62  * Maximum number of LUNs we support at the moment.  MUST be a power of 2.
  63  */
  64 #define CTL_MAX_LUNS            1024
  65
  66 /*
  67  * Maximum number of initiators per port.
  68  */
  69 #define CTL_MAX_INIT_PER_PORT   2048
  70
  71 /*
  72  * Maximum number of ports registered at one time.
  73  */
  74 #define CTL_MAX_PORTS           256
  75
  76 /*
  77  * Maximum number of initiators we support.
  78  */
  79 #define CTL_MAX_INITIATORS      (CTL_MAX_INIT_PER_PORT * CTL_MAX_PORTS)
  80
  81 /* Hopefully this won't conflict with new misc devices that pop up */
  82 #define CTL_MINOR       225
  83
  84 /* Legacy statistics accumulated for every port for every LU. */
  85 #define CTL_LEGACY_STATS        1
  86
  87 typedef enum {
  88         CTL_DELAY_TYPE_NONE,
  89         CTL_DELAY_TYPE_CONT,
  90         CTL_DELAY_TYPE_ONESHOT
  91 } ctl_delay_type;
  92
  93 typedef enum {
  94         CTL_DELAY_LOC_NONE,
  95         CTL_DELAY_LOC_DATAMOVE,
  96         CTL_DELAY_LOC_DONE,
  97 } ctl_delay_location;
  98
  99 typedef enum {
 100         CTL_DELAY_STATUS_NONE,
 101         CTL_DELAY_STATUS_OK,
 102         CTL_DELAY_STATUS_INVALID_LUN,
 103         CTL_DELAY_STATUS_INVALID_TYPE,
 104         CTL_DELAY_STATUS_INVALID_LOC,
 105         CTL_DELAY_STATUS_NOT_IMPLEMENTED
 106 } ctl_delay_status;
 107
 108 struct ctl_io_delay_info {
 109         uint32_t                lun_id;
 110         ctl_delay_type          delay_type;
 111         ctl_delay_location      delay_loc;
 112         uint32_t                delay_secs;
 113         ctl_delay_status        status;
 114 };
 115
 116 typedef enum {
 117         CTL_STATS_NO_IO,
 118         CTL_STATS_READ,
 119         CTL_STATS_WRITE
 120 } ctl_stat_types;
 121 #define CTL_STATS_NUM_TYPES     3
 122
 123 typedef enum {
 124         CTL_SS_OK,
 125         CTL_SS_NEED_MORE_SPACE,
 126         CTL_SS_ERROR
 127 } ctl_stats_status;
 128
 129 typedef enum {
 130         CTL_STATS_FLAG_NONE             = 0x00,
 131         CTL_STATS_FLAG_TIME_VALID       = 0x01
 132 } ctl_stats_flags;
 133
 134 #ifdef CTL_LEGACY_STATS
 135 typedef enum {
 136         CTL_LUN_STATS_NO_BLOCKSIZE      = 0x01
 137 } ctl_lun_stats_flags;
 138
 139 struct ctl_lun_io_port_stats {
 140         uint32_t                        targ_port;
 141         uint64_t                        bytes[CTL_STATS_NUM_TYPES];
 142         uint64_t                        operations[CTL_STATS_NUM_TYPES];
 143         struct bintime                  time[CTL_STATS_NUM_TYPES];
 144         uint64_t                        num_dmas[CTL_STATS_NUM_TYPES];
 145         struct bintime                  dma_time[CTL_STATS_NUM_TYPES];
 146 };
 147
 148 struct ctl_lun_io_stats {
 149         uint8_t                         device_type;
 150         uint64_t                        lun_number;
 151         uint32_t                        blocksize;
 152         ctl_lun_stats_flags             flags;
 153         struct ctl_lun_io_port_stats    ports[CTL_MAX_PORTS];
 154 };
 155
 156 struct ctl_stats {
 157         int                     alloc_len;      /* passed to kernel */
 158         struct ctl_lun_io_stats *lun_stats;     /* passed to/from kernel */
 159         int                     fill_len;       /* passed to userland */
 160         int                     num_luns;       /* passed to userland */
 161         ctl_stats_status        status;         /* passed to userland */
 162         ctl_stats_flags         flags;          /* passed to userland */
 163         struct timespec         timestamp;      /* passed to userland */
 164 };
 165 #endif /* CTL_LEGACY_STATS */
 166
 167 struct ctl_io_stats {
 168         uint32_t                        item;
 169         uint64_t                        bytes[CTL_STATS_NUM_TYPES];
 170         uint64_t                        operations[CTL_STATS_NUM_TYPES];
 171         uint64_t                        dmas[CTL_STATS_NUM_TYPES];
 172         struct bintime                  time[CTL_STATS_NUM_TYPES];
 173         struct bintime                  dma_time[CTL_STATS_NUM_TYPES];
 174 };
 175
 176 struct ctl_get_io_stats {
 177         struct ctl_io_stats     *stats;         /* passed to/from kernel */
 178         size_t                  alloc_len;      /* passed to kernel */
 179         size_t                  fill_len;       /* passed to userland */
 180         int                     first_item;     /* passed to kernel */
 181         int                     num_items;      /* passed to userland */
 182         ctl_stats_status        status;         /* passed to userland */
 183         ctl_stats_flags         flags;          /* passed to userland */
 184         struct timespec         timestamp;      /* passed to userland */
 185 };
 186
 187 /*
 188  * The types of errors that can be injected:
 189  *
 190  * NONE:        No error specified.
 191  * ABORTED:     SSD_KEY_ABORTED_COMMAND, 0x45, 0x00
 192  * MEDIUM_ERR:  Medium error, different asc/ascq depending on read/write.
 193  * UA:          Unit attention.
 194  * CUSTOM:      User specifies the sense data.
 195  * TYPE:        Mask to use with error types.
 196  *
 197  * Flags that affect injection behavior:
 198  * CONTINUOUS:  This error will stay around until explicitly cleared.
 199  * DESCRIPTOR:  Use descriptor sense instead of fixed sense.
 200  */
 201 typedef enum {
 202         CTL_LUN_INJ_NONE                = 0x000,
 203         CTL_LUN_INJ_ABORTED             = 0x001,
 204         CTL_LUN_INJ_MEDIUM_ERR          = 0x002,
 205         CTL_LUN_INJ_UA                  = 0x003,
 206         CTL_LUN_INJ_CUSTOM              = 0x004,
 207         CTL_LUN_INJ_TYPE                = 0x0ff,
 208         CTL_LUN_INJ_CONTINUOUS          = 0x100,
 209         CTL_LUN_INJ_DESCRIPTOR          = 0x200
 210 } ctl_lun_error;
 211
 212 /*
 213  * Flags to specify what type of command the given error pattern will
 214  * execute on.  The first group of types can be ORed together.
 215  *
 216  * READ:        Any read command.
 217  * WRITE:       Any write command.
 218  * READWRITE:   Any read or write command.
 219  * READCAP:     Any read capacity command.
 220  * TUR:         Test Unit Ready.
 221  * ANY:         Any command.
 222  * MASK:        Mask for basic command patterns.
 223  *
 224  * Special types:
 225  *
 226  * CMD:         The CDB to act on is specified in struct ctl_error_desc_cmd.
 227  * RANGE:       For read/write commands, act when the LBA is in the
 228  *              specified range.
 229  */
 230 typedef enum {
 231         CTL_LUN_PAT_NONE        = 0x000,
 232         CTL_LUN_PAT_READ        = 0x001,
 233         CTL_LUN_PAT_WRITE       = 0x002,
 234         CTL_LUN_PAT_READWRITE   = CTL_LUN_PAT_READ | CTL_LUN_PAT_WRITE,
 235         CTL_LUN_PAT_READCAP     = 0x004,
 236         CTL_LUN_PAT_TUR         = 0x008,
 237         CTL_LUN_PAT_ANY         = 0x0ff,
 238         CTL_LUN_PAT_MASK        = 0x0ff,
 239         CTL_LUN_PAT_CMD         = 0x100,
 240         CTL_LUN_PAT_RANGE       = 0x200
 241 } ctl_lun_error_pattern;
 242
 243 /*
 244  * This structure allows the user to specify a particular CDB pattern to
 245  * look for.
 246  *
 247  * cdb_pattern:         Fill in the relevant bytes to look for in the CDB.
 248  * cdb_valid_bytes:     Bitmask specifying valid bytes in the cdb_pattern.
 249  * flags:               Specify any command flags (see ctl_io_flags) that
 250  *                      should be set.
 251  */
 252 struct ctl_error_desc_cmd {
 253         uint8_t         cdb_pattern[CTL_MAX_CDBLEN];
 254         uint32_t        cdb_valid_bytes;
 255         uint32_t        flags;
 256 };
 257
 258 /*
 259  * Error injection descriptor.
 260  *
 261  * lun_id          LUN to act on.
 262  * lun_error:      The type of error to inject.  See above for descriptions.
 263  * error_pattern:  What kind of command to act on.  See above.
 264  * cmd_desc:       For CTL_LUN_PAT_CMD only.
 265  * lba_range:      For CTL_LUN_PAT_RANGE only.
 266  * custom_sense:   Specify sense.  For CTL_LUN_INJ_CUSTOM only.
 267  * serial:         Serial number returned by the kernel.  Use for deletion.
 268  * links:          Kernel use only.
 269  */
 270 struct ctl_error_desc {
 271         uint32_t                        lun_id;         /* To kernel */
 272         ctl_lun_error                   lun_error;      /* To kernel */
 273         ctl_lun_error_pattern           error_pattern;  /* To kernel */
 274         struct ctl_error_desc_cmd       cmd_desc;       /* To kernel */
 275         struct ctl_lba_len              lba_range;      /* To kernel */
 276         struct scsi_sense_data          custom_sense;   /* To kernel */
 277         uint64_t                        serial;         /* From kernel */
 278         STAILQ_ENTRY(ctl_error_desc)    links;          /* Kernel use only */
 279 };
 280
 281 typedef enum {
 282         CTL_OOA_FLAG_NONE       = 0x00,
 283         CTL_OOA_FLAG_ALL_LUNS   = 0x01
 284 } ctl_ooa_flags;
 285
 286 typedef enum {
 287         CTL_OOA_OK,
 288         CTL_OOA_NEED_MORE_SPACE,
 289         CTL_OOA_ERROR
 290 } ctl_get_ooa_status;
 291
 292 typedef enum {
 293         CTL_OOACMD_FLAG_NONE            = 0x00,
 294         CTL_OOACMD_FLAG_DMA             = 0x01,
 295         CTL_OOACMD_FLAG_BLOCKED         = 0x02,
 296         CTL_OOACMD_FLAG_ABORT           = 0x04,
 297         CTL_OOACMD_FLAG_RTR             = 0x08,
 298         CTL_OOACMD_FLAG_DMA_QUEUED      = 0x10
 299 } ctl_ooa_cmd_flags;
 300
 301 struct ctl_ooa_entry {
 302         ctl_ooa_cmd_flags       cmd_flags;
 303         uint8_t                 cdb[CTL_MAX_CDBLEN];
 304         uint8_t                 cdb_len;
 305         uint32_t                tag_num;
 306         uint32_t                lun_num;
 307         struct bintime          start_bt;
 308 };
 309
 310 struct ctl_ooa {
 311         ctl_ooa_flags           flags;          /* passed to kernel */
 312         uint64_t                lun_num;        /* passed to kernel */
 313         uint32_t                alloc_len;      /* passed to kernel */
 314         uint32_t                alloc_num;      /* passed to kernel */
 315         struct ctl_ooa_entry    *entries;       /* filled in kernel */
 316         uint32_t                fill_len;       /* passed to userland */
 317         uint32_t                fill_num;       /* passed to userland */
 318         uint32_t                dropped_num;    /* passed to userland */
 319         struct bintime          cur_bt;         /* passed to userland */
 320         ctl_get_ooa_status      status;         /* passed to userland */
 321 };
 322
 323 typedef enum {
 324         CTL_LUN_NOSTATUS,
 325         CTL_LUN_OK,
 326         CTL_LUN_ERROR,
 327         CTL_LUN_WARNING
 328 } ctl_lun_status;
 329
 330 #define CTL_ERROR_STR_LEN       160
 331
 332 #define CTL_BEARG_RD            0x01
 333 #define CTL_BEARG_WR            0x02
 334 #define CTL_BEARG_RW            (CTL_BEARG_RD|CTL_BEARG_WR)
 335 #define CTL_BEARG_ASCII         0x04
 336
 337 /*
 338  * Backend Argument:
 339  *
 340  * namelen:     Length of the name field, including the terminating NUL.
 341  *
 342  * name:        Name of the parameter.  This must be NUL-terminated.
 343  *
 344  * flags:       Flags for the parameter, see above for values.
 345  *
 346  * vallen:      Length of the value in bytes.
 347  *
 348  * value:       Value to be set/fetched.
 349  *
 350  * kname:       For kernel use only.
 351  *
 352  * kvalue:      For kernel use only.
 353  */
 354 struct ctl_be_arg {
 355         int     namelen;
 356         char    *name;
 357         int     flags;
 358         int     vallen;
 359         void    *value;
 360
 361         char    *kname;
 362         void    *kvalue;
 363 };
 364
 365 typedef enum {
 366         CTL_LUNREQ_CREATE,
 367         CTL_LUNREQ_RM,
 368         CTL_LUNREQ_MODIFY,
 369 } ctl_lunreq_type;
 370
 371 /*
 372  * The ID_REQ flag is used to say that the caller has requested a
 373  * particular LUN ID in the req_lun_id field.  If we cannot allocate that
 374  * LUN ID, the ctl_add_lun() call will fail.
 375  *
 376  * The STOPPED flag tells us that the LUN should default to the powered
 377  * off state.  It will return 0x04,0x02 until it is powered up.  ("Logical
 378  * unit not ready, initializing command required.")
 379  *
 380  * The NO_MEDIA flag tells us that the LUN has no media inserted.
 381  *
 382  * The PRIMARY flag tells us that this LUN is registered as a Primary LUN
 383  * which is accessible via the Master shelf controller in an HA. This flag
 384  * being set indicates a Primary LUN. This flag being reset represents a
 385  * Secondary LUN controlled by the Secondary controller in an HA
 386  * configuration. Flag is applicable at this time to T_DIRECT types.
 387  *
 388  * The SERIAL_NUM flag tells us that the serial_num field is filled in and
 389  * valid for use in SCSI INQUIRY VPD page 0x80.
 390  *
 391  * The DEVID flag tells us that the device_id field is filled in and
 392  * valid for use in SCSI INQUIRY VPD page 0x83.
 393  *
 394  * The DEV_TYPE flag tells us that the device_type field is filled in.
 395  *
 396  * The EJECTED flag tells us that the removable LUN has tray open.
 397  *
 398  * The UNMAP flag tells us that this LUN supports UNMAP.
 399  *
 400  * The OFFLINE flag tells us that this LUN can not access backing store.
 401  */
 402 typedef enum {
 403         CTL_LUN_FLAG_ID_REQ             = 0x01,
 404         CTL_LUN_FLAG_STOPPED            = 0x02,
 405         CTL_LUN_FLAG_NO_MEDIA           = 0x04,
 406         CTL_LUN_FLAG_PRIMARY            = 0x08,
 407         CTL_LUN_FLAG_SERIAL_NUM         = 0x10,
 408         CTL_LUN_FLAG_DEVID              = 0x20,
 409         CTL_LUN_FLAG_DEV_TYPE           = 0x40,
 410         CTL_LUN_FLAG_UNMAP              = 0x80,
 411         CTL_LUN_FLAG_EJECTED            = 0x100,
 412         CTL_LUN_FLAG_READONLY           = 0x200
 413 } ctl_backend_lun_flags;
 414
 415 /*
 416  * LUN creation parameters:
 417  *
 418  * flags:               Various LUN flags, see above.
 419  *
 420  * device_type:         The SCSI device type.  e.g. 0 for Direct Access,
 421  *                      3 for Processor, etc.  Only certain backends may
 422  *                      support setting this field.  The CTL_LUN_FLAG_DEV_TYPE
 423  *                      flag should be set in the flags field if the device
 424  *                      type is set.
 425  *
 426  * lun_size_bytes:      The size of the LUN in bytes.  For some backends
 427  *                      this is relevant (e.g. ramdisk), for others, it may
 428  *                      be ignored in favor of using the properties of the
 429  *                      backing store.  If specified, this should be a
 430  *                      multiple of the blocksize.
 431  *
 432  *                      The actual size of the LUN is returned in this
 433  *                      field.
 434  *
 435  * blocksize_bytes:     The LUN blocksize in bytes.  For some backends this
 436  *                      is relevant, for others it may be ignored in
 437  *                      favor of using the properties of the backing store.
 438  *
 439  *                      The actual blocksize of the LUN is returned in this
 440  *                      field.
 441  *
 442  * req_lun_id:          The requested LUN ID.  The CTL_LUN_FLAG_ID_REQ flag
 443  *                      should be set if this is set.  The request will be
 444  *                      granted if the LUN number is available, otherwise
 445  *                      the LUN addition request will fail.
 446  *
 447  *                      The allocated LUN number is returned in this field.
 448  *
 449  * serial_num:          This is the value returned in SCSI INQUIRY VPD page
 450  *                      0x80.  If it is specified, the CTL_LUN_FLAG_SERIAL_NUM
 451  *                      flag should be set.
 452  *
 453  *                      The serial number value used is returned in this
 454  *                      field.
 455  *
 456  * device_id:           This is the value returned in the T10 vendor ID
 457  *                      based DESIGNATOR field in the SCSI INQUIRY VPD page
 458  *                      0x83 data.  If it is specified, the CTL_LUN_FLAG_DEVID
 459  *                      flag should be set.
 460  *
 461  *                      The device id value used is returned in this field.
 462  */
 463 struct ctl_lun_create_params {
 464         ctl_backend_lun_flags   flags;
 465         uint8_t                 device_type;
 466         uint64_t                lun_size_bytes;
 467         uint32_t                blocksize_bytes;
 468         uint32_t                req_lun_id;
 469         uint8_t                 serial_num[CTL_SN_LEN];
 470         uint8_t                 device_id[CTL_DEVID_LEN];
 471 };
 472
 473 /*
 474  * LUN removal parameters:
 475  *
 476  * lun_id:              The number of the LUN to delete.  This must be set.
 477  *                      The LUN must be backed by the given backend.
 478  */
 479 struct ctl_lun_rm_params {
 480         uint32_t                lun_id;
 481 };
 482
 483 /*
 484  * LUN modification parameters:
 485  *
 486  * lun_id:              The number of the LUN to modify.  This must be set.
 487  *                      The LUN must be backed by the given backend.
 488  *
 489  * lun_size_bytes:      The size of the LUN in bytes.  If zero, update
 490  *                      the size using the backing file size, if possible.
 491  */
 492 struct ctl_lun_modify_params {
 493         uint32_t                lun_id;
 494         uint64_t                lun_size_bytes;
 495 };
 496
 497 /*
 498  * Union of request type data.  Fill in the appropriate union member for
 499  * the request type.
 500  */
 501 union ctl_lunreq_data {
 502         struct ctl_lun_create_params    create;
 503         struct ctl_lun_rm_params        rm;
 504         struct ctl_lun_modify_params    modify;
 505 };
 506
 507 /*
 508  * LUN request interface:
 509  *
 510  * backend:             This is required, and is NUL-terminated a string
 511  *                      that is the name of the backend, like "ramdisk" or
 512  *                      "block".
 513  *
 514  * reqtype:             The type of request, CTL_LUNREQ_CREATE to create a
 515  *                      LUN, CTL_LUNREQ_RM to delete a LUN.
 516  *
 517  * reqdata:             Request type-specific information.  See the
 518  *                      description of individual the union members above
 519  *                      for more information.
 520  *
 521  * num_be_args:         This is the number of backend-specific arguments
 522  *                      in the be_args array.
 523  *
 524  * be_args:             This is an array of backend-specific arguments.
 525  *                      See above for a description of the fields in this
 526  *                      structure.
 527  *
 528  * status:              Status of the LUN request.
 529  *
 530  * error_str:           If the status is CTL_LUN_ERROR, this will
 531  *                      contain a string describing the error.
 532  *
 533  * kern_be_args:        For kernel use only.
 534  */
 535 struct ctl_lun_req {
 536 #define CTL_BE_NAME_LEN         32
 537         char                    backend[CTL_BE_NAME_LEN];
 538         ctl_lunreq_type         reqtype;
 539         union ctl_lunreq_data   reqdata;
 540         int                     num_be_args;
 541         struct ctl_be_arg       *be_args;
 542         ctl_lun_status          status;
 543         char                    error_str[CTL_ERROR_STR_LEN];
 544         struct ctl_be_arg       *kern_be_args;
 545 };
 546
 547 /*
 548  * LUN list status:
 549  *
 550  * NONE:                No status.
 551  *
 552  * OK:                  Request completed successfully.
 553  *
 554  * NEED_MORE_SPACE:     The allocated length of the entries field is too
 555  *                      small for the available data.
 556  *
 557  * ERROR:               An error occurred, look at the error string for a
 558  *                      description of the error.
 559  */
 560 typedef enum {
 561         CTL_LUN_LIST_NONE,
 562         CTL_LUN_LIST_OK,
 563         CTL_LUN_LIST_NEED_MORE_SPACE,
 564         CTL_LUN_LIST_ERROR
 565 } ctl_lun_list_status;
 566
 567 /*
 568  * LUN list interface
 569  *
 570  * backend_name:        This is a NUL-terminated string.  If the string
 571  *                      length is 0, then all LUNs on all backends will
 572  *                      be enumerated.  Otherwise this is the name of the
 573  *                      backend to be enumerated, like "ramdisk" or "block".
 574  *
 575  * alloc_len:           The length of the data buffer allocated for entries.
 576  *                      In order to properly size the buffer, make one call
 577  *                      with alloc_len set to 0, and then use the returned
 578  *                      dropped_len as the buffer length to allocate and
 579  *                      pass in on a subsequent call.
 580  *
 581  * lun_xml:             XML-formatted information on the requested LUNs.
 582  *
 583  * fill_len:            The amount of data filled in the storage for entries.
 584  *
 585  * status:              The status of the request.  See above for the
 586  *                      description of the values of this field.
 587  *
 588  * error_str:           If the status indicates an error, this string will
 589  *                      be filled in to describe the error.
 590  */
 591 struct ctl_lun_list {
 592         char                    backend[CTL_BE_NAME_LEN]; /* passed to kernel*/
 593         uint32_t                alloc_len;      /* passed to kernel */
 594         char                   *lun_xml;        /* filled in kernel */
 595         uint32_t                fill_len;       /* passed to userland */
 596         ctl_lun_list_status     status;         /* passed to userland */
 597         char                    error_str[CTL_ERROR_STR_LEN];
 598                                                 /* passed to userland */
 599 };
 600
 601 /*
 602  * Port request interface:
 603  *
 604  * driver:              This is required, and is NUL-terminated a string
 605  *                      that is the name of the frontend, like "iscsi" .
 606  *
 607  * reqtype:             The type of request, CTL_REQ_CREATE to create a
 608  *                      port, CTL_REQ_REMOVE to delete a port.
 609  *
 610  * num_be_args:         This is the number of frontend-specific arguments
 611  *                      in the be_args array.
 612  *
 613  * be_args:             This is an array of frontend-specific arguments.
 614  *                      See above for a description of the fields in this
 615  *                      structure.
 616  *
 617  * status:              Status of the request.
 618  *
 619  * error_str:           If the status is CTL_LUN_ERROR, this will
 620  *                      contain a string describing the error.
 621  *
 622  * kern_be_args:        For kernel use only.
 623  */
 624 typedef enum {
 625         CTL_REQ_CREATE,
 626         CTL_REQ_REMOVE,
 627         CTL_REQ_MODIFY,
 628 } ctl_req_type;
 629
 630 struct ctl_req {
 631         char                    driver[CTL_DRIVER_NAME_LEN];
 632         ctl_req_type            reqtype;
 633         int                     num_args;
 634         struct ctl_be_arg       *args;
 635         ctl_lun_status          status;
 636         char                    error_str[CTL_ERROR_STR_LEN];
 637         struct ctl_be_arg       *kern_args;
 638 };
 639
 640 /*
 641  * iSCSI status
 642  *
 643  * OK:                  Request completed successfully.
 644  *
 645  * ERROR:               An error occurred, look at the error string for a
 646  *                      description of the error.
 647  *
 648  * CTL_ISCSI_LIST_NEED_MORE_SPACE:
 649  *                      User has to pass larger buffer for CTL_ISCSI_LIST ioctl.
 650  */
 651 typedef enum {
 652         CTL_ISCSI_OK,
 653         CTL_ISCSI_ERROR,
 654         CTL_ISCSI_LIST_NEED_MORE_SPACE,
 655         CTL_ISCSI_SESSION_NOT_FOUND
 656 } ctl_iscsi_status;
 657
 658 typedef enum {
 659         CTL_ISCSI_HANDOFF,
 660         CTL_ISCSI_LIST,
 661         CTL_ISCSI_LOGOUT,
 662         CTL_ISCSI_TERMINATE,
 663 #if defined(ICL_KERNEL_PROXY) || 1
 664         /*
 665          * We actually need those in all cases, but leave the ICL_KERNEL_PROXY,
 666          * to remember to remove them along with rest of proxy code, eventually.
 667          */
 668         CTL_ISCSI_LISTEN,
 669         CTL_ISCSI_ACCEPT,
 670         CTL_ISCSI_SEND,
 671         CTL_ISCSI_RECEIVE,
 672 #endif
 673 } ctl_iscsi_type;
 674
 675 typedef enum {
 676         CTL_ISCSI_DIGEST_NONE,
 677         CTL_ISCSI_DIGEST_CRC32C
 678 } ctl_iscsi_digest;
 679
 680 #define CTL_ISCSI_NAME_LEN      224     /* 223 bytes, by RFC 3720, + '\0' */
 681 #define CTL_ISCSI_ADDR_LEN      47      /* INET6_ADDRSTRLEN + '\0' */
 682 #define CTL_ISCSI_ALIAS_LEN     128     /* Arbitrary. */
 683
 684 struct ctl_iscsi_handoff_params {
 685         char                    initiator_name[CTL_ISCSI_NAME_LEN];
 686         char                    initiator_addr[CTL_ISCSI_ADDR_LEN];
 687         char                    initiator_alias[CTL_ISCSI_ALIAS_LEN];
 688         uint8_t                 initiator_isid[6];
 689         char                    target_name[CTL_ISCSI_NAME_LEN];
 690         int                     socket;
 691         int                     portal_group_tag;
 692
 693         /*
 694          * Connection parameters negotiated by ctld(8).
 695          */
 696         ctl_iscsi_digest        header_digest;
 697         ctl_iscsi_digest        data_digest;
 698         uint32_t                cmdsn;
 699         uint32_t                statsn;
 700         uint32_t                max_recv_data_segment_length;
 701         uint32_t                max_burst_length;
 702         uint32_t                first_burst_length;
 703         uint32_t                immediate_data;
 704 #ifdef ICL_KERNEL_PROXY
 705         int                     connection_id;
 706         int                     spare[3];
 707 #else
 708         int                     spare[4];
 709 #endif
 710 };
 711
 712 struct ctl_iscsi_list_params {
 713         uint32_t                alloc_len;      /* passed to kernel */
 714         char                   *conn_xml;       /* filled in kernel */
 715         uint32_t                fill_len;       /* passed to userland */
 716         int                     spare[4];
 717 };
 718
 719 struct ctl_iscsi_logout_params {
 720         int                     connection_id;  /* passed to kernel */
 721         char                    initiator_name[CTL_ISCSI_NAME_LEN];
 722                                                 /* passed to kernel */
 723         char                    initiator_addr[CTL_ISCSI_ADDR_LEN];
 724                                                 /* passed to kernel */
 725         int                     all;            /* passed to kernel */
 726         int                     spare[4];
 727 };
 728
 729 struct ctl_iscsi_terminate_params {
 730         int                     connection_id;  /* passed to kernel */
 731         char                    initiator_name[CTL_ISCSI_NAME_LEN];
 732                                                 /* passed to kernel */
 733         char                    initiator_addr[CTL_ISCSI_NAME_LEN];
 734                                                 /* passed to kernel */
 735         int                     all;            /* passed to kernel */
 736         int                     spare[4];
 737 };
 738
 739 #ifdef ICL_KERNEL_PROXY
 740 struct ctl_iscsi_listen_params {
 741         int                             iser;
 742         int                             domain;
 743         int                             socktype;
 744         int                             protocol;
 745         struct sockaddr                 *addr;
 746         socklen_t                       addrlen;
 747         int                             portal_id;
 748         int                             spare[4];
 749 };
 750
 751 struct ctl_iscsi_accept_params {
 752         int                             connection_id;
 753         int                             portal_id;
 754         struct sockaddr                 *initiator_addr;
 755         socklen_t                       initiator_addrlen;
 756         int                             spare[4];
 757 };
 758
 759 struct ctl_iscsi_send_params {
 760         int                             connection_id;
 761         void                            *bhs;
 762         size_t                          spare;
 763         void                            *spare2;
 764         size_t                          data_segment_len;
 765         void                            *data_segment;
 766         int                             spare3[4];
 767 };
 768
 769 struct ctl_iscsi_receive_params {
 770         int                             connection_id;
 771         void                            *bhs;
 772         size_t                          spare;
 773         void                            *spare2;
 774         size_t                          data_segment_len;
 775         void                            *data_segment;
 776         int                             spare3[4];
 777 };
 778
 779 #endif /* ICL_KERNEL_PROXY */
 780
 781 union ctl_iscsi_data {
 782         struct ctl_iscsi_handoff_params         handoff;
 783         struct ctl_iscsi_list_params            list;
 784         struct ctl_iscsi_logout_params          logout;
 785         struct ctl_iscsi_terminate_params       terminate;
 786 #ifdef ICL_KERNEL_PROXY
 787         struct ctl_iscsi_listen_params          listen;
 788         struct ctl_iscsi_accept_params          accept;
 789         struct ctl_iscsi_send_params            send;
 790         struct ctl_iscsi_receive_params         receive;
 791 #endif
 792 };
 793
 794 /*
 795  * iSCSI interface
 796  *
 797  * status:              The status of the request.  See above for the
 798  *                      description of the values of this field.
 799  *
 800  * error_str:           If the status indicates an error, this string will
 801  *                      be filled in to describe the error.
 802  */
 803 struct ctl_iscsi {
 804         ctl_iscsi_type          type;           /* passed to kernel */
 805         union ctl_iscsi_data    data;           /* passed to kernel */
 806         ctl_iscsi_status        status;         /* passed to userland */
 807         char                    error_str[CTL_ERROR_STR_LEN];
 808                                                 /* passed to userland */
 809 };
 810
 811 struct ctl_lun_map {
 812         uint32_t                port;
 813         uint32_t                plun;
 814         uint32_t                lun;
 815 };
 816
 817 #define CTL_IO                  _IOWR(CTL_MINOR, 0x00, union ctl_io)
 818 #define CTL_ENABLE_PORT         _IOW(CTL_MINOR, 0x04, struct ctl_port_entry)
 819 #define CTL_DISABLE_PORT        _IOW(CTL_MINOR, 0x05, struct ctl_port_entry)
 820 #define CTL_DELAY_IO            _IOWR(CTL_MINOR, 0x10, struct ctl_io_delay_info)
 821 #define CTL_GETSTATS            _IOWR(CTL_MINOR, 0x15, struct ctl_stats)
 822 #define CTL_ERROR_INJECT        _IOWR(CTL_MINOR, 0x16, struct ctl_error_desc)
 823 #define CTL_GET_OOA             _IOWR(CTL_MINOR, 0x18, struct ctl_ooa)
 824 #define CTL_DUMP_STRUCTS        _IO(CTL_MINOR, 0x19)
 825 #define CTL_LUN_REQ             _IOWR(CTL_MINOR, 0x21, struct ctl_lun_req)
 826 #define CTL_LUN_LIST            _IOWR(CTL_MINOR, 0x22, struct ctl_lun_list)
 827 #define CTL_ERROR_INJECT_DELETE _IOW(CTL_MINOR, 0x23, struct ctl_error_desc)
 828 #define CTL_SET_PORT_WWNS       _IOW(CTL_MINOR, 0x24, struct ctl_port_entry)
 829 #define CTL_ISCSI               _IOWR(CTL_MINOR, 0x25, struct ctl_iscsi)
 830 #define CTL_PORT_REQ            _IOWR(CTL_MINOR, 0x26, struct ctl_req)
 831 #define CTL_PORT_LIST           _IOWR(CTL_MINOR, 0x27, struct ctl_lun_list)
 832 #define CTL_LUN_MAP             _IOW(CTL_MINOR, 0x28, struct ctl_lun_map)
 833 #define CTL_GET_LUN_STATS       _IOWR(CTL_MINOR, 0x29, struct ctl_get_io_stats)
 834 #define CTL_GET_PORT_STATS      _IOWR(CTL_MINOR, 0x2a, struct ctl_get_io_stats)
 835
 836 #endif /* _CTL_IOCTL_H_ */
 837
 838 /*
 839  * vim: ts=8
 840  */