1229997Sken/*- 2229997Sken * Copyright (c) 2003 Silicon Graphics International Corp. 3288811Smav * Copyright (c) 2014-2015 Alexander Motin <mav@FreeBSD.org> 4229997Sken * All rights reserved. 5229997Sken * 6229997Sken * Redistribution and use in source and binary forms, with or without 7229997Sken * modification, are permitted provided that the following conditions 8229997Sken * are met: 9229997Sken * 1. Redistributions of source code must retain the above copyright 10229997Sken * notice, this list of conditions, and the following disclaimer, 11229997Sken * without modification. 12229997Sken * 2. Redistributions in binary form must reproduce at minimum a disclaimer 13229997Sken * substantially similar to the "NO WARRANTY" disclaimer below 14229997Sken * ("Disclaimer") and any redistribution must be conditioned upon 15229997Sken * including a substantially similar Disclaimer requirement for further 16229997Sken * binary redistribution. 17229997Sken * 18229997Sken * NO WARRANTY 19229997Sken * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20229997Sken * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21229997Sken * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 22229997Sken * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23229997Sken * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24229997Sken * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25229997Sken * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26229997Sken * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 27229997Sken * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 28229997Sken * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29229997Sken * POSSIBILITY OF SUCH DAMAGES. 30229997Sken * 31229997Sken * $Id: //depot/users/kenm/FreeBSD-test2/sys/cam/ctl/ctl_io.h#5 $ 32229997Sken * $FreeBSD: stable/10/sys/cam/ctl/ctl_io.h 313367 2017-02-07 01:44:18Z mav $ 33229997Sken */ 34229997Sken/* 35229997Sken * CAM Target Layer data movement structures/interface. 36229997Sken * 37229997Sken * Author: Ken Merry <ken@FreeBSD.org> 38229997Sken */ 39229997Sken 40229997Sken#ifndef _CTL_IO_H_ 41229997Sken#define _CTL_IO_H_ 42229997Sken 43229997Sken#ifdef _CTL_C 44229997Sken#define EXTERN(__var,__val) __var = __val 45229997Sken#else 46229997Sken#define EXTERN(__var,__val) extern __var 47229997Sken#endif 48229997Sken 49229997Sken#define CTL_MAX_CDBLEN 32 50229997Sken/* 51229997Sken * Uncomment this next line to enable printing out times for I/Os 52229997Sken * that take longer than CTL_TIME_IO_SECS seconds to get to the datamove 53229997Sken * and/or done stage. 54229997Sken */ 55229997Sken#define CTL_TIME_IO 56229997Sken#ifdef CTL_TIME_IO 57229997Sken#define CTL_TIME_IO_DEFAULT_SECS 90 58229997SkenEXTERN(int ctl_time_io_secs, CTL_TIME_IO_DEFAULT_SECS); 59229997Sken#endif 60229997Sken 61229997Sken/* 62288730Smav * Uncomment this next line to enable the CTL I/O delay feature. You 63229997Sken * can delay I/O at two different points -- datamove and done. This is 64229997Sken * useful for diagnosing abort conditions (for hosts that send an abort on a 65229997Sken * timeout), and for determining how long a host's timeout is. 66229997Sken */ 67288730Smav//#define CTL_IO_DELAY 68229997Sken 69229997Skentypedef enum { 70229997Sken CTL_STATUS_NONE, /* No status */ 71229997Sken CTL_SUCCESS, /* Transaction completed successfully */ 72229997Sken CTL_CMD_TIMEOUT, /* Command timed out, shouldn't happen here */ 73229997Sken CTL_SEL_TIMEOUT, /* Selection timeout, shouldn't happen here */ 74229997Sken CTL_ERROR, /* General CTL error XXX expand on this? */ 75229997Sken CTL_SCSI_ERROR, /* SCSI error, look at status byte/sense data */ 76229997Sken CTL_CMD_ABORTED, /* Command aborted, don't return status */ 77229997Sken CTL_STATUS_MASK = 0xfff,/* Mask off any status flags */ 78229997Sken CTL_AUTOSENSE = 0x1000 /* Autosense performed */ 79229997Sken} ctl_io_status; 80229997Sken 81229997Sken/* 82229997Sken * WARNING: Keep the data in/out/none flags where they are. They're used 83311402Smav * in conjunction with ctl_cmd_flags. See comment above ctl_cmd_flags 84229997Sken * definition in ctl_private.h. 85229997Sken */ 86229997Skentypedef enum { 87229997Sken CTL_FLAG_NONE = 0x00000000, /* no flags */ 88229997Sken CTL_FLAG_DATA_IN = 0x00000001, /* DATA IN */ 89229997Sken CTL_FLAG_DATA_OUT = 0x00000002, /* DATA OUT */ 90229997Sken CTL_FLAG_DATA_NONE = 0x00000003, /* no data */ 91229997Sken CTL_FLAG_DATA_MASK = 0x00000003, 92229997Sken CTL_FLAG_DO_AUTOSENSE = 0x00000020, /* grab sense info */ 93229997Sken CTL_FLAG_USER_REQ = 0x00000040, /* request came from userland */ 94229997Sken CTL_FLAG_ALLOCATED = 0x00000100, /* data space allocated */ 95229997Sken CTL_FLAG_BLOCKED = 0x00000200, /* on the blocked queue */ 96268697Smav CTL_FLAG_ABORT_STATUS = 0x00000400, /* return TASK ABORTED status */ 97229997Sken CTL_FLAG_ABORT = 0x00000800, /* this I/O should be aborted */ 98229997Sken CTL_FLAG_DMA_INPROG = 0x00001000, /* DMA in progress */ 99229997Sken CTL_FLAG_DELAY_DONE = 0x00004000, /* delay injection done */ 100229997Sken CTL_FLAG_INT_COPY = 0x00008000, /* internal copy, no done call*/ 101229997Sken CTL_FLAG_SENT_2OTHER_SC = 0x00010000, 102229997Sken CTL_FLAG_FROM_OTHER_SC = 0x00020000, 103229997Sken CTL_FLAG_IS_WAS_ON_RTR = 0x00040000, /* Don't rerun cmd on failover*/ 104229997Sken CTL_FLAG_BUS_ADDR = 0x00080000, /* ctl_sglist contains BUS 105229997Sken addresses, not virtual ones*/ 106229997Sken CTL_FLAG_IO_CONT = 0x00100000, /* Continue I/O instead of 107229997Sken completing */ 108229997Sken#if 0 109229997Sken CTL_FLAG_ALREADY_DONE = 0x00200000 /* I/O already completed */ 110229997Sken#endif 111229997Sken CTL_FLAG_NO_DATAMOVE = 0x00400000, 112229997Sken CTL_FLAG_DMA_QUEUED = 0x00800000, /* DMA queued but not started*/ 113229997Sken CTL_FLAG_STATUS_QUEUED = 0x01000000, /* Status queued but not sent*/ 114229997Sken 115229997Sken CTL_FLAG_FAILOVER = 0x04000000, /* Killed by a failover */ 116229997Sken CTL_FLAG_IO_ACTIVE = 0x08000000, /* I/O active on this SC */ 117288774Smav CTL_FLAG_STATUS_SENT = 0x10000000, /* Status sent by datamove */ 118288774Smav CTL_FLAG_SERSEQ_DONE = 0x20000000 /* All storage I/O started */ 119229997Sken} ctl_io_flags; 120229997Sken 121229997Sken 122229997Skenstruct ctl_lba_len { 123229997Sken uint64_t lba; 124229997Sken uint32_t len; 125229997Sken}; 126229997Sken 127265634Smavstruct ctl_lba_len_flags { 128265634Smav uint64_t lba; 129265634Smav uint32_t len; 130265634Smav uint32_t flags; 131272616Smav#define CTL_LLF_FUA 0x04000000 132272616Smav#define CTL_LLF_DPO 0x08000000 133268151Smav#define CTL_LLF_READ 0x10000000 134268151Smav#define CTL_LLF_WRITE 0x20000000 135268151Smav#define CTL_LLF_VERIFY 0x40000000 136268151Smav#define CTL_LLF_COMPARE 0x80000000 137265634Smav}; 138265634Smav 139265634Smavstruct ctl_ptr_len_flags { 140265634Smav uint8_t *ptr; 141265634Smav uint32_t len; 142265634Smav uint32_t flags; 143265634Smav}; 144265634Smav 145229997Skenunion ctl_priv { 146229997Sken uint8_t bytes[sizeof(uint64_t) * 2]; 147229997Sken uint64_t integer; 148312585Smav uint64_t integers[2]; 149229997Sken void *ptr; 150312585Smav void *ptrs[2]; 151229997Sken}; 152229997Sken 153229997Sken/* 154229997Sken * Number of CTL private areas. 155229997Sken */ 156229997Sken#define CTL_NUM_PRIV 6 157229997Sken 158229997Sken/* 159229997Sken * Which private area are we using for a particular piece of data? 160229997Sken */ 161229997Sken#define CTL_PRIV_LUN 0 /* CTL LUN pointer goes here */ 162229997Sken#define CTL_PRIV_LBA_LEN 1 /* Decoded LBA/len for read/write*/ 163229997Sken#define CTL_PRIV_MODEPAGE 1 /* Modepage info for config write */ 164229997Sken#define CTL_PRIV_BACKEND 2 /* Reserved for block, RAIDCore */ 165229997Sken#define CTL_PRIV_BACKEND_LUN 3 /* Backend LUN pointer */ 166288723Smav#define CTL_PRIV_FRONTEND 4 /* Frontend storage */ 167288723Smav#define CTL_PRIV_FRONTEND2 5 /* Another frontend storage */ 168229997Sken 169312835Smav#define CTL_LUN(io) ((io)->io_hdr.ctl_private[CTL_PRIV_LUN].ptrs[0]) 170312835Smav#define CTL_SOFTC(io) ((io)->io_hdr.ctl_private[CTL_PRIV_LUN].ptrs[1]) 171312835Smav#define CTL_BACKEND_LUN(io) ((io)->io_hdr.ctl_private[CTL_PRIV_BACKEND_LUN].ptrs[0]) 172312835Smav#define CTL_PORT(io) (((struct ctl_softc *)CTL_SOFTC(io))-> \ 173312835Smav ctl_ports[(io)->io_hdr.nexus.targ_port]) 174312835Smav 175229997Sken#define CTL_INVALID_PORTNAME 0xFF 176229997Sken#define CTL_UNMAPPED_IID 0xFF 177229997Sken 178229997Skenstruct ctl_sg_entry { 179229997Sken void *addr; 180229997Sken size_t len; 181229997Sken}; 182229997Sken 183229997Skentypedef enum { 184229997Sken CTL_IO_NONE, 185229997Sken CTL_IO_SCSI, 186229997Sken CTL_IO_TASK, 187229997Sken} ctl_io_type; 188229997Sken 189229997Skenstruct ctl_nexus { 190288731Smav uint32_t initid; /* Initiator ID */ 191229997Sken uint32_t targ_port; /* Target port, filled in by PORT */ 192229997Sken uint32_t targ_lun; /* Destination lun */ 193268556Smav uint32_t targ_mapped_lun; /* Destination lun CTL-wide */ 194229997Sken}; 195229997Sken 196229997Skentypedef enum { 197229997Sken CTL_MSG_SERIALIZE, 198229997Sken CTL_MSG_R2R, 199229997Sken CTL_MSG_FINISH_IO, 200229997Sken CTL_MSG_BAD_JUJU, 201229997Sken CTL_MSG_MANAGE_TASKS, 202229997Sken CTL_MSG_PERS_ACTION, 203229997Sken CTL_MSG_DATAMOVE, 204288732Smav CTL_MSG_DATAMOVE_DONE, 205288732Smav CTL_MSG_UA, /* Set/clear UA on secondary. */ 206288732Smav CTL_MSG_PORT_SYNC, /* Information about port. */ 207288732Smav CTL_MSG_LUN_SYNC, /* Information about LUN. */ 208288770Smav CTL_MSG_IID_SYNC, /* Information about initiator. */ 209288789Smav CTL_MSG_LOGIN, /* Information about HA peer. */ 210288790Smav CTL_MSG_MODE_SYNC, /* Mode page current content. */ 211288732Smav CTL_MSG_FAILOVER /* Fake, never sent though the wire */ 212229997Sken} ctl_msg_type; 213229997Sken 214229997Skenstruct ctl_scsiio; 215229997Sken 216229997Skenstruct ctl_io_hdr { 217229997Sken uint32_t version; /* interface version XXX */ 218229997Sken ctl_io_type io_type; /* task I/O, SCSI I/O, etc. */ 219229997Sken ctl_msg_type msg_type; 220229997Sken struct ctl_nexus nexus; /* Initiator, port, target, lun */ 221229997Sken uint32_t iid_indx; /* the index into the iid mapping */ 222229997Sken uint32_t flags; /* transaction flags */ 223229997Sken uint32_t status; /* transaction status */ 224229997Sken uint32_t port_status; /* trans status, set by PORT, 0 = good*/ 225229997Sken uint32_t timeout; /* timeout in ms */ 226229997Sken uint32_t retries; /* retry count */ 227229997Sken#ifdef CTL_IO_DELAY 228288730Smav struct callout delay_callout; 229229997Sken#endif /* CTL_IO_DELAY */ 230229997Sken#ifdef CTL_TIME_IO 231229997Sken time_t start_time; /* I/O start time */ 232229997Sken struct bintime start_bt; /* Timer start ticks */ 233229997Sken struct bintime dma_start_bt; /* DMA start ticks */ 234229997Sken struct bintime dma_bt; /* DMA total ticks */ 235288798Smav#endif /* CTL_TIME_IO */ 236229997Sken uint32_t num_dmas; /* Number of DMAs */ 237229997Sken union ctl_io *original_sc; 238229997Sken union ctl_io *serializing_sc; 239229997Sken void *pool; /* I/O pool */ 240229997Sken union ctl_priv ctl_private[CTL_NUM_PRIV];/* CTL private area */ 241288732Smav struct ctl_sg_entry *remote_sglist; 242288732Smav struct ctl_sg_entry *local_sglist; 243229997Sken STAILQ_ENTRY(ctl_io_hdr) links; /* linked list pointer */ 244229997Sken TAILQ_ENTRY(ctl_io_hdr) ooa_links; 245229997Sken TAILQ_ENTRY(ctl_io_hdr) blocked_links; 246229997Sken}; 247229997Sken 248229997Skentypedef enum { 249229997Sken CTL_TAG_UNTAGGED, 250229997Sken CTL_TAG_SIMPLE, 251229997Sken CTL_TAG_ORDERED, 252229997Sken CTL_TAG_HEAD_OF_QUEUE, 253229997Sken CTL_TAG_ACA 254229997Sken} ctl_tag_type; 255229997Sken 256229997Skenunion ctl_io; 257229997Sken 258229997Sken/* 259229997Sken * SCSI passthrough I/O structure for the CAM Target Layer. Note 260229997Sken * that some of these fields are here for completeness, but they aren't 261229997Sken * used in the CTL implementation. e.g., timeout and retries won't be 262229997Sken * used. 263229997Sken * 264229997Sken * Note: Make sure the io_hdr is *always* the first element in this 265229997Sken * structure. 266229997Sken */ 267229997Skenstruct ctl_scsiio { 268229997Sken struct ctl_io_hdr io_hdr; /* common to all I/O types */ 269268142Smav 270268142Smav /* 271268142Smav * The ext_* fields are generally intended for frontend use; CTL itself 272268142Smav * doesn't modify or use them. 273268142Smav */ 274229997Sken uint32_t ext_sg_entries; /* 0 = no S/G list, > 0 = num entries */ 275229997Sken uint8_t *ext_data_ptr; /* data buffer or S/G list */ 276229997Sken uint32_t ext_data_len; /* Data transfer length */ 277229997Sken uint32_t ext_data_filled; /* Amount of data filled so far */ 278268142Smav 279268142Smav /* 280268142Smav * The number of scatter/gather entries in the list pointed to 281268142Smav * by kern_data_ptr. 0 means there is no list, just a data pointer. 282268142Smav */ 283268142Smav uint32_t kern_sg_entries; 284268142Smav 285268142Smav uint32_t rem_sg_entries; /* Unused. */ 286268142Smav 287268142Smav /* 288268142Smav * The data pointer or a pointer to the scatter/gather list. 289268142Smav */ 290268142Smav uint8_t *kern_data_ptr; 291268142Smav 292268142Smav /* 293268142Smav * Length of the data buffer or scatter/gather list. It's also 294268142Smav * the length of this particular piece of the data transfer, 295268142Smav * ie. number of bytes expected to be transferred by the current 296268142Smav * invocation of frontend's datamove() callback. It's always 297268142Smav * less than or equal to kern_total_len. 298268142Smav */ 299268142Smav uint32_t kern_data_len; 300268142Smav 301268142Smav /* 302268142Smav * Total length of data to be transferred during this particular 303268142Smav * SCSI command, as decoded from SCSI CDB. 304268142Smav */ 305268142Smav uint32_t kern_total_len; 306268142Smav 307268142Smav /* 308268142Smav * Amount of data left after the current data transfer. 309268142Smav */ 310268142Smav uint32_t kern_data_resid; 311268142Smav 312268142Smav /* 313268142Smav * Byte offset of this transfer, equal to the amount of data 314268142Smav * already transferred for this SCSI command during previous 315268142Smav * datamove() invocations. 316268142Smav */ 317268142Smav uint32_t kern_rel_offset; 318268142Smav 319229997Sken struct scsi_sense_data sense_data; /* sense data */ 320229997Sken uint8_t sense_len; /* Returned sense length */ 321229997Sken uint8_t scsi_status; /* SCSI status byte */ 322268142Smav uint8_t sense_residual; /* Unused. */ 323313367Smav uint32_t residual; /* Unused */ 324229997Sken uint32_t tag_num; /* tag number */ 325229997Sken ctl_tag_type tag_type; /* simple, ordered, head of queue,etc.*/ 326229997Sken uint8_t cdb_len; /* CDB length */ 327229997Sken uint8_t cdb[CTL_MAX_CDBLEN]; /* CDB */ 328229997Sken int (*be_move_done)(union ctl_io *io); /* called by fe */ 329229997Sken int (*io_cont)(union ctl_io *io); /* to continue processing */ 330229997Sken}; 331229997Sken 332229997Skentypedef enum { 333229997Sken CTL_TASK_ABORT_TASK, 334229997Sken CTL_TASK_ABORT_TASK_SET, 335229997Sken CTL_TASK_CLEAR_ACA, 336229997Sken CTL_TASK_CLEAR_TASK_SET, 337268690Smav CTL_TASK_I_T_NEXUS_RESET, 338229997Sken CTL_TASK_LUN_RESET, 339229997Sken CTL_TASK_TARGET_RESET, 340229997Sken CTL_TASK_BUS_RESET, 341229997Sken CTL_TASK_PORT_LOGIN, 342288754Smav CTL_TASK_PORT_LOGOUT, 343288754Smav CTL_TASK_QUERY_TASK, 344288754Smav CTL_TASK_QUERY_TASK_SET, 345288754Smav CTL_TASK_QUERY_ASYNC_EVENT 346229997Sken} ctl_task_type; 347229997Sken 348288754Smavtypedef enum { 349288754Smav CTL_TASK_FUNCTION_COMPLETE, 350288754Smav CTL_TASK_FUNCTION_SUCCEEDED, 351288754Smav CTL_TASK_FUNCTION_REJECTED, 352288754Smav CTL_TASK_LUN_DOES_NOT_EXIST, 353288754Smav CTL_TASK_FUNCTION_NOT_SUPPORTED 354288754Smav} ctl_task_status; 355288754Smav 356229997Sken/* 357229997Sken * Task management I/O structure. Aborts, bus resets, etc., are sent using 358229997Sken * this structure. 359229997Sken * 360229997Sken * Note: Make sure the io_hdr is *always* the first element in this 361229997Sken * structure. 362229997Sken */ 363229997Skenstruct ctl_taskio { 364229997Sken struct ctl_io_hdr io_hdr; /* common to all I/O types */ 365229997Sken ctl_task_type task_action; /* Target Reset, Abort, etc. */ 366229997Sken uint32_t tag_num; /* tag number */ 367229997Sken ctl_tag_type tag_type; /* simple, ordered, etc. */ 368288754Smav uint8_t task_status; /* Complete, Succeeded, etc. */ 369288754Smav uint8_t task_resp[3];/* Response information */ 370229997Sken}; 371229997Sken 372288789Smav 373288789Smav/* 374288789Smav * HA link messages. 375288789Smav */ 376313367Smav#define CTL_HA_VERSION 3 377288789Smav 378288789Smav/* 379288789Smav * Used for CTL_MSG_LOGIN. 380288789Smav */ 381288789Smavstruct ctl_ha_msg_login { 382288789Smav ctl_msg_type msg_type; 383288789Smav int version; 384288789Smav int ha_mode; 385288789Smav int ha_id; 386288789Smav int max_luns; 387288789Smav int max_ports; 388288789Smav int max_init_per_port; 389288789Smav}; 390288789Smav 391229997Skentypedef enum { 392229997Sken CTL_PR_REG_KEY, 393229997Sken CTL_PR_UNREG_KEY, 394229997Sken CTL_PR_PREEMPT, 395229997Sken CTL_PR_CLEAR, 396229997Sken CTL_PR_RESERVE, 397229997Sken CTL_PR_RELEASE 398229997Sken} ctl_pr_action; 399229997Sken 400229997Sken/* 401229997Sken * The PR info is specifically for sending Persistent Reserve actions 402229997Sken * to the other SC which it must also act on. 403229997Sken * 404229997Sken * Note: Make sure the io_hdr is *always* the first element in this 405229997Sken * structure. 406229997Sken */ 407229997Skenstruct ctl_pr_info { 408229997Sken ctl_pr_action action; 409229997Sken uint8_t sa_res_key[8]; 410229997Sken uint8_t res_type; 411269298Smav uint32_t residx; 412229997Sken}; 413229997Sken 414229997Skenstruct ctl_ha_msg_hdr { 415229997Sken ctl_msg_type msg_type; 416288777Smav uint32_t status; /* transaction status */ 417229997Sken union ctl_io *original_sc; 418229997Sken union ctl_io *serializing_sc; 419229997Sken struct ctl_nexus nexus; /* Initiator, port, target, lun */ 420229997Sken}; 421229997Sken 422229997Sken#define CTL_HA_MAX_SG_ENTRIES 16 423288732Smav#define CTL_HA_DATAMOVE_SEGMENT 131072 424229997Sken 425229997Sken/* 426229997Sken * Used for CTL_MSG_PERS_ACTION. 427229997Sken */ 428229997Skenstruct ctl_ha_msg_pr { 429229997Sken struct ctl_ha_msg_hdr hdr; 430229997Sken struct ctl_pr_info pr_info; 431229997Sken}; 432229997Sken 433229997Sken/* 434288732Smav * Used for CTL_MSG_UA. 435288732Smav */ 436288732Smavstruct ctl_ha_msg_ua { 437288732Smav struct ctl_ha_msg_hdr hdr; 438288732Smav int ua_all; 439288732Smav int ua_set; 440288732Smav int ua_type; 441288768Smav uint8_t ua_info[8]; 442288732Smav}; 443288732Smav 444288732Smav/* 445229997Sken * The S/G handling here is a little different than the standard ctl_scsiio 446229997Sken * structure, because we can't pass data by reference in between controllers. 447229997Sken * The S/G list in the ctl_scsiio struct is normally passed in the 448229997Sken * kern_data_ptr field. So kern_sg_entries here will always be non-zero, 449229997Sken * even if there is only one entry. 450229997Sken * 451229997Sken * Used for CTL_MSG_DATAMOVE. 452229997Sken */ 453229997Skenstruct ctl_ha_msg_dt { 454229997Sken struct ctl_ha_msg_hdr hdr; 455229997Sken ctl_io_flags flags; /* Only I/O flags are used here */ 456229997Sken uint32_t sg_sequence; /* S/G portion number */ 457229997Sken uint8_t sg_last; /* last S/G batch = 1 */ 458229997Sken uint32_t sent_sg_entries; /* previous S/G count */ 459229997Sken uint32_t cur_sg_entries; /* current S/G entries */ 460229997Sken uint32_t kern_sg_entries; /* total S/G entries */ 461229997Sken uint32_t kern_data_len; /* Length of this S/G list */ 462229997Sken uint32_t kern_total_len; /* Total length of this 463229997Sken transaction */ 464229997Sken uint32_t kern_data_resid; /* Length left to transfer 465229997Sken after this*/ 466229997Sken uint32_t kern_rel_offset; /* Byte Offset of this 467229997Sken transfer */ 468229997Sken struct ctl_sg_entry sg_list[CTL_HA_MAX_SG_ENTRIES]; 469229997Sken}; 470229997Sken 471229997Sken/* 472313367Smav * Used for CTL_MSG_SERIALIZE, CTL_MSG_FINISH_IO, CTL_MSG_BAD_JUJU, 473313367Smav * and CTL_MSG_DATAMOVE_DONE. 474229997Sken */ 475229997Skenstruct ctl_ha_msg_scsi { 476229997Sken struct ctl_ha_msg_hdr hdr; 477229997Sken uint32_t tag_num; /* tag number */ 478229997Sken ctl_tag_type tag_type; /* simple, ordered, etc. */ 479288732Smav uint8_t cdb[CTL_MAX_CDBLEN]; /* CDB */ 480288732Smav uint8_t cdb_len; /* CDB length */ 481229997Sken uint8_t scsi_status; /* SCSI status byte */ 482229997Sken uint8_t sense_len; /* Returned sense length */ 483313367Smav uint32_t port_status; /* trans status, set by FETD, 484229997Sken 0 = good*/ 485313367Smav uint32_t kern_data_resid; /* for DATAMOVE_DONE */ 486288732Smav struct scsi_sense_data sense_data; /* sense data */ 487229997Sken}; 488229997Sken 489229997Sken/* 490229997Sken * Used for CTL_MSG_MANAGE_TASKS. 491229997Sken */ 492229997Skenstruct ctl_ha_msg_task { 493229997Sken struct ctl_ha_msg_hdr hdr; 494229997Sken ctl_task_type task_action; /* Target Reset, Abort, etc. */ 495229997Sken uint32_t tag_num; /* tag number */ 496229997Sken ctl_tag_type tag_type; /* simple, ordered, etc. */ 497229997Sken}; 498229997Sken 499288732Smav/* 500288732Smav * Used for CTL_MSG_PORT_SYNC. 501288732Smav */ 502288732Smavstruct ctl_ha_msg_port { 503288732Smav struct ctl_ha_msg_hdr hdr; 504288732Smav int port_type; 505288732Smav int physical_port; 506288732Smav int virtual_port; 507288732Smav int status; 508288732Smav int name_len; 509288732Smav int lun_map_len; 510288732Smav int port_devid_len; 511288732Smav int target_devid_len; 512288769Smav int init_devid_len; 513288732Smav uint8_t data[]; 514288732Smav}; 515288732Smav 516288732Smav/* 517288732Smav * Used for CTL_MSG_LUN_SYNC. 518288732Smav */ 519288732Smavstruct ctl_ha_msg_lun { 520288732Smav struct ctl_ha_msg_hdr hdr; 521288732Smav int flags; 522288732Smav unsigned int pr_generation; 523288732Smav uint32_t pr_res_idx; 524288732Smav uint8_t pr_res_type; 525288732Smav int lun_devid_len; 526288732Smav int pr_key_count; 527288732Smav uint8_t data[]; 528288732Smav}; 529288732Smav 530288732Smavstruct ctl_ha_msg_lun_pr_key { 531288732Smav uint32_t pr_iid; 532288732Smav uint64_t pr_key; 533288732Smav}; 534288732Smav 535288770Smav/* 536288770Smav * Used for CTL_MSG_IID_SYNC. 537288770Smav */ 538288770Smavstruct ctl_ha_msg_iid { 539288770Smav struct ctl_ha_msg_hdr hdr; 540288770Smav int in_use; 541288770Smav int name_len; 542288770Smav uint64_t wwpn; 543288770Smav uint8_t data[]; 544288770Smav}; 545288770Smav 546288790Smav/* 547288790Smav * Used for CTL_MSG_MODE_SYNC. 548288790Smav */ 549288790Smavstruct ctl_ha_msg_mode { 550288790Smav struct ctl_ha_msg_hdr hdr; 551288790Smav uint8_t page_code; 552288790Smav uint8_t subpage; 553288790Smav uint16_t page_len; 554288790Smav uint8_t data[]; 555288790Smav}; 556288790Smav 557229997Skenunion ctl_ha_msg { 558229997Sken struct ctl_ha_msg_hdr hdr; 559229997Sken struct ctl_ha_msg_task task; 560229997Sken struct ctl_ha_msg_scsi scsi; 561229997Sken struct ctl_ha_msg_dt dt; 562229997Sken struct ctl_ha_msg_pr pr; 563288732Smav struct ctl_ha_msg_ua ua; 564288732Smav struct ctl_ha_msg_port port; 565288732Smav struct ctl_ha_msg_lun lun; 566288770Smav struct ctl_ha_msg_iid iid; 567288789Smav struct ctl_ha_msg_login login; 568288790Smav struct ctl_ha_msg_mode mode; 569229997Sken}; 570229997Sken 571229997Skenstruct ctl_prio { 572229997Sken struct ctl_io_hdr io_hdr; 573229997Sken struct ctl_ha_msg_pr pr_msg; 574229997Sken}; 575229997Sken 576229997Skenunion ctl_io { 577229997Sken struct ctl_io_hdr io_hdr; /* common to all I/O types */ 578229997Sken struct ctl_scsiio scsiio; /* Normal SCSI commands */ 579229997Sken struct ctl_taskio taskio; /* SCSI task management/reset */ 580229997Sken struct ctl_prio presio; /* update per. res info on other SC */ 581229997Sken}; 582229997Sken 583229997Sken#ifdef _KERNEL 584229997Sken 585229997Skenunion ctl_io *ctl_alloc_io(void *pool_ref); 586275878Smavunion ctl_io *ctl_alloc_io_nowait(void *pool_ref); 587229997Skenvoid ctl_free_io(union ctl_io *io); 588229997Skenvoid ctl_zero_io(union ctl_io *io); 589229997Sken 590229997Sken#endif /* _KERNEL */ 591229997Sken 592229997Sken#endif /* _CTL_IO_H_ */ 593229997Sken 594229997Sken/* 595229997Sken * vim: ts=8 596229997Sken */ 597