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 */ 781