sys/cam/ctl/ctl_io.h

   1 /*-
   2  * Copyright (c) 2003 Silicon Graphics International Corp.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions, and the following disclaimer,
  10  *    without modification.
  11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  12  *    substantially similar to the "NO WARRANTY" disclaimer below
  13  *    ("Disclaimer") and any redistribution must be conditioned upon
  14  *    including a substantially similar Disclaimer requirement for further
  15  *    binary redistribution.
  16  *
  17  * NO WARRANTY
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  26  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  27  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGES.
  29  *
  30  * $Id: //depot/users/kenm/FreeBSD-test2/sys/cam/ctl/ctl_io.h#5 $
  31  * $FreeBSD$
  32  */
  33 /*
  34  * CAM Target Layer data movement structures/interface.
  35  *
  36  * Author: Ken Merry <ken@FreeBSD.org>
  37  */
  38
  39 #ifndef _CTL_IO_H_
  40 #define _CTL_IO_H_
  41
  42 #ifdef _CTL_C
  43 #define EXTERN(__var,__val) __var = __val
  44 #else
  45 #define EXTERN(__var,__val) extern __var
  46 #endif
  47
  48 #define CTL_MAX_CDBLEN  32
  49 /*
  50  * Uncomment this next line to enable printing out times for I/Os
  51  * that take longer than CTL_TIME_IO_SECS seconds to get to the datamove
  52  * and/or done stage.
  53  */
  54 #define CTL_TIME_IO
  55 #ifdef  CTL_TIME_IO
  56 #define CTL_TIME_IO_DEFAULT_SECS        90
  57 EXTERN(int ctl_time_io_secs, CTL_TIME_IO_DEFAULT_SECS);
  58 #endif
  59
  60 /*
  61  * Uncomment these next two lines to enable the CTL I/O delay feature.  You
  62  * can delay I/O at two different points -- datamove and done.  This is
  63  * useful for diagnosing abort conditions (for hosts that send an abort on a
  64  * timeout), and for determining how long a host's timeout is.
  65  */
  66 #define CTL_IO_DELAY
  67 #define CTL_TIMER_BYTES         sizeof(struct callout)
  68
  69 typedef enum {
  70         CTL_STATUS_NONE,        /* No status */
  71         CTL_SUCCESS,            /* Transaction completed successfully */
  72         CTL_CMD_TIMEOUT,        /* Command timed out, shouldn't happen here */
  73         CTL_SEL_TIMEOUT,        /* Selection timeout, shouldn't happen here */
  74         CTL_ERROR,              /* General CTL error XXX expand on this? */
  75         CTL_SCSI_ERROR,         /* SCSI error, look at status byte/sense data */
  76         CTL_CMD_ABORTED,        /* Command aborted, don't return status */
  77         CTL_STATUS_MASK = 0xfff,/* Mask off any status flags */
  78         CTL_AUTOSENSE = 0x1000  /* Autosense performed */
  79 } ctl_io_status;
  80
  81 /*
  82  * WARNING:  Keep the data in/out/none flags where they are.  They're used
  83  * in conjuction with ctl_cmd_flags.  See comment above ctl_cmd_flags
  84  * definition in ctl_private.h.
  85  */
  86 typedef enum {
  87         CTL_FLAG_NONE           = 0x00000000,   /* no flags */
  88         CTL_FLAG_DATA_IN        = 0x00000001,   /* DATA IN */
  89         CTL_FLAG_DATA_OUT       = 0x00000002,   /* DATA OUT */
  90         CTL_FLAG_DATA_NONE      = 0x00000003,   /* no data */
  91         CTL_FLAG_DATA_MASK      = 0x00000003,
  92         CTL_FLAG_KDPTR_SGLIST   = 0x00000008,   /* kern_data_ptr is S/G list*/
  93         CTL_FLAG_EDPTR_SGLIST   = 0x00000010,   /* ext_data_ptr is S/G list */
  94         CTL_FLAG_DO_AUTOSENSE   = 0x00000020,   /* grab sense info */
  95         CTL_FLAG_USER_REQ       = 0x00000040,   /* request came from userland */
  96         CTL_FLAG_CONTROL_DEV    = 0x00000080,   /* processor device */
  97         CTL_FLAG_ALLOCATED      = 0x00000100,   /* data space allocated */
  98         CTL_FLAG_BLOCKED        = 0x00000200,   /* on the blocked queue */
  99         CTL_FLAG_ABORT          = 0x00000800,   /* this I/O should be aborted */
 100         CTL_FLAG_DMA_INPROG     = 0x00001000,   /* DMA in progress */
 101         CTL_FLAG_NO_DATASYNC    = 0x00002000,   /* don't cache flush data */
 102         CTL_FLAG_DELAY_DONE     = 0x00004000,   /* delay injection done */
 103         CTL_FLAG_INT_COPY       = 0x00008000,   /* internal copy, no done call*/
 104         CTL_FLAG_SENT_2OTHER_SC = 0x00010000,
 105         CTL_FLAG_FROM_OTHER_SC  = 0x00020000,
 106         CTL_FLAG_IS_WAS_ON_RTR  = 0x00040000,   /* Don't rerun cmd on failover*/
 107         CTL_FLAG_BUS_ADDR       = 0x00080000,   /* ctl_sglist contains BUS
 108                                                    addresses, not virtual ones*/
 109         CTL_FLAG_IO_CONT        = 0x00100000,   /* Continue I/O instead of
 110                                                    completing */
 111         CTL_FLAG_AUTO_MIRROR    = 0x00200000,   /* Automatically use memory
 112                                                    from the RC cache mirrored
 113                                                    address area. */
 114 #if 0
 115         CTL_FLAG_ALREADY_DONE   = 0x00200000    /* I/O already completed */
 116 #endif
 117         CTL_FLAG_NO_DATAMOVE    = 0x00400000,
 118         CTL_FLAG_DMA_QUEUED     = 0x00800000,   /* DMA queued but not started*/
 119         CTL_FLAG_STATUS_QUEUED  = 0x01000000,   /* Status queued but not sent*/
 120
 121         CTL_FLAG_REDIR_DONE     = 0x02000000,   /* Redirection has already
 122                                                    been done. */
 123         CTL_FLAG_FAILOVER       = 0x04000000,   /* Killed by a failover */
 124         CTL_FLAG_IO_ACTIVE      = 0x08000000,   /* I/O active on this SC */
 125         CTL_FLAG_RDMA_MASK      = CTL_FLAG_NO_DATASYNC | CTL_FLAG_BUS_ADDR |
 126                                   CTL_FLAG_AUTO_MIRROR | CTL_FLAG_REDIR_DONE
 127                                                 /* Flags we care about for
 128                                                    remote DMA */
 129 } ctl_io_flags;
 130
 131
 132 struct ctl_lba_len {
 133         uint64_t lba;
 134         uint32_t len;
 135 };
 136
 137 union ctl_priv {
 138         uint8_t         bytes[sizeof(uint64_t) * 2];
 139         uint64_t        integer;
 140         void            *ptr;
 141 };
 142
 143 /*
 144  * Number of CTL private areas.
 145  */
 146 #define CTL_NUM_PRIV    6
 147
 148 /*
 149  * Which private area are we using for a particular piece of data?
 150  */
 151 #define CTL_PRIV_LUN            0       /* CTL LUN pointer goes here */
 152 #define CTL_PRIV_LBA_LEN        1       /* Decoded LBA/len for read/write*/
 153 #define CTL_PRIV_MODEPAGE       1       /* Modepage info for config write */
 154 #define CTL_PRIV_BACKEND        2       /* Reserved for block, RAIDCore */
 155 #define CTL_PRIV_BACKEND_LUN    3       /* Backend LUN pointer */
 156 #define CTL_PRIV_FRONTEND       4       /* LSI driver, ioctl front end */
 157 #define CTL_PRIV_USER           5       /* Userland use */
 158
 159 #define CTL_INVALID_PORTNAME 0xFF
 160 #define CTL_UNMAPPED_IID     0xFF
 161 /*
 162  * XXX KDM this size is for the port_priv variable in struct ctl_io_hdr
 163  * below.  This should be defined in terms of the size of struct
 164  * ctlfe_lun_cmd_info at the moment:
 165  * struct ctlfe_lun_cmd_info {
 166  *      int cur_transfer_index;
 167  *      ctlfe_cmd_flags flags;
 168  *      bus_dma_segment_t cam_sglist[32];
 169  * };
 170  *
 171  * This isn't really the way I'd prefer to do it, but it does make some
 172  * sense, AS LONG AS we can guarantee that there will always only be one
 173  * outstanding DMA request per ctl_io.  If that assumption isn't valid,
 174  * then we've got problems.
 175  *
 176  * At some point it may be nice switch CTL over to using CCBs for
 177  * everything.  At that point we can probably use the ATIO/CTIO model, so
 178  * that multiple simultaneous DMAs per command will just work.
 179  *
 180  * Also note that the current size, 600, is appropriate for 64-bit
 181  * architectures, but is overkill for 32-bit architectures.  Need a way to
 182  * figure out the size at compile time, or just get rid of this altogether.
 183  */
 184 #define CTL_PORT_PRIV_SIZE      600
 185
 186 struct ctl_sg_entry {
 187         void    *addr;
 188         size_t  len;
 189 };
 190
 191 struct ctl_id {
 192         uint32_t                id;
 193         uint64_t                wwid[2];
 194 };
 195
 196 typedef enum {
 197         CTL_IO_NONE,
 198         CTL_IO_SCSI,
 199         CTL_IO_TASK,
 200 } ctl_io_type;
 201
 202 struct ctl_nexus {
 203         struct ctl_id initid;           /* Initiator ID */
 204         uint32_t targ_port;             /* Target port, filled in by PORT */
 205         struct ctl_id targ_target;      /* Destination target */
 206         uint32_t targ_lun;              /* Destination lun */
 207         uint32_t (*lun_map_fn)(void *arg, uint32_t lun);
 208         void *lun_map_arg;
 209 };
 210
 211 typedef enum {
 212         CTL_MSG_SERIALIZE,
 213         CTL_MSG_R2R,
 214         CTL_MSG_FINISH_IO,
 215         CTL_MSG_BAD_JUJU,
 216         CTL_MSG_MANAGE_TASKS,
 217         CTL_MSG_PERS_ACTION,
 218         CTL_MSG_SYNC_FE,
 219         CTL_MSG_APS_LOCK,
 220         CTL_MSG_DATAMOVE,
 221         CTL_MSG_DATAMOVE_DONE
 222 } ctl_msg_type;
 223
 224 struct ctl_scsiio;
 225
 226 #define CTL_NUM_SG_ENTRIES      9
 227
 228 struct ctl_io_hdr {
 229         uint32_t          version;      /* interface version XXX */
 230         ctl_io_type       io_type;      /* task I/O, SCSI I/O, etc. */
 231         ctl_msg_type      msg_type;
 232         struct ctl_nexus  nexus;        /* Initiator, port, target, lun */
 233         uint32_t          iid_indx;     /* the index into the iid mapping */
 234         uint32_t          flags;        /* transaction flags */
 235         uint32_t          status;       /* transaction status */
 236         uint32_t          port_status;  /* trans status, set by PORT, 0 = good*/
 237         uint32_t          timeout;      /* timeout in ms */
 238         uint32_t          retries;      /* retry count */
 239 #ifdef CTL_IO_DELAY
 240         uint8_t           timer_bytes[CTL_TIMER_BYTES]; /* timer kludge */
 241 #endif /* CTL_IO_DELAY */
 242 #ifdef CTL_TIME_IO
 243         time_t            start_time;   /* I/O start time */
 244         struct bintime    start_bt;     /* Timer start ticks */
 245         struct bintime    dma_start_bt; /* DMA start ticks */
 246         struct bintime    dma_bt;       /* DMA total ticks */
 247         uint32_t          num_dmas;     /* Number of DMAs */
 248 #endif /* CTL_TIME_IO */
 249         union ctl_io      *original_sc;
 250         union ctl_io      *serializing_sc;
 251         void              *pool;        /* I/O pool */
 252         union ctl_priv    ctl_private[CTL_NUM_PRIV];/* CTL private area */
 253         uint8_t           port_priv[CTL_PORT_PRIV_SIZE];/* PORT private area*/
 254         struct ctl_sg_entry remote_sglist[CTL_NUM_SG_ENTRIES];
 255         struct ctl_sg_entry remote_dma_sglist[CTL_NUM_SG_ENTRIES];
 256         struct ctl_sg_entry local_sglist[CTL_NUM_SG_ENTRIES];
 257         struct ctl_sg_entry local_dma_sglist[CTL_NUM_SG_ENTRIES];
 258         STAILQ_ENTRY(ctl_io_hdr) links; /* linked list pointer */
 259         TAILQ_ENTRY(ctl_io_hdr) ooa_links;
 260         TAILQ_ENTRY(ctl_io_hdr) blocked_links;
 261 };
 262
 263 typedef enum {
 264         CTL_TAG_UNTAGGED,
 265         CTL_TAG_SIMPLE,
 266         CTL_TAG_ORDERED,
 267         CTL_TAG_HEAD_OF_QUEUE,
 268         CTL_TAG_ACA
 269 } ctl_tag_type;
 270
 271 union ctl_io;
 272
 273 /*
 274  * SCSI passthrough I/O structure for the CAM Target Layer.  Note
 275  * that some of these fields are here for completeness, but they aren't
 276  * used in the CTL implementation.  e.g., timeout and retries won't be
 277  * used.
 278  *
 279  * Note:  Make sure the io_hdr is *always* the first element in this
 280  * structure.
 281  */
 282 struct ctl_scsiio {
 283         struct ctl_io_hdr io_hdr;       /* common to all I/O types */
 284         uint32_t   ext_sg_entries;      /* 0 = no S/G list, > 0 = num entries */
 285         uint8_t    *ext_data_ptr;       /* data buffer or S/G list */
 286         uint32_t   ext_data_len;        /* Data transfer length */
 287         uint32_t   ext_data_filled;     /* Amount of data filled so far */
 288         uint32_t   kern_sg_entries;     /* 0 = no S/G list, > 0 = num entries */
 289         uint32_t   rem_sg_entries;      /* 0 = no S/G list, > 0 = num entries */
 290         uint8_t    *kern_data_ptr;      /* data buffer or S/G list */
 291         uint32_t   kern_data_len;       /* Length of this S/G list/buffer */
 292         uint32_t   kern_total_len;      /* Total length of this transaction */
 293         uint32_t   kern_data_resid;     /* Length left to transfer after this*/
 294         uint32_t   kern_rel_offset;     /* Byte Offset of this transfer */
 295         struct     scsi_sense_data sense_data;  /* sense data */
 296         uint8_t    sense_len;           /* Returned sense length */
 297         uint8_t    scsi_status;         /* SCSI status byte */
 298         uint8_t    sense_residual;      /* sense residual length */
 299         uint32_t   residual;            /* data residual length */
 300         uint32_t   tag_num;             /* tag number */
 301         ctl_tag_type tag_type;          /* simple, ordered, head of queue,etc.*/
 302         uint8_t    cdb_len;             /* CDB length */
 303         uint8_t    cdb[CTL_MAX_CDBLEN]; /* CDB */
 304         int        (*be_move_done)(union ctl_io *io); /* called by fe */
 305         int        (*io_cont)(union ctl_io *io); /* to continue processing */
 306 };
 307
 308 typedef enum {
 309         CTL_TASK_ABORT_TASK,
 310         CTL_TASK_ABORT_TASK_SET,
 311         CTL_TASK_CLEAR_ACA,
 312         CTL_TASK_CLEAR_TASK_SET,
 313         CTL_TASK_LUN_RESET,
 314         CTL_TASK_TARGET_RESET,
 315         CTL_TASK_BUS_RESET,
 316         CTL_TASK_PORT_LOGIN,
 317         CTL_TASK_PORT_LOGOUT
 318 } ctl_task_type;
 319
 320 /*
 321  * Task management I/O structure.  Aborts, bus resets, etc., are sent using
 322  * this structure.
 323  *
 324  * Note:  Make sure the io_hdr is *always* the first element in this
 325  * structure.
 326  */
 327 struct ctl_taskio {
 328         struct ctl_io_hdr       io_hdr;      /* common to all I/O types */
 329         ctl_task_type           task_action; /* Target Reset, Abort, etc.  */
 330         uint32_t                tag_num;     /* tag number */
 331         ctl_tag_type            tag_type;    /* simple, ordered, etc. */
 332 };
 333
 334 typedef enum {
 335         CTL_PR_REG_KEY,
 336         CTL_PR_UNREG_KEY,
 337         CTL_PR_PREEMPT,
 338         CTL_PR_CLEAR,
 339         CTL_PR_RESERVE,
 340         CTL_PR_RELEASE
 341 } ctl_pr_action;
 342
 343 /*
 344  * The PR info is specifically for sending Persistent Reserve actions
 345  * to the other SC which it must also act on.
 346  *
 347  * Note:  Make sure the io_hdr is *always* the first element in this
 348  * structure.
 349  */
 350 struct ctl_pr_info {
 351         ctl_pr_action        action;
 352         uint8_t              sa_res_key[8];
 353         uint8_t              res_type;
 354         uint16_t             residx;
 355 };
 356
 357 struct ctl_ha_msg_hdr {
 358         ctl_msg_type            msg_type;
 359         union ctl_io            *original_sc;
 360         union ctl_io            *serializing_sc;
 361         struct ctl_nexus        nexus;       /* Initiator, port, target, lun */
 362         uint32_t                status;      /* transaction status */
 363         TAILQ_ENTRY(ctl_ha_msg_hdr) links;
 364 };
 365
 366 #define CTL_HA_MAX_SG_ENTRIES   16
 367
 368 /*
 369  * Used for CTL_MSG_APS_LOCK.
 370  */
 371 struct ctl_ha_msg_aps {
 372         struct ctl_ha_msg_hdr   hdr;
 373         uint8_t                 lock_flag;
 374 };
 375
 376 /*
 377  * Used for CTL_MSG_PERS_ACTION.
 378  */
 379 struct ctl_ha_msg_pr {
 380         struct ctl_ha_msg_hdr   hdr;
 381         struct ctl_pr_info      pr_info;
 382 };
 383
 384 /*
 385  * The S/G handling here is a little different than the standard ctl_scsiio
 386  * structure, because we can't pass data by reference in between controllers.
 387  * The S/G list in the ctl_scsiio struct is normally passed in the
 388  * kern_data_ptr field.  So kern_sg_entries here will always be non-zero,
 389  * even if there is only one entry.
 390  *
 391  * Used for CTL_MSG_DATAMOVE.
 392  */
 393 struct ctl_ha_msg_dt {
 394         struct ctl_ha_msg_hdr   hdr;
 395         ctl_io_flags            flags;  /* Only I/O flags are used here */
 396         uint32_t                sg_sequence;     /* S/G portion number  */
 397         uint8_t                 sg_last;         /* last S/G batch = 1 */
 398         uint32_t                sent_sg_entries; /* previous S/G count */
 399         uint32_t                cur_sg_entries;  /* current S/G entries */
 400         uint32_t                kern_sg_entries; /* total S/G entries */
 401         uint32_t                kern_data_len;   /* Length of this S/G list */
 402         uint32_t                kern_total_len;  /* Total length of this
 403                                                     transaction */
 404         uint32_t                kern_data_resid; /* Length left to transfer
 405                                                     after this*/
 406         uint32_t                kern_rel_offset; /* Byte Offset of this
 407                                                     transfer */
 408         struct ctl_sg_entry     sg_list[CTL_HA_MAX_SG_ENTRIES];
 409 };
 410
 411 /*
 412  * Used for CTL_MSG_SERIALIZE, CTL_MSG_FINISH_IO, CTL_MSG_BAD_JUJU.
 413  */
 414 struct ctl_ha_msg_scsi {
 415         struct ctl_ha_msg_hdr   hdr;
 416         uint8_t                 cdb[CTL_MAX_CDBLEN];    /* CDB */
 417         uint32_t                tag_num;     /* tag number */
 418         ctl_tag_type            tag_type;    /* simple, ordered, etc. */
 419         uint8_t                 scsi_status; /* SCSI status byte */
 420         struct scsi_sense_data  sense_data;  /* sense data */
 421         uint8_t                 sense_len;   /* Returned sense length */
 422         uint8_t                 sense_residual; /* sense residual length */
 423         uint32_t                residual;    /* data residual length */
 424         uint32_t                fetd_status; /* trans status, set by FETD,
 425                                                 0 = good*/
 426         struct ctl_lba_len      lbalen;      /* used for stats */
 427 };
 428
 429 /*
 430  * Used for CTL_MSG_MANAGE_TASKS.
 431  */
 432 struct ctl_ha_msg_task {
 433         struct ctl_ha_msg_hdr   hdr;
 434         ctl_task_type           task_action; /* Target Reset, Abort, etc.  */
 435         uint32_t                tag_num;     /* tag number */
 436         ctl_tag_type            tag_type;    /* simple, ordered, etc. */
 437 };
 438
 439 union ctl_ha_msg {
 440         struct ctl_ha_msg_hdr   hdr;
 441         struct ctl_ha_msg_task  task;
 442         struct ctl_ha_msg_scsi  scsi;
 443         struct ctl_ha_msg_dt    dt;
 444         struct ctl_ha_msg_pr    pr;
 445         struct ctl_ha_msg_aps   aps;
 446 };
 447
 448
 449 struct ctl_prio {
 450         struct ctl_io_hdr  io_hdr;
 451         struct ctl_ha_msg_pr pr_msg;
 452 };
 453
 454
 455
 456 union ctl_io {
 457         struct ctl_io_hdr io_hdr;       /* common to all I/O types */
 458         struct ctl_scsiio scsiio;       /* Normal SCSI commands */
 459         struct ctl_taskio taskio;       /* SCSI task management/reset */
 460         struct ctl_prio   presio;       /* update per. res info on other SC */
 461 };
 462
 463 #ifdef _KERNEL
 464
 465 union ctl_io *ctl_alloc_io(void *pool_ref);
 466 void ctl_free_io(union ctl_io *io);
 467 void ctl_zero_io(union ctl_io *io);
 468 void ctl_copy_io(union ctl_io *src, union ctl_io *dest);
 469
 470 #endif /* _KERNEL */
 471
 472 #endif  /* _CTL_IO_H_ */
 473
 474 /*
 475  * vim: ts=8
 476  */