~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/scsi/scsi_cmnd.h

Version: ~ [ linux-5.14-rc3 ] ~ [ linux-5.13.5 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.53 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.135 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.198 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.240 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.276 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.276 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #ifndef _SCSI_SCSI_CMND_H
  2 #define _SCSI_SCSI_CMND_H
  3 
  4 #include <linux/dma-mapping.h>
  5 #include <linux/blkdev.h>
  6 #include <linux/list.h>
  7 #include <linux/types.h>
  8 #include <linux/timer.h>
  9 #include <linux/scatterlist.h>
 10 #include <scsi/scsi_device.h>
 11 
 12 struct Scsi_Host;
 13 struct scsi_driver;
 14 
 15 #include <scsi/scsi_device.h>
 16 
 17 /*
 18  * MAX_COMMAND_SIZE is:
 19  * The longest fixed-length SCSI CDB as per the SCSI standard.
 20  * fixed-length means: commands that their size can be determined
 21  * by their opcode and the CDB does not carry a length specifier, (unlike
 22  * the VARIABLE_LENGTH_CMD(0x7f) command). This is actually not exactly
 23  * true and the SCSI standard also defines extended commands and
 24  * vendor specific commands that can be bigger than 16 bytes. The kernel
 25  * will support these using the same infrastructure used for VARLEN CDB's.
 26  * So in effect MAX_COMMAND_SIZE means the maximum size command scsi-ml
 27  * supports without specifying a cmd_len by ULD's
 28  */
 29 #define MAX_COMMAND_SIZE 16
 30 #if (MAX_COMMAND_SIZE > BLK_MAX_CDB)
 31 # error MAX_COMMAND_SIZE can not be bigger than BLK_MAX_CDB
 32 #endif
 33 
 34 struct scsi_data_buffer {
 35         struct sg_table table;
 36         unsigned length;
 37         int resid;
 38 };
 39 
 40 /* embedded in scsi_cmnd */
 41 struct scsi_pointer {
 42         char *ptr;              /* data pointer */
 43         int this_residual;      /* left in this buffer */
 44         struct scatterlist *buffer;     /* which buffer */
 45         int buffers_residual;   /* how many buffers left */
 46 
 47         dma_addr_t dma_handle;
 48 
 49         volatile int Status;
 50         volatile int Message;
 51         volatile int have_data_in;
 52         volatile int sent_command;
 53         volatile int phase;
 54 };
 55 
 56 /* for scmd->flags */
 57 #define SCMD_TAGGED             (1 << 0)
 58 
 59 struct scsi_cmnd {
 60         struct scsi_device *device;
 61         struct list_head list;  /* scsi_cmnd participates in queue lists */
 62         struct list_head eh_entry; /* entry for the host eh_cmd_q */
 63         struct delayed_work abort_work;
 64         int eh_eflags;          /* Used by error handlr */
 65 
 66         /*
 67          * A SCSI Command is assigned a nonzero serial_number before passed
 68          * to the driver's queue command function.  The serial_number is
 69          * cleared when scsi_done is entered indicating that the command
 70          * has been completed.  It is a bug for LLDDs to use this number
 71          * for purposes other than printk (and even that is only useful
 72          * for debugging).
 73          */
 74         unsigned long serial_number;
 75 
 76         /*
 77          * This is set to jiffies as it was when the command was first
 78          * allocated.  It is used to time how long the command has
 79          * been outstanding
 80          */
 81         unsigned long jiffies_at_alloc;
 82 
 83         int retries;
 84         int allowed;
 85 
 86         unsigned char prot_op;
 87         unsigned char prot_type;
 88         unsigned char prot_flags;
 89 
 90         unsigned short cmd_len;
 91         enum dma_data_direction sc_data_direction;
 92 
 93         /* These elements define the operation we are about to perform */
 94         unsigned char *cmnd;
 95 
 96 
 97         /* These elements define the operation we ultimately want to perform */
 98         struct scsi_data_buffer sdb;
 99         struct scsi_data_buffer *prot_sdb;
100 
101         unsigned underflow;     /* Return error if less than
102                                    this amount is transferred */
103 
104         unsigned transfersize;  /* How much we are guaranteed to
105                                    transfer with each SCSI transfer
106                                    (ie, between disconnect / 
107                                    reconnects.   Probably == sector
108                                    size */
109 
110         struct request *request;        /* The command we are
111                                            working on */
112 
113 #define SCSI_SENSE_BUFFERSIZE   96
114         unsigned char *sense_buffer;
115                                 /* obtained by REQUEST SENSE when
116                                  * CHECK CONDITION is received on original
117                                  * command (auto-sense) */
118 
119         /* Low-level done function - can be used by low-level driver to point
120          *        to completion function.  Not used by mid/upper level code. */
121         void (*scsi_done) (struct scsi_cmnd *);
122 
123         /*
124          * The following fields can be written to by the host specific code. 
125          * Everything else should be left alone. 
126          */
127         struct scsi_pointer SCp;        /* Scratchpad used by some host adapters */
128 
129         unsigned char *host_scribble;   /* The host adapter is allowed to
130                                          * call scsi_malloc and get some memory
131                                          * and hang it here.  The host adapter
132                                          * is also expected to call scsi_free
133                                          * to release this memory.  (The memory
134                                          * obtained by scsi_malloc is guaranteed
135                                          * to be at an address < 16Mb). */
136 
137         int result;             /* Status code from lower level driver */
138         int flags;              /* Command flags */
139 
140         unsigned char tag;      /* SCSI-II queued command tag */
141 };
142 
143 /*
144  * Return the driver private allocation behind the command.
145  * Only works if cmd_size is set in the host template.
146  */
147 static inline void *scsi_cmd_priv(struct scsi_cmnd *cmd)
148 {
149         return cmd + 1;
150 }
151 
152 /* make sure not to use it with REQ_TYPE_BLOCK_PC commands */
153 static inline struct scsi_driver *scsi_cmd_to_driver(struct scsi_cmnd *cmd)
154 {
155         return *(struct scsi_driver **)cmd->request->rq_disk->private_data;
156 }
157 
158 extern struct scsi_cmnd *scsi_get_command(struct scsi_device *, gfp_t);
159 extern void scsi_put_command(struct scsi_cmnd *);
160 extern void scsi_finish_command(struct scsi_cmnd *cmd);
161 
162 extern void *scsi_kmap_atomic_sg(struct scatterlist *sg, int sg_count,
163                                  size_t *offset, size_t *len);
164 extern void scsi_kunmap_atomic_sg(void *virt);
165 
166 extern int scsi_init_io(struct scsi_cmnd *cmd);
167 
168 extern int scsi_dma_map(struct scsi_cmnd *cmd);
169 extern void scsi_dma_unmap(struct scsi_cmnd *cmd);
170 
171 static inline unsigned scsi_sg_count(struct scsi_cmnd *cmd)
172 {
173         return cmd->sdb.table.nents;
174 }
175 
176 static inline struct scatterlist *scsi_sglist(struct scsi_cmnd *cmd)
177 {
178         return cmd->sdb.table.sgl;
179 }
180 
181 static inline unsigned scsi_bufflen(struct scsi_cmnd *cmd)
182 {
183         return cmd->sdb.length;
184 }
185 
186 static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid)
187 {
188         cmd->sdb.resid = resid;
189 }
190 
191 static inline int scsi_get_resid(struct scsi_cmnd *cmd)
192 {
193         return cmd->sdb.resid;
194 }
195 
196 #define scsi_for_each_sg(cmd, sg, nseg, __i)                    \
197         for_each_sg(scsi_sglist(cmd), sg, nseg, __i)
198 
199 static inline int scsi_bidi_cmnd(struct scsi_cmnd *cmd)
200 {
201         return blk_bidi_rq(cmd->request) &&
202                 (cmd->request->next_rq->special != NULL);
203 }
204 
205 static inline struct scsi_data_buffer *scsi_in(struct scsi_cmnd *cmd)
206 {
207         return scsi_bidi_cmnd(cmd) ?
208                 cmd->request->next_rq->special : &cmd->sdb;
209 }
210 
211 static inline struct scsi_data_buffer *scsi_out(struct scsi_cmnd *cmd)
212 {
213         return &cmd->sdb;
214 }
215 
216 static inline int scsi_sg_copy_from_buffer(struct scsi_cmnd *cmd,
217                                            void *buf, int buflen)
218 {
219         return sg_copy_from_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
220                                    buf, buflen);
221 }
222 
223 static inline int scsi_sg_copy_to_buffer(struct scsi_cmnd *cmd,
224                                          void *buf, int buflen)
225 {
226         return sg_copy_to_buffer(scsi_sglist(cmd), scsi_sg_count(cmd),
227                                  buf, buflen);
228 }
229 
230 /*
231  * The operations below are hints that tell the controller driver how
232  * to handle I/Os with DIF or similar types of protection information.
233  */
234 enum scsi_prot_operations {
235         /* Normal I/O */
236         SCSI_PROT_NORMAL = 0,
237 
238         /* OS-HBA: Protected, HBA-Target: Unprotected */
239         SCSI_PROT_READ_INSERT,
240         SCSI_PROT_WRITE_STRIP,
241 
242         /* OS-HBA: Unprotected, HBA-Target: Protected */
243         SCSI_PROT_READ_STRIP,
244         SCSI_PROT_WRITE_INSERT,
245 
246         /* OS-HBA: Protected, HBA-Target: Protected */
247         SCSI_PROT_READ_PASS,
248         SCSI_PROT_WRITE_PASS,
249 };
250 
251 static inline void scsi_set_prot_op(struct scsi_cmnd *scmd, unsigned char op)
252 {
253         scmd->prot_op = op;
254 }
255 
256 static inline unsigned char scsi_get_prot_op(struct scsi_cmnd *scmd)
257 {
258         return scmd->prot_op;
259 }
260 
261 enum scsi_prot_flags {
262         SCSI_PROT_TRANSFER_PI           = 1 << 0,
263         SCSI_PROT_GUARD_CHECK           = 1 << 1,
264         SCSI_PROT_REF_CHECK             = 1 << 2,
265         SCSI_PROT_REF_INCREMENT         = 1 << 3,
266         SCSI_PROT_IP_CHECKSUM           = 1 << 4,
267 };
268 
269 /*
270  * The controller usually does not know anything about the target it
271  * is communicating with.  However, when DIX is enabled the controller
272  * must be know target type so it can verify the protection
273  * information passed along with the I/O.
274  */
275 enum scsi_prot_target_type {
276         SCSI_PROT_DIF_TYPE0 = 0,
277         SCSI_PROT_DIF_TYPE1,
278         SCSI_PROT_DIF_TYPE2,
279         SCSI_PROT_DIF_TYPE3,
280 };
281 
282 static inline void scsi_set_prot_type(struct scsi_cmnd *scmd, unsigned char type)
283 {
284         scmd->prot_type = type;
285 }
286 
287 static inline unsigned char scsi_get_prot_type(struct scsi_cmnd *scmd)
288 {
289         return scmd->prot_type;
290 }
291 
292 static inline sector_t scsi_get_lba(struct scsi_cmnd *scmd)
293 {
294         return blk_rq_pos(scmd->request);
295 }
296 
297 static inline unsigned int scsi_prot_interval(struct scsi_cmnd *scmd)
298 {
299         return scmd->device->sector_size;
300 }
301 
302 static inline u32 scsi_prot_ref_tag(struct scsi_cmnd *scmd)
303 {
304         return blk_rq_pos(scmd->request) >>
305                 (ilog2(scsi_prot_interval(scmd)) - 9) & 0xffffffff;
306 }
307 
308 static inline unsigned scsi_prot_sg_count(struct scsi_cmnd *cmd)
309 {
310         return cmd->prot_sdb ? cmd->prot_sdb->table.nents : 0;
311 }
312 
313 static inline struct scatterlist *scsi_prot_sglist(struct scsi_cmnd *cmd)
314 {
315         return cmd->prot_sdb ? cmd->prot_sdb->table.sgl : NULL;
316 }
317 
318 static inline struct scsi_data_buffer *scsi_prot(struct scsi_cmnd *cmd)
319 {
320         return cmd->prot_sdb;
321 }
322 
323 #define scsi_for_each_prot_sg(cmd, sg, nseg, __i)               \
324         for_each_sg(scsi_prot_sglist(cmd), sg, nseg, __i)
325 
326 static inline void set_msg_byte(struct scsi_cmnd *cmd, char status)
327 {
328         cmd->result = (cmd->result & 0xffff00ff) | (status << 8);
329 }
330 
331 static inline void set_host_byte(struct scsi_cmnd *cmd, char status)
332 {
333         cmd->result = (cmd->result & 0xff00ffff) | (status << 16);
334 }
335 
336 static inline void set_driver_byte(struct scsi_cmnd *cmd, char status)
337 {
338         cmd->result = (cmd->result & 0x00ffffff) | (status << 24);
339 }
340 
341 static inline unsigned scsi_transfer_length(struct scsi_cmnd *scmd)
342 {
343         unsigned int xfer_len = scsi_out(scmd)->length;
344         unsigned int prot_interval = scsi_prot_interval(scmd);
345 
346         if (scmd->prot_flags & SCSI_PROT_TRANSFER_PI)
347                 xfer_len += (xfer_len >> ilog2(prot_interval)) * 8;
348 
349         return xfer_len;
350 }
351 
352 #endif /* _SCSI_SCSI_CMND_H */
353 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp