xref: /freebsd/sys/cam/ctl/ctl_io.h (revision 06e8e46410776c1d2a28c89004cda266402a8e69)
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  */
477