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