xref: /freebsd/sys/cam/ctl/ctl_io.h (revision c1eb4109f3b1d90a9c1538179ea6a52a191899b2)
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_STATUS	= 0x00000400,	/* return TASK ABORTED status */
100 	CTL_FLAG_ABORT		= 0x00000800,	/* this I/O should be aborted */
101 	CTL_FLAG_DMA_INPROG	= 0x00001000,	/* DMA in progress */
102 	CTL_FLAG_NO_DATASYNC	= 0x00002000,	/* don't cache flush data */
103 	CTL_FLAG_DELAY_DONE	= 0x00004000,	/* delay injection done */
104 	CTL_FLAG_INT_COPY	= 0x00008000,	/* internal copy, no done call*/
105 	CTL_FLAG_SENT_2OTHER_SC	= 0x00010000,
106 	CTL_FLAG_FROM_OTHER_SC	= 0x00020000,
107 	CTL_FLAG_IS_WAS_ON_RTR  = 0x00040000,	/* Don't rerun cmd on failover*/
108 	CTL_FLAG_BUS_ADDR	= 0x00080000,	/* ctl_sglist contains BUS
109 						   addresses, not virtual ones*/
110 	CTL_FLAG_IO_CONT	= 0x00100000,	/* Continue I/O instead of
111 						   completing */
112 	CTL_FLAG_AUTO_MIRROR	= 0x00200000,	/* Automatically use memory
113 						   from the RC cache mirrored
114 						   address area. */
115 #if 0
116 	CTL_FLAG_ALREADY_DONE	= 0x00200000	/* I/O already completed */
117 #endif
118 	CTL_FLAG_NO_DATAMOVE	= 0x00400000,
119 	CTL_FLAG_DMA_QUEUED	= 0x00800000,	/* DMA queued but not started*/
120 	CTL_FLAG_STATUS_QUEUED	= 0x01000000,	/* Status queued but not sent*/
121 
122 	CTL_FLAG_REDIR_DONE	= 0x02000000,	/* Redirection has already
123 						   been done. */
124 	CTL_FLAG_FAILOVER	= 0x04000000,	/* Killed by a failover */
125 	CTL_FLAG_IO_ACTIVE	= 0x08000000,	/* I/O active on this SC */
126 	CTL_FLAG_RDMA_MASK	= CTL_FLAG_NO_DATASYNC | CTL_FLAG_BUS_ADDR |
127 				  CTL_FLAG_AUTO_MIRROR | CTL_FLAG_REDIR_DONE,
128 						/* Flags we care about for
129 						   remote DMA */
130 	CTL_FLAG_STATUS_SENT	= 0x10000000	/* Status sent by datamove */
131 } ctl_io_flags;
132 
133 
134 struct ctl_lba_len {
135 	uint64_t lba;
136 	uint32_t len;
137 };
138 
139 struct ctl_lba_len_flags {
140 	uint64_t lba;
141 	uint32_t len;
142 	uint32_t flags;
143 #define CTL_LLF_FUA	0x04000000
144 #define CTL_LLF_DPO	0x08000000
145 #define CTL_LLF_READ	0x10000000
146 #define CTL_LLF_WRITE	0x20000000
147 #define CTL_LLF_VERIFY	0x40000000
148 #define CTL_LLF_COMPARE	0x80000000
149 };
150 
151 struct ctl_ptr_len_flags {
152 	uint8_t *ptr;
153 	uint32_t len;
154 	uint32_t flags;
155 };
156 
157 union ctl_priv {
158 	uint8_t		bytes[sizeof(uint64_t) * 2];
159 	uint64_t	integer;
160 	void		*ptr;
161 };
162 
163 /*
164  * Number of CTL private areas.
165  */
166 #define	CTL_NUM_PRIV	6
167 
168 /*
169  * Which private area are we using for a particular piece of data?
170  */
171 #define	CTL_PRIV_LUN		0	/* CTL LUN pointer goes here */
172 #define	CTL_PRIV_LBA_LEN	1	/* Decoded LBA/len for read/write*/
173 #define	CTL_PRIV_MODEPAGE	1	/* Modepage info for config write */
174 #define	CTL_PRIV_BACKEND	2	/* Reserved for block, RAIDCore */
175 #define	CTL_PRIV_BACKEND_LUN	3	/* Backend LUN pointer */
176 #define	CTL_PRIV_FRONTEND	4	/* Frontend storage */
177 #define	CTL_PRIV_FRONTEND2	5	/* Another frontend storage */
178 
179 #define CTL_INVALID_PORTNAME 0xFF
180 #define CTL_UNMAPPED_IID     0xFF
181 
182 struct ctl_sg_entry {
183 	void	*addr;
184 	size_t	len;
185 };
186 
187 struct ctl_id {
188 	uint32_t		id;
189 	uint64_t		wwid[2];
190 };
191 
192 typedef enum {
193 	CTL_IO_NONE,
194 	CTL_IO_SCSI,
195 	CTL_IO_TASK,
196 } ctl_io_type;
197 
198 struct ctl_nexus {
199 	struct ctl_id initid;		/* Initiator ID */
200 	uint32_t targ_port;		/* Target port, filled in by PORT */
201 	struct ctl_id targ_target;	/* Destination target */
202 	uint32_t targ_lun;		/* Destination lun */
203 	uint32_t targ_mapped_lun;	/* Destination lun CTL-wide */
204 };
205 
206 typedef enum {
207 	CTL_MSG_SERIALIZE,
208 	CTL_MSG_R2R,
209 	CTL_MSG_FINISH_IO,
210 	CTL_MSG_BAD_JUJU,
211 	CTL_MSG_MANAGE_TASKS,
212 	CTL_MSG_PERS_ACTION,
213 	CTL_MSG_SYNC_FE,
214 	CTL_MSG_DATAMOVE,
215 	CTL_MSG_DATAMOVE_DONE
216 } ctl_msg_type;
217 
218 struct ctl_scsiio;
219 
220 #define	CTL_NUM_SG_ENTRIES	9
221 
222 struct ctl_io_hdr {
223 	uint32_t	  version;	/* interface version XXX */
224 	ctl_io_type	  io_type;	/* task I/O, SCSI I/O, etc. */
225 	ctl_msg_type	  msg_type;
226 	struct ctl_nexus  nexus;	/* Initiator, port, target, lun */
227 	uint32_t	  iid_indx;	/* the index into the iid mapping */
228 	uint32_t	  flags;	/* transaction flags */
229 	uint32_t	  status;	/* transaction status */
230 	uint32_t	  port_status;	/* trans status, set by PORT, 0 = good*/
231 	uint32_t	  timeout;	/* timeout in ms */
232 	uint32_t	  retries;	/* retry count */
233 #ifdef CTL_IO_DELAY
234 	uint8_t		  timer_bytes[CTL_TIMER_BYTES]; /* timer kludge */
235 #endif /* CTL_IO_DELAY */
236 #ifdef CTL_TIME_IO
237 	time_t		  start_time;	/* I/O start time */
238 	struct bintime	  start_bt;	/* Timer start ticks */
239 	struct bintime	  dma_start_bt;	/* DMA start ticks */
240 	struct bintime	  dma_bt;	/* DMA total ticks */
241 	uint32_t	  num_dmas;	/* Number of DMAs */
242 #endif /* CTL_TIME_IO */
243 	union ctl_io	  *original_sc;
244 	union ctl_io	  *serializing_sc;
245 	void		  *pool;	/* I/O pool */
246 	union ctl_priv	  ctl_private[CTL_NUM_PRIV];/* CTL private area */
247 	struct ctl_sg_entry remote_sglist[CTL_NUM_SG_ENTRIES];
248 	struct ctl_sg_entry remote_dma_sglist[CTL_NUM_SG_ENTRIES];
249 	struct ctl_sg_entry local_sglist[CTL_NUM_SG_ENTRIES];
250 	struct ctl_sg_entry local_dma_sglist[CTL_NUM_SG_ENTRIES];
251 	STAILQ_ENTRY(ctl_io_hdr) links;	/* linked list pointer */
252 	TAILQ_ENTRY(ctl_io_hdr) ooa_links;
253 	TAILQ_ENTRY(ctl_io_hdr) blocked_links;
254 };
255 
256 typedef enum {
257 	CTL_TAG_UNTAGGED,
258 	CTL_TAG_SIMPLE,
259 	CTL_TAG_ORDERED,
260 	CTL_TAG_HEAD_OF_QUEUE,
261 	CTL_TAG_ACA
262 } ctl_tag_type;
263 
264 union ctl_io;
265 
266 /*
267  * SCSI passthrough I/O structure for the CAM Target Layer.  Note
268  * that some of these fields are here for completeness, but they aren't
269  * used in the CTL implementation.  e.g., timeout and retries won't be
270  * used.
271  *
272  * Note:  Make sure the io_hdr is *always* the first element in this
273  * structure.
274  */
275 struct ctl_scsiio {
276 	struct ctl_io_hdr io_hdr;	/* common to all I/O types */
277 
278 	/*
279 	 * The ext_* fields are generally intended for frontend use; CTL itself
280 	 * doesn't modify or use them.
281 	 */
282 	uint32_t   ext_sg_entries;	/* 0 = no S/G list, > 0 = num entries */
283 	uint8_t	   *ext_data_ptr;	/* data buffer or S/G list */
284 	uint32_t   ext_data_len;	/* Data transfer length */
285 	uint32_t   ext_data_filled;	/* Amount of data filled so far */
286 
287 	/*
288 	 * The number of scatter/gather entries in the list pointed to
289 	 * by kern_data_ptr.  0 means there is no list, just a data pointer.
290 	 */
291 	uint32_t   kern_sg_entries;
292 
293 	uint32_t   rem_sg_entries;	/* Unused. */
294 
295 	/*
296 	 * The data pointer or a pointer to the scatter/gather list.
297 	 */
298 	uint8_t    *kern_data_ptr;
299 
300 	/*
301 	 * Length of the data buffer or scatter/gather list.  It's also
302 	 * the length of this particular piece of the data transfer,
303 	 * ie. number of bytes expected to be transferred by the current
304 	 * invocation of frontend's datamove() callback.  It's always
305 	 * less than or equal to kern_total_len.
306 	 */
307 	uint32_t   kern_data_len;
308 
309 	/*
310 	 * Total length of data to be transferred during this particular
311 	 * SCSI command, as decoded from SCSI CDB.
312 	 */
313 	uint32_t   kern_total_len;
314 
315 	/*
316 	 * Amount of data left after the current data transfer.
317 	 */
318 	uint32_t   kern_data_resid;
319 
320 	/*
321 	 * Byte offset of this transfer, equal to the amount of data
322 	 * already transferred for this SCSI command during previous
323 	 * datamove() invocations.
324 	 */
325 	uint32_t   kern_rel_offset;
326 
327 	struct     scsi_sense_data sense_data;	/* sense data */
328 	uint8_t	   sense_len;		/* Returned sense length */
329 	uint8_t	   scsi_status;		/* SCSI status byte */
330 	uint8_t	   sense_residual;	/* Unused. */
331 	uint32_t   residual;		/* data residual length */
332 	uint32_t   tag_num;		/* tag number */
333 	ctl_tag_type tag_type;		/* simple, ordered, head of queue,etc.*/
334 	uint8_t    cdb_len;		/* CDB length */
335 	uint8_t	   cdb[CTL_MAX_CDBLEN];	/* CDB */
336 	int	   (*be_move_done)(union ctl_io *io); /* called by fe */
337 	int        (*io_cont)(union ctl_io *io); /* to continue processing */
338 };
339 
340 typedef enum {
341 	CTL_TASK_ABORT_TASK,
342 	CTL_TASK_ABORT_TASK_SET,
343 	CTL_TASK_CLEAR_ACA,
344 	CTL_TASK_CLEAR_TASK_SET,
345 	CTL_TASK_I_T_NEXUS_RESET,
346 	CTL_TASK_LUN_RESET,
347 	CTL_TASK_TARGET_RESET,
348 	CTL_TASK_BUS_RESET,
349 	CTL_TASK_PORT_LOGIN,
350 	CTL_TASK_PORT_LOGOUT
351 } ctl_task_type;
352 
353 /*
354  * Task management I/O structure.  Aborts, bus resets, etc., are sent using
355  * this structure.
356  *
357  * Note:  Make sure the io_hdr is *always* the first element in this
358  * structure.
359  */
360 struct ctl_taskio {
361 	struct ctl_io_hdr	io_hdr;      /* common to all I/O types */
362 	ctl_task_type		task_action; /* Target Reset, Abort, etc.  */
363 	uint32_t		tag_num;     /* tag number */
364 	ctl_tag_type		tag_type;    /* simple, ordered, etc. */
365 };
366 
367 typedef enum {
368 	CTL_PR_REG_KEY,
369 	CTL_PR_UNREG_KEY,
370 	CTL_PR_PREEMPT,
371 	CTL_PR_CLEAR,
372 	CTL_PR_RESERVE,
373 	CTL_PR_RELEASE
374 } ctl_pr_action;
375 
376 /*
377  * The PR info is specifically for sending Persistent Reserve actions
378  * to the other SC which it must also act on.
379  *
380  * Note:  Make sure the io_hdr is *always* the first element in this
381  * structure.
382  */
383 struct ctl_pr_info {
384 	ctl_pr_action        action;
385 	uint8_t              sa_res_key[8];
386 	uint8_t              res_type;
387 	uint32_t             residx;
388 };
389 
390 struct ctl_ha_msg_hdr {
391 	ctl_msg_type		msg_type;
392 	union ctl_io		*original_sc;
393 	union ctl_io		*serializing_sc;
394 	struct ctl_nexus	nexus;	     /* Initiator, port, target, lun */
395 	uint32_t		status;	     /* transaction status */
396 	TAILQ_ENTRY(ctl_ha_msg_hdr) links;
397 };
398 
399 #define	CTL_HA_MAX_SG_ENTRIES	16
400 
401 /*
402  * Used for CTL_MSG_PERS_ACTION.
403  */
404 struct ctl_ha_msg_pr {
405 	struct ctl_ha_msg_hdr	hdr;
406 	struct ctl_pr_info	pr_info;
407 };
408 
409 /*
410  * The S/G handling here is a little different than the standard ctl_scsiio
411  * structure, because we can't pass data by reference in between controllers.
412  * The S/G list in the ctl_scsiio struct is normally passed in the
413  * kern_data_ptr field.  So kern_sg_entries here will always be non-zero,
414  * even if there is only one entry.
415  *
416  * Used for CTL_MSG_DATAMOVE.
417  */
418 struct ctl_ha_msg_dt {
419 	struct ctl_ha_msg_hdr	hdr;
420 	ctl_io_flags		flags;  /* Only I/O flags are used here */
421 	uint32_t		sg_sequence;     /* S/G portion number  */
422 	uint8_t			sg_last;         /* last S/G batch = 1 */
423 	uint32_t		sent_sg_entries; /* previous S/G count */
424 	uint32_t		cur_sg_entries;  /* current S/G entries */
425 	uint32_t		kern_sg_entries; /* total S/G entries */
426 	uint32_t		kern_data_len;   /* Length of this S/G list */
427 	uint32_t		kern_total_len;  /* Total length of this
428 						    transaction */
429 	uint32_t		kern_data_resid; /* Length left to transfer
430 						    after this*/
431 	uint32_t		kern_rel_offset; /* Byte Offset of this
432 						    transfer */
433 	struct ctl_sg_entry	sg_list[CTL_HA_MAX_SG_ENTRIES];
434 };
435 
436 /*
437  * Used for CTL_MSG_SERIALIZE, CTL_MSG_FINISH_IO, CTL_MSG_BAD_JUJU.
438  */
439 struct ctl_ha_msg_scsi {
440 	struct ctl_ha_msg_hdr	hdr;
441 	uint8_t			cdb[CTL_MAX_CDBLEN];	/* CDB */
442 	uint32_t		tag_num;     /* tag number */
443 	ctl_tag_type		tag_type;    /* simple, ordered, etc. */
444 	uint8_t			scsi_status; /* SCSI status byte */
445 	struct scsi_sense_data	sense_data;  /* sense data */
446 	uint8_t			sense_len;   /* Returned sense length */
447 	uint8_t			sense_residual;	/* sense residual length */
448 	uint32_t		residual;    /* data residual length */
449 	uint32_t		fetd_status; /* trans status, set by FETD,
450 						0 = good*/
451 	struct ctl_lba_len	lbalen;      /* used for stats */
452 };
453 
454 /*
455  * Used for CTL_MSG_MANAGE_TASKS.
456  */
457 struct ctl_ha_msg_task {
458 	struct ctl_ha_msg_hdr	hdr;
459 	ctl_task_type		task_action; /* Target Reset, Abort, etc.  */
460 	uint32_t		tag_num;     /* tag number */
461 	ctl_tag_type		tag_type;    /* simple, ordered, etc. */
462 };
463 
464 union ctl_ha_msg {
465 	struct ctl_ha_msg_hdr	hdr;
466 	struct ctl_ha_msg_task	task;
467 	struct ctl_ha_msg_scsi	scsi;
468 	struct ctl_ha_msg_dt	dt;
469 	struct ctl_ha_msg_pr	pr;
470 };
471 
472 
473 struct ctl_prio {
474 	struct ctl_io_hdr  io_hdr;
475 	struct ctl_ha_msg_pr pr_msg;
476 };
477 
478 
479 
480 union ctl_io {
481 	struct ctl_io_hdr io_hdr;	/* common to all I/O types */
482 	struct ctl_scsiio scsiio;	/* Normal SCSI commands */
483 	struct ctl_taskio taskio;	/* SCSI task management/reset */
484 	struct ctl_prio   presio;	/* update per. res info on other SC */
485 };
486 
487 #ifdef _KERNEL
488 
489 union ctl_io *ctl_alloc_io(void *pool_ref);
490 union ctl_io *ctl_alloc_io_nowait(void *pool_ref);
491 void ctl_free_io(union ctl_io *io);
492 void ctl_zero_io(union ctl_io *io);
493 void ctl_copy_io(union ctl_io *src, union ctl_io *dest);
494 
495 #endif /* _KERNEL */
496 
497 #endif	/* _CTL_IO_H_ */
498 
499 /*
500  * vim: ts=8
501  */
502