sys/cam/ctl/ctl_ioctl.h

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