baab67a81e25468fc72dfc7cc3c4daff213c5174
[mirror/scst/.git] / scst / include / scst.h
1 /*
2  *  include/scst.h
3  *
4  *  Copyright (C) 2004 - 2008 Vladislav Bolkhovitin <vst@vlnb.net>
5  *  Copyright (C) 2004 - 2005 Leonid Stoljar
6  *  Copyright (C) 2007 - 2008 CMS Distribution Limited
7  *
8  *  Main SCSI target mid-level include file.
9  *
10  *  This program is free software; you can redistribute it and/or
11  *  modify it under the terms of the GNU General Public License
12  *  as published by the Free Software Foundation, version 2
13  *  of the License.
14  *
15  *  This program is distributed in the hope that it will be useful,
16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  *  GNU General Public License for more details.
19  */
20
21 #ifndef __SCST_H
22 #define __SCST_H
23
24 #include <linux/types.h>
25 #include <linux/version.h>
26 #include <linux/blkdev.h>
27 #include <linux/interrupt.h>
28 #include <linux/proc_fs.h>
29
30 #ifdef SCST_HIGHMEM
31 #include <asm/kmap_types.h>
32 #endif
33 #include <scsi/scsi_cmnd.h>
34 #include <scsi/scsi_device.h>
35 #include <scsi/scsi_eh.h>
36 #include <scsi/scsi.h>
37
38 #include <scst_const.h>
39
40 #ifndef DECLARE_MUTEX_LOCKED
41 #define DECLARE_MUTEX_LOCKED(name)      __DECLARE_SEMAPHORE_GENERIC(name, 0)
42 #endif
43
44 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
45 typedef _Bool bool;
46 #define true  1
47 #define false 0
48 #endif
49
50 /* Version numbers, the same as for the kernel */
51 #define SCST_VERSION_CODE 0x00090601
52 #define SCST_VERSION(a, b, c, d) (((a) << 24) + ((b) << 16) + ((c) << 8) + d)
53 #define SCST_VERSION_STRING "0.9.6-rc1"
54 #define SCST_INTERFACE_VERSION SCST_VERSION_STRING "$Revision$" SCST_CONST_VERSION
55
56 /*************************************************************
57  ** States of command processing state machine. At first,
58  ** "active" states, then - "passive" ones. This is to have
59  ** more efficient generated code of the corresponding
60  ** "switch" statements.
61  *************************************************************/
62
63 /* Internal parsing */
64 #define SCST_CMD_STATE_PRE_PARSE     0
65
66 /* Dev handler's parse() is going to be called */
67 #define SCST_CMD_STATE_DEV_PARSE     1
68
69 /* Allocation of the cmd's data buffer */
70 #define SCST_CMD_STATE_PREPARE_SPACE 2
71
72 /* Target driver's rdy_to_xfer() is going to be called */
73 #define SCST_CMD_STATE_RDY_TO_XFER   3
74
75 /* Target driver's pre_exec() is going to be called */
76 #define SCST_CMD_STATE_TGT_PRE_EXEC  4
77
78 /* CDB is going to be sent to SCSI mid-level for execution */
79 #define SCST_CMD_STATE_SEND_TO_MIDLEV 5
80
81 /* Internal pos-exec checks */
82 #define SCST_CMD_STATE_PRE_DEV_DONE  6
83
84 /* Internal MODE SELECT pages related checks */
85 #define SCST_CMD_STATE_MODE_SELECT_CHECKS 7
86
87 /* Dev handler's dev_done() is going to be called */
88 #define SCST_CMD_STATE_DEV_DONE      8
89
90 /* Target driver's xmit_response() is going to be called */
91 #define SCST_CMD_STATE_PRE_XMIT_RESP 9
92
93 /* Target driver's xmit_response() is going to be called */
94 #define SCST_CMD_STATE_XMIT_RESP     10
95
96 /* The cmd finished */
97 #define SCST_CMD_STATE_FINISHED      11
98
99 #define SCST_CMD_STATE_LAST_ACTIVE   (SCST_CMD_STATE_FINISHED+100)
100
101
102 /* A cmd is created, but scst_cmd_init_done() not called */
103 #define SCST_CMD_STATE_INIT_WAIT     (SCST_CMD_STATE_LAST_ACTIVE+1)
104
105 /* LUN translation (cmd->tgt_dev assignment) */
106 #define SCST_CMD_STATE_INIT          (SCST_CMD_STATE_LAST_ACTIVE+2)
107
108 /* Allocation of the cmd's data buffer */
109 #define SCST_CMD_STATE_PREPROCESS_DONE (SCST_CMD_STATE_LAST_ACTIVE+3)
110
111 /* Waiting for data from the initiator (until scst_rx_data() called) */
112 #define SCST_CMD_STATE_DATA_WAIT     (SCST_CMD_STATE_LAST_ACTIVE+4)
113
114 /* Waiting for CDB's execution finish */
115 #define SCST_CMD_STATE_EXECUTING     (SCST_CMD_STATE_LAST_ACTIVE+5)
116
117 /* Waiting for response's transmission finish */
118 #define SCST_CMD_STATE_XMIT_WAIT     (SCST_CMD_STATE_LAST_ACTIVE+6)
119
120 /*************************************************************
121  * Can be retuned instead of cmd's state by dev handlers'
122  * functions, if the command's state should be set by default
123  *************************************************************/
124 #define SCST_CMD_STATE_DEFAULT        500
125
126 /*************************************************************
127  * Can be retuned instead of cmd's state by dev handlers'
128  * functions, if it is impossible to complete requested
129  * task in atomic context. The cmd will be restarted in thread
130  * context.
131  *************************************************************/
132 #define SCST_CMD_STATE_NEED_THREAD_CTX 1000
133
134 /*************************************************************
135  * Can be retuned instead of cmd's state by dev handlers'
136  * parse function, if the cmd processing should be stopped
137  * for now. The cmd will be restarted by dev handlers itself.
138  *************************************************************/
139 #define SCST_CMD_STATE_STOP           1001
140
141 /*************************************************************
142  ** States of mgmt command processing state machine
143  *************************************************************/
144
145 /* LUN translation (mcmd->tgt_dev assignment) */
146 #define SCST_MGMT_CMD_STATE_INIT     0
147
148 /* Mgmt cmd is ready for processing */
149 #define SCST_MGMT_CMD_STATE_READY    1
150
151 /* Mgmt cmd is being executing */
152 #define SCST_MGMT_CMD_STATE_EXECUTING 2
153
154 /* Reservations are going to be cleared, if necessary */
155 #define SCST_MGMT_CMD_STATE_CHECK_NEXUS_LOSS 3
156
157 /* Target driver's task_mgmt_fn_done() is going to be called */
158 #define SCST_MGMT_CMD_STATE_DONE     4
159
160 /* The mcmd finished */
161 #define SCST_MGMT_CMD_STATE_FINISHED 5
162
163 /*************************************************************
164  ** Constants for "atomic" parameter of SCST's functions
165  *************************************************************/
166 #define SCST_NON_ATOMIC              0
167 #define SCST_ATOMIC                  1
168
169 /*************************************************************
170  ** Values for pref_context parameter of scst_cmd_init_done() and
171  ** scst_rx_data()
172  *************************************************************/
173
174 /*
175  * Direct cmd's processing (i.e. regular function calls in the current
176  * context) sleeping is not allowed
177  */
178 #define SCST_CONTEXT_DIRECT_ATOMIC   0
179
180 /*
181  * Direct cmd's processing (i.e. regular function calls in the current
182  * context), sleeping is allowed, no restrictions
183  */
184 #define SCST_CONTEXT_DIRECT          1
185
186 /* Tasklet or thread context required for cmd's processing */
187 #define SCST_CONTEXT_TASKLET         2
188
189 /* Thread context required for cmd's processing */
190 #define SCST_CONTEXT_THREAD          3
191
192 /*
193  * SCST internal flag, which specifies that context is processable, i.e. the
194  * next command in the active list will be processed after the current one.
195  *
196  * Target drivers must never use it!!
197  */
198 #define SCST_CONTEXT_PROCESSABLE     0x100
199
200 /*************************************************************
201  ** Values for status parameter of scst_rx_data()
202  *************************************************************/
203
204 /* Success */
205 #define SCST_RX_STATUS_SUCCESS       0
206
207 /*
208  * Data receiving finished with error, so set the sense and
209  * finish the command, including xmit_response() call
210  */
211 #define SCST_RX_STATUS_ERROR         1
212
213 /*
214  * Data receiving finished with error and the sense is set,
215  * so finish the command, including xmit_response() call
216  */
217 #define SCST_RX_STATUS_ERROR_SENSE_SET 2
218
219 /*
220  * Data receiving finished with fatal error, so finish the command,
221  * but don't call xmit_response()
222  */
223 #define SCST_RX_STATUS_ERROR_FATAL   3
224
225 /*************************************************************
226  ** Values for status parameter of scst_restart_cmd()
227  *************************************************************/
228
229 /* Success */
230 #define SCST_PREPROCESS_STATUS_SUCCESS       0
231
232 /*
233  * Command's processing finished with error, so set the sense and
234  * finish the command, including xmit_response() call
235  */
236 #define SCST_PREPROCESS_STATUS_ERROR         1
237
238 /*
239  * Command's processing finished with error and the sense is set,
240  * so finish the command, including xmit_response() call
241  */
242 #define SCST_PREPROCESS_STATUS_ERROR_SENSE_SET 2
243
244 /*
245  * Command's processing finished with fatal error, so finish the command,
246  * but don't call xmit_response()
247  */
248 #define SCST_PREPROCESS_STATUS_ERROR_FATAL   3
249
250 /* Thread context requested */
251 #define SCST_PREPROCESS_STATUS_NEED_THREAD   4
252
253 /*************************************************************
254  ** Allowed return codes for xmit_response(), rdy_to_xfer(),
255  ** report_aen()
256  *************************************************************/
257
258 /* Success */
259 #define SCST_TGT_RES_SUCCESS         0
260
261 /* Internal device queue is full, retry again later */
262 #define SCST_TGT_RES_QUEUE_FULL      -1
263
264 /*
265  * It is impossible to complete requested task in atomic context.
266  * The cmd will be restarted in thread  context.
267  */
268 #define SCST_TGT_RES_NEED_THREAD_CTX -2
269
270 /*
271  * Fatal error, if returned by xmit_response() the cmd will
272  * be destroyed, if by any other function, xmit_response()
273  * will be called with HARDWARE ERROR sense data
274  */
275 #define SCST_TGT_RES_FATAL_ERROR     -3
276
277 /*************************************************************
278  ** Allowed return codes for dev handler's exec()
279  *************************************************************/
280
281 /* The cmd is done, go to other ones */
282 #define SCST_EXEC_COMPLETED          0
283
284 /* The cmd should be sent to SCSI mid-level */
285 #define SCST_EXEC_NOT_COMPLETED      1
286
287 /*
288  * Thread context is required to execute the command.
289  * Exec() will be called again in the thread context.
290  */
291 #define SCST_EXEC_NEED_THREAD        2
292
293 /*
294  * Set if cmd is finished and there is status/sense to be sent.
295  * The status should be not sent (i.e. the flag not set) if the
296  * possibility to perform a command in "chunks" (i.e. with multiple
297  * xmit_response()/rdy_to_xfer()) is used (not implemented yet).
298  * Obsolete, use scst_cmd_get_is_send_status() instead.
299  */
300 #define SCST_TSC_FLAG_STATUS         0x2
301
302 /*************************************************************
303  ** Additional return code for dev handler's task_mgmt_fn()
304  *************************************************************/
305
306 /* Regular standard actions for the command should be done */
307 #define SCST_DEV_TM_NOT_COMPLETED     1
308
309 /*************************************************************
310  ** Session initialization phases
311  *************************************************************/
312
313 /* Set if session is being initialized */
314 #define SCST_SESS_IPH_INITING        0
315
316 /* Set if the session is successfully initialized */
317 #define SCST_SESS_IPH_SUCCESS        1
318
319 /* Set if the session initialization failed */
320 #define SCST_SESS_IPH_FAILED         2
321
322 /* Set if session is initialized and ready */
323 #define SCST_SESS_IPH_READY          3
324
325 /*************************************************************
326  ** Session shutdown phases
327  *************************************************************/
328
329 /* Set if session is initialized and ready */
330 #define SCST_SESS_SPH_READY          0
331
332 /* Set if session is shutting down */
333 #define SCST_SESS_SPH_SHUTDOWN       1
334
335 /*************************************************************
336  ** Cmd's async (atomic) flags
337  *************************************************************/
338
339 /* Set if the cmd is aborted and ABORTED sense will be sent as the result */
340 #define SCST_CMD_ABORTED                0
341
342 /* Set if the cmd is aborted by other initiator */
343 #define SCST_CMD_ABORTED_OTHER          1
344
345 /* Set if no response should be sent to the target about this cmd */
346 #define SCST_CMD_NO_RESP                2
347
348 /* Set if the cmd is dead and can be destroyed at any time */
349 #define SCST_CMD_CAN_BE_DESTROYED       3
350
351 /*************************************************************
352  ** Tgt_dev's flags (tgt_dev_flags)
353  *************************************************************/
354
355 /* Set if tgt_dev has Unit Attention sense */
356 #define SCST_TGT_DEV_UA_PENDING         0
357
358 /* Set if tgt_dev is RESERVED by another session */
359 #define SCST_TGT_DEV_RESERVED           1
360
361 /* Set if the corresponding context is atomic */
362 #define SCST_TGT_DEV_AFTER_INIT_WR_ATOMIC       5
363 #define SCST_TGT_DEV_AFTER_INIT_OTH_ATOMIC      6
364 #define SCST_TGT_DEV_AFTER_RESTART_WR_ATOMIC    7
365 #define SCST_TGT_DEV_AFTER_RESTART_OTH_ATOMIC   8
366 #define SCST_TGT_DEV_AFTER_RX_DATA_ATOMIC       9
367 #define SCST_TGT_DEV_AFTER_EXEC_ATOMIC          10
368
369 #ifdef DEBUG_TM
370 #define SCST_TGT_DEV_UNDER_TM_DBG               20
371 #endif
372
373 /*************************************************************
374  ** Name of the entry in /proc
375  *************************************************************/
376 #define SCST_PROC_ENTRY_NAME         "scsi_tgt"
377
378 /*************************************************************
379  ** Activities suspending timeout
380  *************************************************************/
381 #define SCST_SUSPENDING_TIMEOUT                 (90 * HZ)
382
383 /*************************************************************
384  ** Kernel cache creation helper
385  *************************************************************/
386 #ifndef KMEM_CACHE
387 #define KMEM_CACHE(__struct, __flags) kmem_cache_create(#__struct,\
388         sizeof(struct __struct), __alignof__(struct __struct),\
389         (__flags), NULL, NULL)
390 #endif
391
392 /*************************************************************
393  *                     TYPES
394  *************************************************************/
395
396 struct scst_tgt;
397 struct scst_session;
398 struct scst_cmd;
399 struct scst_mgmt_cmd;
400 struct scst_device;
401 struct scst_tgt_dev;
402 struct scst_dev_type;
403 struct scst_acg;
404 struct scst_acg_dev;
405 struct scst_acn;
406
407 typedef uint64_t lun_t;
408
409 typedef enum dma_data_direction scst_data_direction;
410
411 enum scst_cdb_flags {
412         SCST_TRANSFER_LEN_TYPE_FIXED = 0x01, /* must be equviv 1 (FIXED_BIT in cdb) */
413         SCST_SMALL_TIMEOUT = 0x02,
414         SCST_LONG_TIMEOUT = 0x04,
415         SCST_UNKNOWN_LENGTH = 0x08,
416         SCST_INFO_INVALID = 0x10,
417 };
418
419 /*
420  * Scsi_Target_Template: defines what functions a target driver will
421  * have to provide in order to work with the target mid-level.
422  * MUST HAVEs define functions that are expected to be in order to work.
423  * OPTIONAL says that there is a choice.
424  * Also, pay attention to the fact that a command is BLOCKING or NON-BLOCKING.
425  * NON-BLOCKING means that a function returns immediately and will not wait
426  * for actual data transfer to finish. Blocking in such command could have
427  * negative impact on overall system performance. If blocking is necessary,
428  * it is worth to consider creating dedicated thread(s) in target driver, to
429  * which the commands would be passed and which would perform blocking
430  * operations instead of SCST.
431  * If the function allowed to sleep or not is determined by its last
432  * argument, which is true, if sleeping is not allowed. In this case,
433  * if the function requires sleeping, it  can return
434  * SCST_TGT_RES_NEED_THREAD_CTX, and it will be recalled in the thread context,
435  * where sleeping is allowed.
436  */
437 struct scst_tgt_template {
438         /* public: */
439
440         /*
441          * SG tablesize allows to check whether scatter/gather can be used
442          * or not.
443          */
444         int sg_tablesize;
445
446         /*
447          * True, if this target adapter uses unchecked DMA onto an ISA bus.
448          */
449         unsigned unchecked_isa_dma:1;
450
451         /*
452          * True, if this target adapter can benefit from using SG-vector
453          * clustering (i.e. smaller number of segments).
454          */
455         unsigned use_clustering:1;
456
457         /*
458          * True, if this target adapter doesn't support SG-vector clustering
459          */
460         unsigned no_clustering:1;
461
462         /*
463          * True, if corresponding function supports execution in
464          * the atomic (non-sleeping) context
465          */
466         unsigned xmit_response_atomic:1;
467         unsigned rdy_to_xfer_atomic:1;
468
469         /* True, if the template doesn't need the entry in /proc */
470         unsigned no_proc_entry:1;
471
472         /*
473          * This function is equivalent to the SCSI
474          * queuecommand. The target should transmit the response
475          * buffer and the status in the scst_cmd struct.
476          * The expectation is that this executing this command is NON-BLOCKING.
477          *
478          * After the response is actually transmitted, the target
479          * should call the scst_tgt_cmd_done() function of the
480          * mid-level, which will allow it to free up the command.
481          * Returns one of the SCST_TGT_RES_* constants.
482          *
483          * Pay attention to "atomic" attribute of the cmd, which can be get
484          * by scst_cmd_atomic(): it is true if the function called in the
485          * atomic (non-sleeping) context.
486          *
487          * MUST HAVE
488          */
489         int (*xmit_response) (struct scst_cmd *cmd);
490
491         /*
492          * This function informs the driver that data
493          * buffer corresponding to the said command have now been
494          * allocated and it is OK to receive data for this command.
495          * This function is necessary because a SCSI target does not
496          * have any control over the commands it receives. Most lower
497          * level protocols have a corresponding function which informs
498          * the initiator that buffers have been allocated e.g., XFER_
499          * RDY in Fibre Channel. After the data is actually received
500          * the low-level driver needs to call scst_rx_data() in order to
501          * continue processing this command.
502          * Returns one of the SCST_TGT_RES_* constants.
503          * This command is expected to be NON-BLOCKING.
504          *
505          * Pay attention to "atomic" attribute of the cmd, which can be get
506          * by scst_cmd_atomic(): it is true if the function called in the
507          * atomic (non-sleeping) context.
508          *
509          * OPTIONAL
510          */
511         int (*rdy_to_xfer) (struct scst_cmd *cmd);
512
513         /*
514          * Called to notify the driver that the command is about to be freed.
515          * Necessary, because for aborted commands xmit_response() could not
516          * be called. Could be called on IRQ context.
517          *
518          * OPTIONAL
519          */
520         void (*on_free_cmd) (struct scst_cmd *cmd);
521
522         /*
523          * This function allows target driver to handle data buffer
524          * allocations on its own.
525          *
526          * Target driver doesn't have to always allocate buffer in this
527          * function, but if it decide to do it, it must check that
528          * scst_cmd_get_data_buff_alloced() returns 0, otherwise to avoid
529          * double buffer allocation and memory leaks alloc_data_buf() shall
530          * fail.
531          *
532          * Shall return 0 in case of success or < 0 (preferrably -ENOMEM)
533          * in case of error, or > 0 if the regular SCST allocation should be
534          * done. In case of returning successfully, scst_cmd->data_buf_alloced
535          * will be set by SCST.
536          *
537          * If allocation in atomic context - cf. scst_cmd_atomic() - is not
538          * desired or fails and consequently < 0 is returned, this function
539          * will be re-called in thread context.
540          *
541          * Please note that the driver will have to handle itself all relevant
542          * details such as scatterlist setup, highmem, freeing the allocated
543          * memory, etc.
544          *
545          * OPTIONAL.
546          */
547         int (*alloc_data_buf) (struct scst_cmd *cmd);
548
549         /*
550          * This function informs the driver that data
551          * buffer corresponding to the said command have now been
552          * allocated and other preprocessing tasks have been done.
553          * A target driver could need to do some actions at this stage.
554          * After the target driver done the needed actions, it shall call
555          * scst_restart_cmd() in order to continue processing this command.
556          *
557          * Called only if the cmd is queued using scst_cmd_init_stage1_done()
558          * instead of scst_cmd_init_done().
559          *
560          * Returns void, the result is expected to be returned using
561          * scst_restart_cmd().
562          *
563          * This command is expected to be NON-BLOCKING.
564          *
565          * Pay attention to "atomic" attribute of the cmd, which can be get
566          * by scst_cmd_atomic(): it is true if the function called in the
567          * atomic (non-sleeping) context.
568          *
569          * OPTIONAL.
570          */
571         void (*preprocessing_done) (struct scst_cmd *cmd);
572
573         /*
574          * This function informs the driver that the said command is about
575          * to be executed.
576          *
577          * Returns one of the SCST_PREPROCESS_* constants.
578          *
579          * This command is expected to be NON-BLOCKING.
580          *
581          * Pay attention to "atomic" attribute of the cmd, which can be get
582          * by scst_cmd_atomic(): it is true if the function called in the
583          * atomic (non-sleeping) context.
584          *
585          * OPTIONAL
586          */
587         int (*pre_exec) (struct scst_cmd *cmd);
588
589         /*
590          * This function informs the driver that a
591          * received task management function has been completed. This
592          * function is necessary because low-level protocols have some
593          * means of informing the initiator about the completion of a
594          * Task Management function. This function being called will
595          * signify that a Task Management function is completed as far
596          * as the mid-level is concerned. Any information that must be
597          * stored about the command is the responsibility of the low-
598          * level driver. No return value expected.
599          * This function is expected to be NON-BLOCKING
600          *
601          * Called without any locks held from a thread context.
602          *
603          * MUST HAVE if the target supports ABORTs
604          */
605         void (*task_mgmt_fn_done) (struct scst_mgmt_cmd *mgmt_cmd);
606
607         /*
608          * This function should detect the target adapters that
609          * are present in the system. The function should return a value
610          * >= 0 to signify the number of detected target adapters.
611          * A negative value should be returned whenever there is
612          * an error.
613          *
614          * MUST HAVE
615          */
616         int (*detect) (struct scst_tgt_template *tgt_template);
617
618         /*
619          * This function should free up the resources allocated to the device.
620          * The function should return 0 to indicate successful release
621          * or a negative value if there are some issues with the release.
622          * In the current version the return value is ignored.
623          *
624          * MUST HAVE
625          */
626         int (*release) (struct scst_tgt *tgt);
627
628         /*
629          * This function is used for Asynchronous Event Notification.
630          * It is the responsibility of the driver to notify any/all
631          * initiators about the Asynchronous Event reported.
632          * Returns one of the SCST_TGT_RES_* constants.
633          * This command is expected to be NON-BLOCKING, but can sleep.
634          *
635          * MUST HAVE if low-level protocol supports AEN
636          *
637          * ToDo
638          */
639         int (*report_aen) (int mgmt_fn, const uint8_t *lun, int lun_len);
640
641         /*
642          * Those functions can be used to export the driver's statistics and
643          * other infos to the world outside the kernel as well as to get some
644          * management commands from it.
645          *
646          * OPTIONAL
647          */
648         int (*read_proc) (struct seq_file *seq, struct scst_tgt *tgt);
649         int (*write_proc) (char *buffer, char **start, off_t offset,
650                 int length, int *eof, struct scst_tgt *tgt);
651
652         /*
653          * Name of the template. Must be unique to identify
654          * the template. MUST HAVE
655          */
656         const char name[50];
657
658         /*
659          * Number of additional threads to the pool of dedicated threads.
660          * Used if xmit_response() or rdy_to_xfer() is blocking.
661          * It is the target driver's duty to ensure that not more, than that
662          * number of threads, are blocked in those functions at any time.
663          */
664         int threads_num;
665
666         /* Private, must be inited to 0 by memset() */
667
668         /* List of targets per template, protected by scst_mutex */
669         struct list_head tgt_list;
670
671         /* List entry of global templates list */
672         struct list_head scst_template_list_entry;
673
674         /* The pointer to the /proc directory entry */
675         struct proc_dir_entry *proc_tgt_root;
676
677         /* Device number in /proc */
678         int proc_dev_num;
679 };
680
681 struct scst_dev_type {
682         /* SCSI type of the supported device. MUST HAVE */
683         int type;
684
685         /*
686          * True, if corresponding function supports execution in
687          * the atomic (non-sleeping) context
688          */
689         unsigned parse_atomic:1;
690         unsigned exec_atomic:1;
691         unsigned dev_done_atomic:1;
692
693         /* Set, if no /proc files should be automatically created by SCST */
694         unsigned no_proc:1;
695
696         /* Set, if exec() is synchronous */
697         unsigned exec_sync:1;
698
699         /*
700          * Called to parse CDB from the cmd and initialize
701          * cmd->bufflen and cmd->data_direction (both - REQUIRED).
702          * Returns the command's next state or SCST_CMD_STATE_DEFAULT,
703          * if the next default state should be used, or
704          * SCST_CMD_STATE_NEED_THREAD_CTX if the function called in atomic
705          * context, but requires sleeping, or SCST_CMD_STATE_STOP if the
706          * command should not be further processed for now. In the
707          * SCST_CMD_STATE_NEED_THREAD_CTX case the function
708          * will be recalled in the thread context, where sleeping is allowed.
709          *
710          * Pay attention to "atomic" attribute of the cmd, which can be get
711          * by scst_cmd_atomic(): it is true if the function called in the
712          * atomic (non-sleeping) context.
713          *
714          * MUST HAVE
715          */
716         int (*parse) (struct scst_cmd *cmd);
717
718         /*
719          * Called to execute CDB. Useful, for instance, to implement
720          * data caching. The result of CDB execution is reported via
721          * cmd->scst_cmd_done() callback.
722          * Returns:
723          *  - SCST_EXEC_COMPLETED - the cmd is done, go to other ones
724          *  - SCST_EXEC_NEED_THREAD - thread context is required to execute
725          *    the command. Exec() will be called again in the thread context.
726          *  - SCST_EXEC_NOT_COMPLETED - the cmd should be sent to SCSI mid-level.
727          *
728          * Pay attention to "atomic" attribute of the cmd, which can be get
729          * by scst_cmd_atomic(): it is true if the function called in the
730          * atomic (non-sleeping) context.
731          *
732          * If this function provides sync execution, you must set above
733          * exec_sync flag and should consider to setup dedicated threads by
734          * setting threads_num > 0.
735          *
736          * !! If this function is implemented, scst_check_local_events() shall !!
737          * !! be called inside it just before the actual command's execution.  !!
738          *
739          * OPTIONAL, if not set, the commands will be sent directly to SCSI
740          * device.
741          */
742         int (*exec) (struct scst_cmd *cmd);
743
744         /*
745          * Called to notify dev handler about the result of cmd execution
746          * and perform some post processing. Cmd's fields is_send_status and
747          * resp_data_len should be set by this function, but SCST offers good
748          * defaults.
749          * Returns the command's next state or SCST_CMD_STATE_DEFAULT,
750          * if the next default state should be used, or
751          * SCST_CMD_STATE_NEED_THREAD_CTX if the function called in atomic
752          * context, but requires sleeping. In the last case, the function
753          * will be recalled in the thread context, where sleeping is allowed.
754          *
755          * Pay attention to "atomic" attribute of the cmd, which can be get
756          * by scst_cmd_atomic(): it is true if the function called in the
757          * atomic (non-sleeping) context.
758          */
759         int (*dev_done) (struct scst_cmd *cmd);
760
761         /*
762          * Called to notify dev hander that the command is about to be freed.
763          * Could be called on IRQ context.
764          */
765         void (*on_free_cmd) (struct scst_cmd *cmd);
766
767         /*
768          * Called to execute a task management command.
769          * Returns:
770          *  - SCST_MGMT_STATUS_SUCCESS - the command is done with success,
771          *      no firther actions required
772          *  - The SCST_MGMT_STATUS_* error code if the command is failed and
773          *      no further actions required
774          *  - SCST_DEV_TM_NOT_COMPLETED - regular standard actions for the command
775          *      should be done
776          *
777          * Called without any locks held from a thread context.
778          */
779         int (*task_mgmt_fn) (struct scst_mgmt_cmd *mgmt_cmd,
780                 struct scst_tgt_dev *tgt_dev);
781
782         /*
783          * Called when new device is attaching to the dev handler
784          * Returns 0 on success, error code otherwise.
785          */
786         int (*attach) (struct scst_device *dev);
787
788         /* Called when new device is detaching from the dev handler */
789         void (*detach) (struct scst_device *dev);
790
791         /*
792          * Called when new tgt_dev (session) is attaching to the dev handler.
793          * Returns 0 on success, error code otherwise.
794          */
795         int (*attach_tgt) (struct scst_tgt_dev *tgt_dev);
796
797         /* Called when tgt_dev (session) is detaching from the dev handler */
798         void (*detach_tgt) (struct scst_tgt_dev *tgt_dev);
799
800         /*
801          * Those functions can be used to export the handler's statistics and
802          * other infos to the world outside the kernel as well as to get some
803          * management commands from it.
804          *
805          * OPTIONAL
806          */
807         int (*read_proc) (struct seq_file *seq, struct scst_dev_type *dev_type);
808         int (*write_proc) (char *buffer, char **start, off_t offset,
809                 int length, int *eof, struct scst_dev_type *dev_type);
810
811         /* Name of the dev handler. Must be unique. MUST HAVE */
812         char name[15];
813
814         /*
815          * Number of dedicated threads. If 0 - no dedicated threads will
816          * be created, if <0 - creation of dedicated threads is prohibited.
817          */
818         int threads_num;
819
820         struct module *module;
821
822         /* private: */
823
824         /* list entry in scst_dev_type_list */
825         struct list_head dev_type_list_entry;
826
827         /* The pointer to the /proc directory entry */
828         struct proc_dir_entry *proc_dev_type_root;
829 };
830
831 struct scst_tgt {
832         /* List of remote sessions per target, protected by scst_mutex */
833         struct list_head sess_list;
834
835         /* List entry of targets per template (tgts_list) */
836         struct list_head tgt_list_entry;
837
838         struct scst_tgt_template *tgtt; /* corresponding target template */
839
840         /* Used to wait until session finished to unregister */
841         wait_queue_head_t unreg_waitQ;
842
843         /* Device number in /proc */
844         int proc_num;
845
846         /*
847          * The following fields used to store and retry cmds if
848          * target's internal queue is full, so the target is unable to accept
849          * the cmd returning QUEUE FULL
850          */
851         atomic_t finished_cmds;
852         int retry_cmds;         /* protected by tgt_lock */
853         spinlock_t tgt_lock;
854         struct list_head retry_cmd_list; /* protected by tgt_lock */
855         struct timer_list retry_timer;
856         int retry_timer_active;
857
858         /*
859          * Maximum SG table size. Needed here, since different cards on the
860          * same target template can have different SG table limitations.
861          */
862         int sg_tablesize;
863
864         /* Used for storage of target driver private stuff */
865         void *tgt_priv;
866
867         /* Name on the default security group ("Default_target_name") */
868         char *default_group_name;
869 };
870
871 /* Hash size and hash fn for hash based lun translation */
872 #define TGT_DEV_HASH_SHIFT      5
873 #define TGT_DEV_HASH_SIZE       (1<<TGT_DEV_HASH_SHIFT)
874 #define HASH_VAL(_val)          (_val & (TGT_DEV_HASH_SIZE - 1))
875
876 struct scst_session {
877         /*
878          * Initialization phase, one of SCST_SESS_IPH_* constants, protected by
879          * sess_list_lock
880          */
881         int init_phase;
882
883         atomic_t refcnt;                /* get/put counter */
884
885         /**************************************************************/
886
887         /* Alive commands for this session. ToDo: make it part of the common IO flow control */
888         atomic_t sess_cmd_count;
889
890         spinlock_t sess_list_lock; /* protects search_cmd_list, etc */
891
892         /*
893          * List of cmds in this session. Used to find a cmd in the
894          * session. Protected by sess_list_lock.
895          */
896         struct list_head search_cmd_list;
897
898         /*
899          * Hash list of tgt_dev's for this session, protected by scst_mutex
900          * and suspended activity
901          */
902         struct list_head sess_tgt_dev_list_hash[TGT_DEV_HASH_SIZE];
903
904         /* Access control for this session and list entry there */
905         struct scst_acg *acg;
906
907         /* List entry for the sessions list inside ACG */
908         struct list_head acg_sess_list_entry;
909
910         struct scst_tgt *tgt;   /* corresponding target */
911
912         /* Used for storage of target driver private stuff */
913         void *tgt_priv;
914
915         /* Name of attached initiator */
916         const char *initiator_name;
917
918         /* List entry of sessions per target */
919         struct list_head sess_list_entry;
920
921         /* List entry for the list that keeps session, waiting for the init */
922         struct list_head sess_init_list_entry;
923
924         /* List entry for the list that keeps session, waiting for the shutdown */
925         struct list_head sess_shut_list_entry;
926
927         /*
928          * Lists of deffered during session initialization commands.
929          * Protected by sess_list_lock.
930          */
931         struct list_head init_deferred_cmd_list;
932         struct list_head init_deferred_mcmd_list;
933
934         /*
935          * Shutdown phase, one of SCST_SESS_SPH_* constants, unprotected.
936          * Async. relating to init_phase, must be a separate variable, because
937          * session could be unregistered before async. registration is finished.
938          */
939         unsigned long shut_phase;
940
941         /* Used if scst_unregister_session() called in wait mode */
942         struct completion *shutdown_compl;
943
944         /*
945          * Functions and data for user callbacks from scst_register_session()
946          * and scst_unregister_session()
947          */
948         void *reg_sess_data;
949         void (*init_result_fn) (struct scst_session *sess, void *data,
950                                 int result);
951         void (*unreg_done_fn) (struct scst_session *sess);
952         void (*unreg_cmds_done_fn) (struct scst_session *sess);
953
954 #ifdef MEASURE_LATENCY /* must be last */
955         spinlock_t meas_lock;
956         uint64_t scst_time, processing_time;
957         unsigned int processed_cmds;
958 #endif
959 };
960
961 struct scst_cmd_lists {
962         spinlock_t cmd_list_lock;
963         struct list_head active_cmd_list;
964         wait_queue_head_t cmd_list_waitQ;
965         struct list_head lists_list_entry;
966 };
967
968 struct scst_cmd {
969         /* List entry for below *_cmd_lists */
970         struct list_head cmd_list_entry;
971
972         /* Pointer to lists of commands with the lock */
973         struct scst_cmd_lists *cmd_lists;
974
975         atomic_t cmd_ref;
976
977         struct scst_session *sess;      /* corresponding session */
978
979         /* Cmd state, one of SCST_CMD_STATE_* constants */
980         int state;
981
982         /*************************************************************
983          ** Cmd's flags
984          *************************************************************/
985         /*
986          * Set if expected_sn was incremented, i.e. cmd was sent to
987          * SCSI mid-level for execution
988          */
989         unsigned int sent_to_midlev:1;
990
991         /* Set if scst_local_exec() was already called for this cmd */
992         unsigned int local_exec_done:1;
993
994         /* Set if the cmd's action is completed */
995         unsigned int completed:1;
996
997         /* Set if we should ignore Unit Attention in scst_check_sense() */
998         unsigned int ua_ignore:1;
999
1000         /* Set if cmd is being processed in atomic context */
1001         unsigned int atomic:1;
1002
1003         /* Set if this command contains status */
1004         unsigned int is_send_status:1;
1005
1006         /*
1007          * Set if the cmd is being processed in the processable context. See
1008          * comment for SCST_CONTEXT_PROCESSABLE for what it means.
1009          */
1010         unsigned int context_processable:1;
1011
1012         /* Set if cmd is internally generated */
1013         unsigned int internal:1;
1014
1015         /* Set if cmd is being retried */
1016         unsigned int retry:1;
1017
1018         /* Set if the device was blocked by scst_inc_on_dev_cmd() (for debug) */
1019         unsigned int inc_blocking:1;
1020
1021         /* Set if the device should be unblocked after cmd's finish */
1022         unsigned int needs_unblocking:1;
1023
1024         /* Set if scst_dec_on_dev_cmd() call is needed on the cmd's finish */
1025         unsigned int dec_on_dev_needed:1;
1026
1027         /*
1028          * Set if the target driver wants to alloc data buffers on its own.
1029          * In this case alloc_data_buf() must be provided in the target driver
1030          * template.
1031          */
1032         unsigned int data_buf_tgt_alloc:1;
1033
1034         /*
1035          * Set by SCST if the custom data buffer allocation by the target driver
1036          * succeeded.
1037          */
1038         unsigned int data_buf_alloced:1;
1039
1040         /* Set if the target driver called scst_set_expected() */
1041         unsigned int expected_values_set:1;
1042
1043         /*
1044          * Set if the cmd was delayed by task management debugging code.
1045          * Used only if DEBUG_TM is on.
1046          */
1047         unsigned int tm_dbg_delayed:1;
1048
1049         /*
1050          * Set if the cmd must be ignored by task management debugging code.
1051          * Used only if DEBUG_TM is on.
1052          */
1053         unsigned int tm_dbg_immut:1;
1054
1055         /*
1056          * Set if the SG buffer was modified by scst_set_resp_data_len()
1057          */
1058         unsigned int sg_buff_modified:1;
1059
1060         /*
1061          * Set if scst_cmd_init_stage1_done() called and the target
1062          * want that preprocessing_done() will be called
1063          */
1064         unsigned int preprocessing_only:1;
1065
1066         /* Set if cmd's SN was set */
1067         unsigned int sn_set:1;
1068
1069         /* Set if hq_cmd_count was incremented */
1070         unsigned int hq_cmd_inced:1;
1071
1072         /*
1073          * Set if scst_cmd_init_stage1_done() called and the target wants
1074          * that the SN for the cmd won't be assigned until scst_restart_cmd()
1075          */
1076         unsigned int set_sn_on_restart_cmd:1;
1077
1078         /* Set if the cmd's must not use sgv cache for data buffer */
1079         unsigned int no_sgv:1;
1080
1081         /*
1082          * Set if target driver may need to call dma_sync_sg() or similar
1083          * function before transferring cmd' data to the target device
1084          * via DMA.
1085          */
1086         unsigned int may_need_dma_sync:1;
1087
1088         /* Set if the cmd was done or aborted out of its SN */
1089         unsigned int out_of_sn:1;
1090
1091         /* Set if increment expected_sn in cmd->scst_cmd_done() */
1092         unsigned int inc_expected_sn_on_done:1;
1093
1094         /*
1095          * Set if xmit_response() is going to need a considerable processing
1096          * time. Processing time is considerable, if it's > context switch time
1097          * (about 1 usec on modern systems). It's needed to trigger other
1098          * threads to start processing other outstanding commands without
1099          * waiting XMIT for the current one to finish. E.g., it should be set
1100          * if iSCSI data digest used and cmd has READ direction.
1101          */
1102         unsigned int long_xmit:1;
1103
1104         /* Set if tgt_sn field is valid */
1105         unsigned int tgt_sn_set:1;
1106
1107         /* Set if cmd is done */
1108         unsigned int done:1;
1109
1110         /* Set if cmd is finished */
1111         unsigned int finished:1;
1112
1113         /**************************************************************/
1114
1115         unsigned long cmd_flags; /* cmd's async flags */
1116
1117         /* Keeps status of cmd's status/data delivery to remote initiator */
1118         int delivery_status;
1119
1120         struct scst_tgt_template *tgtt; /* to save extra dereferences */
1121         struct scst_tgt *tgt;           /* to save extra dereferences */
1122         struct scst_device *dev;        /* to save extra dereferences */
1123
1124         struct scst_tgt_dev *tgt_dev;   /* corresponding device for this cmd */
1125
1126         lun_t lun;                      /* LUN for this cmd */
1127
1128         unsigned long start_time;
1129
1130 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
1131         struct scsi_request *scsi_req;  /* SCSI request */
1132 #endif
1133
1134         /* List entry for tgt_dev's SN related lists */
1135         struct list_head sn_cmd_list_entry;
1136
1137         /* Cmd's serial number, used to execute cmd's in order of arrival */
1138         unsigned long sn;
1139
1140         /* The corresponding sn_slot in tgt_dev->sn_slots */
1141         atomic_t *sn_slot;
1142
1143         /* List entry for session's search_cmd_list */
1144         struct list_head search_cmd_list_entry;
1145
1146         /*
1147          * Used to found the cmd by scst_find_cmd_by_tag(). Set by the
1148          * target driver on the cmd's initialization time
1149          */
1150         uint64_t tag;
1151
1152         uint32_t tgt_sn; /* SN set by target driver (for TM purposes) */
1153
1154         /* CDB and its len */
1155         uint8_t cdb[SCST_MAX_CDB_SIZE];
1156         int cdb_len;
1157
1158         enum scst_cdb_flags op_flags;
1159         const char *op_name;
1160
1161         enum scst_cmd_queue_type queue_type;
1162
1163         int timeout;    /* CDB execution timeout in seconds */
1164         int retries;    /* Amount of retries that will be done by SCSI mid-level */
1165
1166         /* SCSI data direction, one of SCST_DATA_* constants */
1167         scst_data_direction data_direction;
1168
1169         /* Remote initiator supplied values, if any */
1170         scst_data_direction expected_data_direction;
1171         int expected_transfer_len;
1172
1173         /*
1174          * Cmd data length. Could be different from bufflen for commands like
1175          * VERIFY, which transfer different amount of data (if any), than
1176          * processed.
1177          */
1178         int data_len;
1179
1180         /* Completition routine */
1181         void (*scst_cmd_done) (struct scst_cmd *cmd, int next_state);
1182
1183         struct sgv_pool_obj *sgv;       /* sgv object */
1184
1185         int bufflen;                    /* cmd buffer length */
1186         struct scatterlist *sg;         /* cmd data buffer SG vector */
1187         int sg_cnt;                     /* SG segments count */
1188
1189         /* scst_get_sg_buf_[first,next]() support */
1190         int get_sg_buf_entry_num;
1191
1192         /*
1193          * Response data length in data buffer. This field must not be set
1194          * directly, use scst_set_resp_data_len() for that
1195          */
1196         int resp_data_len;
1197
1198         uint8_t status;         /* status byte from target device */
1199         uint8_t msg_status;     /* return status from host adapter itself */
1200         uint8_t host_status;    /* set by low-level driver to indicate status */
1201         uint8_t driver_status;  /* set by mid-level */
1202
1203         uint8_t *sense;         /* pointer to sense buffer */
1204
1205         /* Used for storage of target driver private stuff */
1206         void *tgt_priv;
1207
1208         /* Used for storage of dev handler private stuff */
1209         void *dh_priv;
1210
1211         /*
1212          * Used to restore the SG vector if it was modified by
1213          * scst_set_resp_data_len()
1214          */
1215         int orig_sg_cnt, orig_sg_entry, orig_entry_len;
1216
1217         /* Used to retry commands in case of double UA */
1218         int dbl_ua_orig_resp_data_len, dbl_ua_orig_data_direction;
1219
1220         /* List corresponding mgmt cmd, if any, protected by sess_list_lock */
1221         struct list_head mgmt_cmd_list;
1222
1223         /* List entry for dev's blocked_cmd_list */
1224         struct list_head blocked_cmd_list_entry;
1225
1226         struct scst_cmd *orig_cmd; /* Used to issue REQUEST SENSE */
1227
1228 #ifdef MEASURE_LATENCY /* must be last */
1229         uint64_t start, pre_exec_finish, post_exec_start;
1230 #endif
1231 };
1232
1233 struct scst_rx_mgmt_params {
1234         int fn;
1235         uint64_t tag;
1236         const uint8_t *lun;
1237         int lun_len;
1238         uint32_t cmd_sn;
1239         int atomic;
1240         void *tgt_priv;
1241         unsigned char tag_set;
1242         unsigned char lun_set;
1243         unsigned char cmd_sn_set;
1244 };
1245
1246 struct scst_mgmt_cmd_stub {
1247         struct scst_mgmt_cmd *mcmd;
1248
1249         /* List entry in cmd->mgmt_cmd_list */
1250         struct list_head cmd_mgmt_cmd_list_entry;
1251 };
1252
1253 struct scst_mgmt_cmd {
1254         /* List entry for *_mgmt_cmd_list */
1255         struct list_head mgmt_cmd_list_entry;
1256
1257         struct scst_session *sess;
1258
1259         /* Mgmt cmd state, one of SCST_MGMT_CMD_STATE_* constants */
1260         int state;
1261
1262         int fn;
1263
1264         unsigned int completed:1;       /* set, if the mcmd is completed */
1265         /* Set if device(s) should be unblocked after mcmd's finish */
1266         unsigned int needs_unblocking:1;
1267         unsigned int lun_set:1;         /* set, if lun field is valid */
1268         unsigned int cmd_sn_set:1;      /* set, if cmd_sn field is valid */
1269         unsigned int nexus_loss_check_done:1; /* set, if nexus loss check is done */
1270
1271         /*
1272          * Number of commands to finish before sending response,
1273          * protected by scst_mcmd_lock
1274          */
1275         int cmd_finish_wait_count;
1276
1277         /*
1278          * Number of commands to complete (done) before resetting reservation,
1279          * protected by scst_mcmd_lock
1280          */
1281         int cmd_done_wait_count;
1282
1283         /* Number of completed commands, protected by scst_mcmd_lock */
1284         int completed_cmd_count;
1285
1286         lun_t lun;      /* LUN for this mgmt cmd */
1287         /* or (and for iSCSI) */
1288         uint64_t tag;   /* tag of the corresponding cmd */
1289
1290         uint32_t cmd_sn; /* affected command's highest SN */
1291
1292         /* corresponding cmd (to be aborted, found by tag) */
1293         struct scst_cmd *cmd_to_abort;
1294
1295         /* corresponding device for this mgmt cmd (found by lun) */
1296         struct scst_tgt_dev *mcmd_tgt_dev;
1297
1298         /* completition status, one of the SCST_MGMT_STATUS_* constants */
1299         int status;
1300
1301         /* Used for storage of target driver private stuff */
1302         void *tgt_priv;
1303 };
1304
1305 struct scst_device {
1306         struct scst_dev_type *handler;  /* corresponding dev handler */
1307
1308         /* Pointer to lists of commands with the lock */
1309         struct scst_cmd_lists *p_cmd_lists;
1310
1311         /* Lists of commands with lock, if dedicated threads are used */
1312         struct scst_cmd_lists cmd_lists;
1313
1314         /* How many cmds alive on this dev */
1315         atomic_t dev_cmd_count;
1316
1317         /* How many write cmds alive on this dev. Temporary, ToDo */
1318         atomic_t write_cmd_count;
1319
1320         unsigned short type;    /* SCSI type of the device */
1321
1322         /*************************************************************
1323          ** Dev's flags. Updates serialized by dev_lock or suspended
1324          ** activity
1325          *************************************************************/
1326
1327         /* Set if dev is RESERVED */
1328         unsigned short dev_reserved:1;
1329
1330         /* Set if dev accepts only one command at time  */
1331         unsigned short dev_serialized:1;
1332
1333         /* Set if double reset UA is possible */
1334         unsigned short dev_double_ua_possible:1;
1335
1336         /* Set if reset UA sent (to avoid double reset UAs) */
1337         unsigned short dev_reset_ua_sent:1;
1338
1339         /**************************************************************/
1340
1341         /*************************************************************
1342          ** Dev's control mode page related values. Updates serialized
1343          ** by scst_block_dev(). It's long to not interfere with the
1344          ** above flags.
1345          *************************************************************/
1346
1347         unsigned long queue_alg:4;
1348         unsigned long tst:3;
1349         unsigned long tas:1;
1350         unsigned long swp:1;
1351
1352         /*
1353          * Set if device implements own ordered commands management. If not set
1354          * and queue_alg is SCST_CONTR_MODE_QUEUE_ALG_RESTRICTED_REORDER,
1355          * expected_sn will be incremented only after commands finished.
1356          */
1357         unsigned long has_own_order_mgmt:1;
1358
1359         /**************************************************************/
1360
1361         spinlock_t dev_lock;            /* device lock */
1362
1363         /*
1364          * How many times device was blocked for new cmds execution.
1365          * Protected by dev_lock
1366          */
1367         int block_count;
1368
1369         /*
1370          * How many there are "on_dev" commands, i.e. ones those are being
1371          * executed by the underlying SCSI/virtual device.
1372          */
1373         atomic_t on_dev_count;
1374
1375         struct list_head blocked_cmd_list; /* protected by dev_lock */
1376
1377         /* Used for storage of dev handler private stuff */
1378         void *dh_priv;
1379
1380         /* Used to translate SCSI's cmd to SCST's cmd */
1381         struct gendisk *rq_disk;
1382
1383         /* Corresponding real SCSI device, could be NULL for virtual devices */
1384         struct scsi_device *scsi_dev;
1385
1386         /* Used to wait for requested amount of "on_dev" commands */
1387         wait_queue_head_t on_dev_waitQ;
1388
1389         /* A list entry used during TM, protected by scst_mutex */
1390         struct list_head tm_dev_list_entry;
1391
1392         /* Virtual device internal ID */
1393         int virt_id;
1394
1395         /* Pointer to virtual device name, for convenience only */
1396         const char *virt_name;
1397
1398         /* List entry in global devices list */
1399         struct list_head dev_list_entry;
1400
1401         /*
1402          * List of tgt_dev's, one per session, protected by scst_mutex or
1403          * dev_lock for reads and both for writes
1404          */
1405         struct list_head dev_tgt_dev_list;
1406
1407         /* List of acg_dev's, one per acg, protected by scst_mutex */
1408         struct list_head dev_acg_dev_list;
1409
1410         /* List of dedicated threads, protected by scst_mutex */
1411         struct list_head threads_list;
1412
1413         /* Device number */
1414         int dev_num;
1415 };
1416
1417 /*
1418  * Used to store threads local tgt_dev specific data
1419  */
1420 struct scst_thr_data_hdr {
1421         /* List entry in tgt_dev->thr_data_list */
1422         struct list_head thr_data_list_entry;
1423         pid_t pid; /* PID of the owner thread */
1424         atomic_t ref;
1425         /* Function that will be called on the tgt_dev destruction */
1426         void (*free_fn) (struct scst_thr_data_hdr *data);
1427 };
1428
1429 /*
1430  * Used to store per-session specific device information
1431  */
1432 struct scst_tgt_dev {
1433         /* List entry in sess->sess_tgt_dev_list_hash */
1434         struct list_head sess_tgt_dev_list_entry;
1435
1436         struct scst_device *dev; /* to save extra dereferences */
1437         lun_t lun;               /* to save extra dereferences */
1438
1439         /* How many cmds alive on this dev in this session */
1440         atomic_t tgt_dev_cmd_count;
1441
1442         int gfp_mask;
1443         struct sgv_pool *pool;
1444         int max_sg_cnt;
1445
1446         unsigned long tgt_dev_flags;    /* tgt_dev's async flags */
1447
1448         /*
1449          * Used to execute cmd's in order of arrival, honoring SCSI task
1450          * attributes.
1451          *
1452          * Protected by sn_lock, except expected_sn, which is protected by
1453          * itself. Curr_sn must have the same size as expected_sn to
1454          * overflow simultaneously.
1455          */
1456         int def_cmd_count;
1457         spinlock_t sn_lock;
1458         unsigned long expected_sn;
1459         unsigned long curr_sn;
1460         int hq_cmd_count;
1461         struct list_head deferred_cmd_list;
1462         struct list_head skipped_sn_list;
1463
1464         /*
1465          * Set if the prev cmd was ORDERED. Size must allow unprotected
1466          * modifications
1467          */
1468         unsigned long prev_cmd_ordered;
1469
1470         int num_free_sn_slots; /* if it's <0, then all slots are busy */
1471         atomic_t *cur_sn_slot;
1472         atomic_t sn_slots[15];
1473
1474         /* Used for storage of dev handler private stuff */
1475         void *dh_priv;
1476
1477         /* List of scst_thr_data_hdr and lock */
1478         spinlock_t thr_data_lock;
1479         struct list_head thr_data_list;
1480
1481         spinlock_t tgt_dev_lock;        /* per-session device lock */
1482
1483         /* List of UA's for this device, protected by tgt_dev_lock */
1484         struct list_head UA_list;
1485
1486         struct scst_session *sess;      /* corresponding session */
1487         struct scst_acg_dev *acg_dev;   /* corresponding acg_dev */
1488
1489         /* list entry in dev->dev_tgt_dev_list */
1490         struct list_head dev_tgt_dev_list_entry;
1491
1492         /* internal tmp list entry */
1493         struct list_head extra_tgt_dev_list_entry;
1494 };
1495
1496 /*
1497  * Used to store ACG-specific device information, like LUN
1498  */
1499 struct scst_acg_dev {
1500         struct scst_device *dev; /* corresponding device */
1501         lun_t lun;              /* device's LUN in this acg */
1502         unsigned int rd_only_flag:1; /* if != 0, then read only */
1503         struct scst_acg *acg;   /* parent acg */
1504
1505         /* list entry in dev->dev_acg_dev_list */
1506         struct list_head dev_acg_dev_list_entry;
1507
1508         /* list entry in acg->acg_dev_list */
1509         struct list_head acg_dev_list_entry;
1510 };
1511
1512 /*
1513  * ACG - access control group. Used to store group related
1514  * control information.
1515  */
1516 struct scst_acg {
1517         /* List of acg_dev's in this acg, protected by scst_mutex */
1518         struct list_head acg_dev_list;
1519
1520         /* List of attached sessions, protected by scst_mutex */
1521         struct list_head acg_sess_list;
1522
1523         /* List of attached acn's, protected by scst_mutex */
1524         struct list_head acn_list;
1525
1526         /* List entry in scst_acg_list */
1527         struct list_head scst_acg_list_entry;
1528
1529         /* Name of this acg */
1530         const char *acg_name;
1531
1532         /* The pointer to the /proc directory entry */
1533         struct proc_dir_entry *acg_proc_root;
1534 };
1535
1536 /*
1537  * ACN - access control name. Used to store names, by which
1538  * incoming sessions will be assigned to appropriate ACG.
1539  */
1540 struct scst_acn {
1541         /* Initiator's name */
1542         const char *name;
1543         /* List entry in acg->acn_list */
1544         struct list_head acn_list_entry;
1545 };
1546
1547 /*
1548  * Used to store per-session UNIT ATTENTIONs
1549  */
1550 struct scst_tgt_dev_UA {
1551         /* List entry in tgt_dev->UA_list */
1552         struct list_head UA_list_entry;
1553         /* Unit Attention sense */
1554         uint8_t UA_sense_buffer[SCST_SENSE_BUFFERSIZE];
1555 };
1556
1557 #ifndef smp_mb__after_set_bit
1558 /* There is no smp_mb__after_set_bit() in the kernel */
1559 #define smp_mb__after_set_bit()                 smp_mb()
1560 #endif
1561
1562 /*
1563  * Registers target template
1564  * Returns 0 on success or appropriate error code otherwise
1565  */
1566 int __scst_register_target_template(struct scst_tgt_template *vtt,
1567         const char *version);
1568 static inline int scst_register_target_template(struct scst_tgt_template *vtt)
1569 {
1570         return __scst_register_target_template(vtt, SCST_INTERFACE_VERSION);
1571 }
1572
1573 /*
1574  * Unregisters target template
1575  */
1576 void scst_unregister_target_template(struct scst_tgt_template *vtt);
1577
1578 /*
1579  * Registers and returns target adapter
1580  * Returns new target structure on success or NULL otherwise.
1581  *
1582  * If parameter "target_name" isn't NULL, then security group with name
1583  * "Default_##target_name", if created, will be used as the default
1584  * instead of "Default" one for all initiators not assigned to any other group.
1585  */
1586 struct scst_tgt *scst_register(struct scst_tgt_template *vtt,
1587         const char *target_name);
1588
1589 /*
1590  * Unregisters target adapter
1591  */
1592 void scst_unregister(struct scst_tgt *tgt);
1593
1594 /*
1595  * Registers and returns a session
1596  *
1597  * Returns new session on success or NULL otherwise
1598  *
1599  * Parameters:
1600  *   tgt    - target
1601  *   atomic - true, if the function called in the atomic context
1602  *   initiator_name - remote initiator's name, any NULL-terminated string,
1603  *      e.g. iSCSI name, which used as the key to found appropriate access
1604  *      control group. Could be NULL, then "default" group is used.
1605  *      The groups are set up via /proc interface.
1606  *   data - any target driver supplied data
1607  *   result_fn - pointer to the function that will be
1608  *      asynchronously called when session initialization finishes.
1609  *      Can be NULL. Parameters:
1610  *       - sess - session
1611  *       - data - target driver supplied to scst_register_session() data
1612  *       - result - session initialization result, 0 on success or
1613  *                  appropriate error code otherwise
1614  *
1615  * Note: A session creation and initialization is a complex task,
1616  *       which requires sleeping state, so it can't be fully done
1617  *       in interrupt context. Therefore the "bottom half" of it, if
1618  *       scst_register_session() is called from atomic context, will be
1619  *       done in SCST thread context. In this case scst_register_session()
1620  *       will return not completely initialized session, but the target
1621  *       driver can supply commands to this session via scst_rx_cmd().
1622  *       Those commands processing will be delayed inside SCST until
1623  *       the session initialization is finished, then their processing
1624  *       will be restarted. The target driver will be notified about
1625  *       finish of the session initialization by function result_fn().
1626  *       On success the target driver could do nothing, but if the
1627  *       initialization fails, the target driver must ensure that
1628  *       no more new commands being sent or will be sent to SCST after
1629  *       result_fn() returns. All already sent to SCST commands for
1630  *       failed session will be returned in xmit_response() with BUSY status.
1631  *       In case of failure the driver shall call scst_unregister_session()
1632  *       inside result_fn(), it will NOT be called automatically.
1633  */
1634 struct scst_session *scst_register_session(struct scst_tgt *tgt, int atomic,
1635         const char *initiator_name, void *data,
1636         void (*result_fn) (struct scst_session *sess, void *data, int result));
1637
1638 /*
1639  * Unregisters a session.
1640  * Parameters:
1641  *   sess - session to be unregistered
1642  *   wait - if true, instructs to wait until all commands, which
1643  *      currently is being executed and belonged to the session, finished.
1644  *      Otherwise, target driver should be prepared to receive
1645  *      xmit_response() for the session's command after
1646  *      scst_unregister_session() returns.
1647  *   unreg_done_fn - pointer to the function that will be
1648  *      asynchronously called when the last session's command finishes and
1649  *      the session is about to be completely freed. Can be NULL.
1650  *      Parameter:
1651  *       - sess - session
1652  *   unreg_cmds_done_fn - pointer to the function that will be
1653  *      asynchronously called when the last session's command completes, i.e.
1654  *      goes to XMIT stage. Can be NULL.
1655  *      Parameter:
1656  *       - sess - session
1657  *
1658  * Notes:
1659  *
1660  * - All outstanding commands will be finished regularly. After
1661  *   scst_unregister_session() returned no new commands must be sent to
1662  *   SCST via scst_rx_cmd().
1663  *
1664  * - The caller must ensure that no scst_rx_cmd() or scst_rx_mgmt_fn_*() is
1665  *   called in paralell with scst_unregister_session().
1666  *
1667  * - Can be called before result_fn() of scst_register_session() called,
1668  *   i.e. during the session registration/initialization.
1669  *
1670  * - It is highly recommended to call scst_unregister_session() as soon as it
1671  *   gets clear that session will be unregistered and not to wait until all
1672  *   related commands finished. This function provides the wait functionality,
1673  *   but it also starts recovering stuck commands, if there are any.
1674  *   Otherwise, your target driver could wait for those commands forever.
1675  */
1676 void scst_unregister_session_ex(struct scst_session *sess, int wait,
1677         void (*unreg_done_fn) (struct scst_session *sess),
1678         void (*unreg_cmds_done_fn) (struct scst_session *sess));
1679
1680 static inline void scst_unregister_session(struct scst_session *sess, int wait,
1681         void (*unreg_done_fn) (struct scst_session *sess))
1682 {
1683         scst_unregister_session_ex(sess, wait, unreg_done_fn, NULL);
1684 }
1685
1686 /*
1687  * Registers dev handler driver
1688  * Returns 0 on success or appropriate error code otherwise
1689  */
1690 int __scst_register_dev_driver(struct scst_dev_type *dev_type,
1691         const char *version);
1692 static inline int scst_register_dev_driver(struct scst_dev_type *dev_type)
1693 {
1694         return __scst_register_dev_driver(dev_type, SCST_INTERFACE_VERSION);
1695 }
1696
1697 /*
1698  * Unregisters dev handler driver
1699  */
1700 void scst_unregister_dev_driver(struct scst_dev_type *dev_type);
1701
1702 /*
1703  * Registers dev handler driver for virtual devices (eg VDISK)
1704  * Returns 0 on success or appropriate error code otherwise
1705  */
1706 int __scst_register_virtual_dev_driver(struct scst_dev_type *dev_type,
1707         const char *version);
1708 static inline int scst_register_virtual_dev_driver(
1709         struct scst_dev_type *dev_type)
1710 {
1711         return __scst_register_virtual_dev_driver(dev_type,
1712                 SCST_INTERFACE_VERSION);
1713 }
1714
1715 /*
1716  * Unregisters dev handler driver for virtual devices
1717  */
1718 void scst_unregister_virtual_dev_driver(struct scst_dev_type *dev_type);
1719
1720 /*
1721  * Creates and sends new command to SCST.
1722  * Must not be called in parallel with scst_unregister_session() for the
1723  * same sess. Returns the command on success or NULL otherwise
1724  */
1725 struct scst_cmd *scst_rx_cmd(struct scst_session *sess,
1726                              const uint8_t *lun, int lun_len,
1727                              const uint8_t *cdb, int cdb_len, int atomic);
1728
1729 /*
1730  * Notifies SCST that the driver finished its part of the command
1731  * initialization, and the command is ready for execution.
1732  * The second argument sets preferred command execition context.
1733  * See SCST_CONTEXT_* constants for details.
1734  *
1735  * !!IMPORTANT!!
1736  *
1737  * If cmd->set_sn_on_restart_cmd not set, this function, as well as
1738  * scst_cmd_init_stage1_done() and scst_restart_cmd(), must not be
1739  * called simultaneously for the same session (more precisely,
1740  * for the same session/LUN, i.e. tgt_dev), i.e. they must be
1741  * somehow externally serialized. This is needed to have lock free fast path in
1742  * scst_cmd_set_sn(). For majority of targets those functions are naturally
1743  * serialized by the single source of commands. Only iSCSI immediate commands
1744  * with multiple connections per session seems to be an exception. For it, some
1745  * mutex/lock shall be used for the serialization.
1746  */
1747 void scst_cmd_init_done(struct scst_cmd *cmd, int pref_context);
1748
1749 /*
1750  * Notifies SCST that the driver finished the first stage of the command
1751  * initialization, and the command is ready for execution, but after
1752  * SCST done the command's preprocessing preprocessing_done() function
1753  * should be called. The second argument sets preferred command execition
1754  * context. See SCST_CONTEXT_* constants for details.
1755  *
1756  * See also scst_cmd_init_done() comment for the serialization requirements.
1757  */
1758 static inline void scst_cmd_init_stage1_done(struct scst_cmd *cmd,
1759         int pref_context, int set_sn)
1760 {
1761         cmd->preprocessing_only = 1;
1762         cmd->set_sn_on_restart_cmd = !set_sn;
1763         scst_cmd_init_done(cmd, pref_context);
1764 }
1765
1766 /*
1767  * Notifies SCST that the driver finished its part of the command's
1768  * preprocessing and it is ready for further processing.
1769  * The second argument sets data receiving completion status
1770  * (see SCST_PREPROCESS_STATUS_* constants for details)
1771  * The third argument sets preferred command execition context
1772  * (see SCST_CONTEXT_* constants for details).
1773  *
1774  * See also scst_cmd_init_done() comment for the serialization requirements.
1775  */
1776 void scst_restart_cmd(struct scst_cmd *cmd, int status, int pref_context);
1777
1778 /*
1779  * Notifies SCST that the driver received all the necessary data
1780  * and the command is ready for further processing.
1781  * The second argument sets data receiving completion status
1782  * (see SCST_RX_STATUS_* constants for details)
1783  * The third argument sets preferred command execition context
1784  * (see SCST_CONTEXT_* constants for details)
1785  */
1786 void scst_rx_data(struct scst_cmd *cmd, int status, int pref_context);
1787
1788 /*
1789  * Notifies SCST that the driver sent the response and the command
1790  * can be freed now. Don't forget to set the delivery status, if it
1791  * isn't success, using scst_set_delivery_status() before calling
1792  * this function.
1793  */
1794 void scst_tgt_cmd_done(struct scst_cmd *cmd);
1795
1796 /*
1797  * Creates new management command sends it for execution.
1798  * Must not be called in parallel with scst_unregister_session() for the
1799  * same sess. Returns 0 for success, error code otherwise.
1800  */
1801 int scst_rx_mgmt_fn(struct scst_session *sess,
1802         const struct scst_rx_mgmt_params *params);
1803
1804 /*
1805  * Creates new management command using tag and sends it for execution.
1806  * Can be used for SCST_ABORT_TASK only.
1807  * Must not be called in parallel with scst_unregister_session() for the
1808  * same sess. Returns 0 for success, error code otherwise.
1809  *
1810  * Obsolete in favor of scst_rx_mgmt_fn()
1811  */
1812 static inline int scst_rx_mgmt_fn_tag(struct scst_session *sess, int fn,
1813         uint64_t tag, int atomic, void *tgt_priv)
1814 {
1815         struct scst_rx_mgmt_params params;
1816
1817         BUG_ON(fn != SCST_ABORT_TASK);
1818
1819         memset(&params, 0, sizeof(params));
1820         params.fn = fn;
1821         params.tag = tag;
1822         params.tag_set = 1;
1823         params.atomic = atomic;
1824         params.tgt_priv = tgt_priv;
1825         return scst_rx_mgmt_fn(sess, &params);
1826 }
1827
1828 /*
1829  * Creates new management command using LUN and sends it for execution.
1830  * Currently can be used for any fn, except SCST_ABORT_TASK.
1831  * Must not be called in parallel with scst_unregister_session() for the
1832  * same sess. Returns 0 for success, error code otherwise.
1833  *
1834  * Obsolete in favor of scst_rx_mgmt_fn()
1835  */
1836 static inline int scst_rx_mgmt_fn_lun(struct scst_session *sess, int fn,
1837         const uint8_t *lun, int lun_len, int atomic, void *tgt_priv)
1838 {
1839         struct scst_rx_mgmt_params params;
1840
1841         BUG_ON(fn == SCST_ABORT_TASK);
1842
1843         memset(&params, 0, sizeof(params));
1844         params.fn = fn;
1845         params.lun = lun;
1846         params.lun_len = lun_len;
1847         params.lun_set = 1;
1848         params.atomic = atomic;
1849         params.tgt_priv = tgt_priv;
1850         return scst_rx_mgmt_fn(sess, &params);
1851 }
1852
1853 /*
1854  * Provides various CDB info
1855  * Parameters:
1856  *   cdb_p - pointer to CDB
1857  *   dev_type - SCSI device type
1858  *   op_flags, direction, transfer_len, cdb_len, op_name - the result (output)
1859  * Returns: 0 on success, <0 if command is unknown, >0 if command is invalid.
1860  */
1861 int scst_get_cdb_info(struct scst_cmd *cmd);
1862
1863 /*
1864  * Set error SCSI status in the command and prepares it for returning it
1865  */
1866 void scst_set_cmd_error_status(struct scst_cmd *cmd, int status);
1867
1868 /*
1869  * Set error in the command and fill the sense buffer
1870  */
1871 void scst_set_cmd_error(struct scst_cmd *cmd, int key, int asc, int ascq);
1872
1873 /*
1874  * Sets BUSY or TASK QUEUE FULL status
1875  */
1876 void scst_set_busy(struct scst_cmd *cmd);
1877
1878 /*
1879  * Finds a command based on the supplied tag comparing it with one
1880  * that previously set by scst_cmd_set_tag().
1881  * Returns the command on success or NULL otherwise
1882  */
1883 struct scst_cmd *scst_find_cmd_by_tag(struct scst_session *sess, uint64_t tag);
1884
1885 /*
1886  * Finds a command based on user supplied data and comparision
1887  * callback function, that should return true, if the command is found.
1888  * Returns the command on success or NULL otherwise
1889  */
1890 struct scst_cmd *scst_find_cmd(struct scst_session *sess, void *data,
1891                                int (*cmp_fn) (struct scst_cmd *cmd,
1892                                               void *data));
1893
1894 /*
1895  * Translates SCST's data direction to DMA one
1896  */
1897 static inline int scst_to_dma_dir(int scst_dir)
1898 {
1899         return scst_dir;
1900 }
1901
1902 /*
1903  * Translates SCST data direction to DMA one from the perspective
1904  * of the target device.
1905  */
1906 static inline int scst_to_tgt_dma_dir(int scst_dir)
1907 {
1908         if (scst_dir == SCST_DATA_WRITE)
1909                 return DMA_FROM_DEVICE;
1910         else if (scst_dir == SCST_DATA_READ)
1911                 return DMA_TO_DEVICE;
1912         return scst_dir;
1913 }
1914
1915 /*
1916  * Returns 1, if cmd's CDB is locally handled by SCST and 0 otherwise.
1917  * Dev handlers parse() and dev_done() not called for such commands.
1918  */
1919 static inline int scst_is_cmd_local(struct scst_cmd *cmd)
1920 {
1921         int res = 0;
1922         switch (cmd->cdb[0]) {
1923         case REPORT_LUNS:
1924                 res = 1;
1925         }
1926         return res;
1927 }
1928
1929 /*
1930  * Registers a virtual device.
1931  * Parameters:
1932  *   dev_type - the device's device handler
1933  *   dev_name - the new device name, NULL-terminated string. Must be uniq
1934  *              among all virtual devices in the system. The value isn't
1935  *              copied, only the reference is stored, so the value must
1936  *              remain valid during the device lifetime.
1937  * Returns assinged to the device ID on success, or negative value otherwise
1938  */
1939 int scst_register_virtual_device(struct scst_dev_type *dev_handler,
1940         const char *dev_name);
1941
1942 /*
1943  * Unegisters a virtual device.
1944  * Parameters:
1945  *   id - the device's ID, returned by the registration function
1946  */
1947 void scst_unregister_virtual_device(int id);
1948
1949 /*
1950  * Get/Set functions for tgt's sg_tablesize
1951  */
1952 static inline int scst_tgt_get_sg_tablesize(struct scst_tgt *tgt)
1953 {
1954         return tgt->sg_tablesize;
1955 }
1956
1957 static inline void scst_tgt_set_sg_tablesize(struct scst_tgt *tgt, int val)
1958 {
1959         tgt->sg_tablesize = val;
1960 }
1961
1962 /*
1963  * Get/Set functions for tgt's target private data
1964  */
1965 static inline void *scst_tgt_get_tgt_priv(struct scst_tgt *tgt)
1966 {
1967         return tgt->tgt_priv;
1968 }
1969
1970 static inline void scst_tgt_set_tgt_priv(struct scst_tgt *tgt, void *val)
1971 {
1972         tgt->tgt_priv = val;
1973 }
1974
1975 /*
1976  * Get/Set functions for session's target private data
1977  */
1978 static inline void *scst_sess_get_tgt_priv(struct scst_session *sess)
1979 {
1980         return sess->tgt_priv;
1981 }
1982
1983 static inline void scst_sess_set_tgt_priv(struct scst_session *sess,
1984                                               void *val)
1985 {
1986         sess->tgt_priv = val;
1987 }
1988
1989 /* Returns TRUE if cmd is being executed in atomic context */
1990 static inline int scst_cmd_atomic(struct scst_cmd *cmd)
1991 {
1992         int res = cmd->atomic;
1993 #ifdef EXTRACHECKS
1994         if (unlikely(in_atomic() && !res)) {
1995                 printk(KERN_ERR "ERROR: in_atomic() and non-atomic cmd\n");
1996                 dump_stack();
1997                 cmd->atomic = 1;
1998                 res = 1;
1999         }
2000 #endif
2001         return res;
2002 }
2003
2004 /* Returns cmd's session */
2005 static inline struct scst_session *scst_cmd_get_session(struct scst_cmd *cmd)
2006 {
2007         return cmd->sess;
2008 }
2009
2010 /* Returns cmd's response data length */
2011 static inline int scst_cmd_get_resp_data_len(struct scst_cmd *cmd)
2012 {
2013         return cmd->resp_data_len;
2014 }
2015
2016 /*
2017  * Returns cmd's response flags (SCST_TSC_FLAG_* constants). Obsolete, use
2018  * scst_cmd_get_is_send_status() instead.
2019  */
2020 static inline __deprecated int scst_cmd_get_tgt_resp_flags(struct scst_cmd *cmd)
2021 {
2022         return cmd->is_send_status ? SCST_TSC_FLAG_STATUS : 0;
2023 }
2024
2025 /* Returns if status should be sent for cmd */
2026 static inline int scst_cmd_get_is_send_status(struct scst_cmd *cmd)
2027 {
2028         return cmd->is_send_status;
2029 }
2030
2031 /*
2032  * Returns pointer to cmd's SG data buffer.
2033  *
2034  * Usage of this function is not recommended, use scst_get_buf_*()
2035  * family of functions instead.
2036  */
2037 static inline struct scatterlist *scst_cmd_get_sg(struct scst_cmd *cmd)
2038 {
2039         return cmd->sg;
2040 }
2041
2042 /*
2043  * Returns cmd's data buffer length.
2044  *
2045  * In case if you need to iterate over data in the buffer, usage of
2046  * this function is not recommended, use scst_get_buf_*()
2047  * family of functions instead.
2048  */
2049 static inline unsigned int scst_cmd_get_bufflen(struct scst_cmd *cmd)
2050 {
2051         return cmd->bufflen;
2052 }
2053
2054 /*
2055  * Returns cmd's sg_cnt.
2056  *
2057  * Usage of this function is not recommended, use scst_get_buf_*()
2058  * family of functions instead.
2059  */
2060 static inline unsigned short scst_cmd_get_sg_cnt(struct scst_cmd *cmd)
2061 {
2062         return cmd->sg_cnt;
2063 }
2064
2065 /* Returns cmd's data direction */
2066 static inline scst_data_direction scst_cmd_get_data_direction(
2067         struct scst_cmd *cmd)
2068 {
2069         return cmd->data_direction;
2070 }
2071
2072 /* Returns cmd's status byte from host device */
2073 static inline uint8_t scst_cmd_get_status(struct scst_cmd *cmd)
2074 {
2075         return cmd->status;
2076 }
2077
2078 /* Returns cmd's status from host adapter itself */
2079 static inline uint8_t scst_cmd_get_msg_status(struct scst_cmd *cmd)
2080 {
2081         return cmd->msg_status;
2082 }
2083
2084 /* Returns cmd's status set by low-level driver to indicate its status */
2085 static inline uint8_t scst_cmd_get_host_status(struct scst_cmd *cmd)
2086 {
2087         return cmd->host_status;
2088 }
2089
2090 /* Returns cmd's status set by SCSI mid-level */
2091 static inline uint8_t scst_cmd_get_driver_status(struct scst_cmd *cmd)
2092 {
2093         return cmd->driver_status;
2094 }
2095
2096 /* Returns pointer to cmd's sense buffer */
2097 static inline uint8_t *scst_cmd_get_sense_buffer(struct scst_cmd *cmd)
2098 {
2099         return cmd->sense;
2100 }
2101
2102 /* Returns cmd's sense buffer length */
2103 static inline int scst_cmd_get_sense_buffer_len(struct scst_cmd *cmd)
2104 {
2105         return SCST_SENSE_BUFFERSIZE;
2106 }
2107
2108 /*
2109  * Get/Set functions for cmd's target SN
2110  */
2111 static inline uint64_t scst_cmd_get_tag(struct scst_cmd *cmd)
2112 {
2113         return cmd->tag;
2114 }
2115
2116 static inline void scst_cmd_set_tag(struct scst_cmd *cmd, uint64_t tag)
2117 {
2118         cmd->tag = tag;
2119 }
2120
2121 /*
2122  * Get/Set functions for cmd's target private data.
2123  * Variant with *_lock must be used if target driver uses
2124  * scst_find_cmd() to avoid race with it, except inside scst_find_cmd()'s
2125  * callback, where lock is already taken.
2126  */
2127 static inline void *scst_cmd_get_tgt_priv(struct scst_cmd *cmd)
2128 {
2129         return cmd->tgt_priv;
2130 }
2131
2132 static inline void scst_cmd_set_tgt_priv(struct scst_cmd *cmd, void *val)
2133 {
2134         cmd->tgt_priv = val;
2135 }
2136
2137 void *scst_cmd_get_tgt_priv_lock(struct scst_cmd *cmd);
2138 void scst_cmd_set_tgt_priv_lock(struct scst_cmd *cmd, void *val);
2139
2140 /*
2141  * Get/Set functions for data_buf_tgt_alloc flag
2142  */
2143 static inline int scst_cmd_get_data_buf_tgt_alloc(struct scst_cmd *cmd)
2144 {
2145         return cmd->data_buf_tgt_alloc;
2146 }
2147
2148 static inline void scst_cmd_set_data_buf_tgt_alloc(struct scst_cmd *cmd)
2149 {
2150         cmd->data_buf_tgt_alloc = 1;
2151 }
2152
2153 /*
2154  * Get/Set functions for data_buf_alloced flag
2155  */
2156 static inline int scst_cmd_get_data_buff_alloced(struct scst_cmd *cmd)
2157 {
2158         return cmd->data_buf_alloced;
2159 }
2160
2161 static inline void scst_cmd_set_data_buff_alloced(struct scst_cmd *cmd)
2162 {
2163         cmd->data_buf_alloced = 1;
2164 }
2165
2166 /*
2167  * Get/Set functions for no_sgv flag
2168  */
2169 static inline int scst_cmd_get_no_sgv(struct scst_cmd *cmd)
2170 {
2171         return cmd->no_sgv;
2172 }
2173
2174 static inline void scst_cmd_set_no_sgv(struct scst_cmd *cmd)
2175 {
2176         cmd->no_sgv = 1;
2177 }
2178
2179 /*
2180  * Get/Set functions for tgt_sn
2181  */
2182 static inline int scst_cmd_get_tgt_sn(struct scst_cmd *cmd)
2183 {
2184         BUG_ON(!cmd->tgt_sn_set);
2185         return cmd->tgt_sn;
2186 }
2187
2188 static inline void scst_cmd_set_tgt_sn(struct scst_cmd *cmd, uint32_t tgt_sn)
2189 {
2190         cmd->tgt_sn_set = 1;
2191         cmd->tgt_sn = tgt_sn;
2192 }
2193
2194 /*
2195  * Returns 1 if the cmd was aborted, so its status is invalid and no
2196  * reply shall be sent to the remote initiator. A target driver should
2197  * only clear internal resources, associated with cmd.
2198  */
2199 static inline int scst_cmd_aborted(struct scst_cmd *cmd)
2200 {
2201         return test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags) &&
2202                 !test_bit(SCST_CMD_ABORTED_OTHER, &cmd->cmd_flags);
2203 }
2204
2205 /*
2206  * Get/Set functions for expected data direction, transfer length
2207  * and its validity flag
2208  */
2209 static inline int scst_cmd_is_expected_set(struct scst_cmd *cmd)
2210 {
2211         return cmd->expected_values_set;
2212 }
2213
2214 static inline scst_data_direction scst_cmd_get_expected_data_direction(
2215         struct scst_cmd *cmd)
2216 {
2217         return cmd->expected_data_direction;
2218 }
2219
2220 static inline int scst_cmd_get_expected_transfer_len(
2221         struct scst_cmd *cmd)
2222 {
2223         return cmd->expected_transfer_len;
2224 }
2225
2226 static inline void scst_cmd_set_expected(struct scst_cmd *cmd,
2227         scst_data_direction expected_data_direction,
2228         int expected_transfer_len)
2229 {
2230         cmd->expected_data_direction = expected_data_direction;
2231         cmd->expected_transfer_len = expected_transfer_len;
2232         cmd->expected_values_set = 1;
2233 }
2234
2235 /*
2236  * Get/clear functions for cmd's may_need_dma_sync
2237  */
2238 static inline int scst_get_may_need_dma_sync(struct scst_cmd *cmd)
2239 {
2240         return cmd->may_need_dma_sync;
2241 }
2242
2243 static inline void scst_clear_may_need_dma_sync(struct scst_cmd *cmd)
2244 {
2245         cmd->may_need_dma_sync = 0;
2246 }
2247
2248 /*
2249  * Get/clear functions for cmd's delivery_status. It is one of
2250  * SCST_CMD_DELIVERY_* constants, it specifies the status of the
2251  * command's delivery to initiator.
2252  */
2253 static inline int scst_get_delivery_status(struct scst_cmd *cmd)
2254 {
2255         return cmd->delivery_status;
2256 }
2257
2258 static inline void scst_set_delivery_status(struct scst_cmd *cmd,
2259         int delivery_status)
2260 {
2261         cmd->delivery_status = delivery_status;
2262 }
2263
2264 /*
2265  * Get/set/clear functions for cmd's long XMIT flag.
2266  */
2267 static inline int scst_get_long_xmit(struct scst_cmd *cmd)
2268 {
2269         return cmd->long_xmit;
2270 }
2271
2272 static inline void scst_set_long_xmit(struct scst_cmd *cmd)
2273 {
2274         cmd->long_xmit = 1;
2275 }
2276
2277 static inline void scst_clear_long_xmit(struct scst_cmd *cmd)
2278 {
2279         cmd->long_xmit = 0;
2280 }
2281
2282 /*
2283  * Get/Set function for mgmt cmd's target private data
2284  */
2285 static inline void *scst_mgmt_cmd_get_tgt_priv(struct scst_mgmt_cmd *mcmd)
2286 {
2287         return mcmd->tgt_priv;
2288 }
2289
2290 static inline void scst_mgmt_cmd_set_tgt_priv(struct scst_mgmt_cmd *mcmd,
2291         void *val)
2292 {
2293         mcmd->tgt_priv = val;
2294 }
2295
2296 /* Returns mgmt cmd's completition status (SCST_MGMT_STATUS_* constants) */
2297 static inline int scst_mgmt_cmd_get_status(struct scst_mgmt_cmd *mcmd)
2298 {
2299         return mcmd->status;
2300 }
2301
2302 /* Returns mgmt cmd's TM fn */
2303 static inline int scst_mgmt_cmd_get_fn(struct scst_mgmt_cmd *mcmd)
2304 {
2305         return mcmd->fn;
2306 }
2307
2308 /*
2309  * Called by dev handler's task_mgmt_fn() to notify SCST core that mcmd
2310  * is going to complete asynchronously.
2311  */
2312 void scst_prepare_async_mcmd(struct scst_mgmt_cmd *mcmd);
2313
2314 /*
2315  * Called by dev handler to notify SCST core that async. mcmd is completed
2316  * with status "status".
2317  */
2318 void scst_async_mcmd_completed(struct scst_mgmt_cmd *mcmd, int status);
2319
2320 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
2321
2322 static inline struct page *sg_page(struct scatterlist *sg)
2323 {
2324         return sg->page;
2325 }
2326
2327 static inline void *sg_virt(struct scatterlist *sg)
2328 {
2329         return page_address(sg_page(sg)) + sg->offset;
2330 }
2331
2332 static inline void sg_init_table(struct scatterlist *sgl, unsigned int nents)
2333 {
2334         memset(sgl, 0, sizeof(*sgl) * nents);
2335 }
2336
2337 static inline void sg_assign_page(struct scatterlist *sg, struct page *page)
2338 {
2339         sg->page = page;
2340 }
2341
2342 static inline void sg_set_page(struct scatterlist *sg, struct page *page,
2343                                unsigned int len, unsigned int offset)
2344 {
2345         sg_assign_page(sg, page);
2346         sg->offset = offset;
2347         sg->length = len;
2348 }
2349
2350 #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24) */
2351
2352 static inline void sg_clear(struct scatterlist *sg)
2353 {
2354         memset(sg, 0, sizeof(*sg));
2355 #ifdef CONFIG_DEBUG_SG
2356         sg->sg_magic = SG_MAGIC;
2357 #endif
2358 }
2359
2360 /*
2361  * Functions for access to the commands data (SG) buffer,
2362  * including HIGHMEM environment. Should be used instead of direct
2363  * access. Returns the mapped buffer length for success, 0 for EOD,
2364  * negative error code otherwise.
2365  *
2366  * "Buf" argument returns the mapped buffer
2367  *
2368  * The "put" function unmaps the buffer.
2369  */
2370 static inline int __scst_get_buf(struct scst_cmd *cmd, uint8_t **buf)
2371 {
2372         int res = 0;
2373         struct scatterlist *sg = cmd->sg;
2374         int i = cmd->get_sg_buf_entry_num;
2375
2376         *buf = NULL;
2377
2378         if ((i >= cmd->sg_cnt) || unlikely(sg == NULL))
2379                 goto out;
2380 #ifdef SCST_HIGHMEM /* HIGHMEM isn't currently supported */
2381         /*
2382          * HIGHMEM pages not merged (clustered), so if it's
2383          * not HIGHMEM page, kmap() is the same as page_address()
2384          */
2385         if (scst_cmd_atomic(cmd)) {
2386                 enum km_type km;
2387                 if (in_softirq())
2388                         km = KM_SOFTIRQ0;
2389                 else
2390                         km = KM_USER0;
2391                 *buf = kmap_atomic(sg[i].page, km);
2392         } else
2393                 *buf = kmap(sg[i].page);
2394 #else
2395         *buf = page_address(sg_page(&sg[i]));
2396 #endif
2397         *buf += sg[i].offset;
2398         res = sg[i].length;
2399         cmd->get_sg_buf_entry_num++;
2400
2401 out:
2402         return res;
2403 }
2404
2405 static inline int scst_get_buf_first(struct scst_cmd *cmd, uint8_t **buf)
2406 {
2407         cmd->get_sg_buf_entry_num = 0;
2408         cmd->may_need_dma_sync = 1;
2409         return __scst_get_buf(cmd, buf);
2410 }
2411
2412 static inline int scst_get_buf_next(struct scst_cmd *cmd, uint8_t **buf)
2413 {
2414         return __scst_get_buf(cmd, buf);
2415 }
2416
2417 static inline void scst_put_buf(struct scst_cmd *cmd, void *buf)
2418 {
2419 #ifdef SCST_HIGHMEM /* HIGHMEM isn't currently supported */
2420         if (cmd->sg_cnt) {
2421                 if (scst_cmd_atomic(cmd)) {
2422                         enum km_type km;
2423                         BUG_ON(in_irq());
2424                         if (in_softirq())
2425                                 km = KM_SOFTIRQ0;
2426                         else
2427                                 km = KM_USER0;
2428                         kunmap_atomic(buf, km);
2429                 } else
2430                         kunmap(buf);
2431         }
2432 #endif
2433 }
2434
2435 /*
2436  * Returns approximate higher rounded buffers count that
2437  * scst_get_buf_[first|next]() return.
2438  */
2439 static inline int scst_get_buf_count(struct scst_cmd *cmd)
2440 {
2441         int res;
2442 #ifdef SCST_HIGHMEM
2443         res = (cmd->bufflen >> PAGE_SHIFT) + 1;
2444 #else
2445         res = (cmd->sg_cnt == 0) ? 1 : cmd->sg_cnt;
2446 #endif
2447         return res;
2448 }
2449
2450 /*
2451  * Suspends and resumes any activity.
2452  * Function scst_suspend_activity() doesn't return 0, until there are any
2453  * active commands (state after SCST_CMD_STATE_INIT). If "interruptible"
2454  * is true, it returns after SCST_SUSPENDING_TIMEOUT or if it was interrupted
2455  * by a signal with the coresponding error status < 0. If "interruptible"
2456  * is false, it will wait virtually forever.
2457  *
2458  * New arriving commands stay in that state until scst_resume_activity()
2459  * is called.
2460  */
2461 int scst_suspend_activity(bool interruptible);
2462 void scst_resume_activity(void);
2463
2464 /*
2465  * Main SCST commands processing routing. Must be used only by dev handlers.
2466  * Argument context sets the execution context, only SCST_CONTEXT_DIRECT and
2467  * SCST_CONTEXT_DIRECT_ATOMIC with optional SCST_CONTEXT_PROCESSABLE flag
2468  * are allowed.
2469  */
2470 void scst_process_active_cmd(struct scst_cmd *cmd, int context);
2471
2472 /*
2473  * Checks if command can be executed (reservations, etc.) or there are local
2474  * events, like pending UAs. Returns < 0 if command must be aborted, > 0 if
2475  * there is an event and command should be immediately completed, or 0
2476  * otherwise.
2477  *
2478  * !! Dev handlers implementing exec() callback must call this function there !!
2479  * !! just before the actual command's execution                              !!
2480  */
2481 int scst_check_local_events(struct scst_cmd *cmd);
2482
2483 /*
2484  * Returns target driver's root entry in SCST's /proc hierarchy.
2485  * The driver can create own files/directoryes here, which should
2486  * be deleted in the driver's release().
2487  */
2488 static inline struct proc_dir_entry *scst_proc_get_tgt_root(
2489         struct scst_tgt_template *vtt)
2490 {
2491         return vtt->proc_tgt_root;
2492 }
2493
2494 /*
2495  * Returns device handler's root entry in SCST's /proc hierarchy.
2496  * The driver can create own files/directoryes here, which should
2497  * be deleted in the driver's detach()/release().
2498  */
2499 static inline struct proc_dir_entry *scst_proc_get_dev_type_root(
2500         struct scst_dev_type *dtt)
2501 {
2502         return dtt->proc_dev_type_root;
2503 }
2504
2505 /**
2506  ** Two library functions and the structure to help the drivers
2507  ** that use scst_debug.* facilities manage "trace_level" /proc entry.
2508  ** The functions service "standard" log levels and allow to work
2509  ** with driver specific levels, which should be passed inside as
2510  ** NULL-terminated array of struct scst_proc_log's, where:
2511  **   - val - the level's numeric value
2512  **   - token - its string representation
2513  **/
2514
2515 struct scst_proc_log {
2516         unsigned int val;
2517         const char *token;
2518 };
2519
2520 int scst_proc_log_entry_read(struct seq_file *seq, unsigned long log_level,
2521         const struct scst_proc_log *tbl);
2522
2523 int scst_proc_log_entry_write(struct file *file, const char *buf,
2524         unsigned long length, unsigned long *log_level,
2525         unsigned long default_level, const struct scst_proc_log *tbl);
2526
2527 /*
2528  * helper data structure and function to create proc entry.
2529  */
2530 struct scst_proc_data {
2531         struct file_operations seq_op;
2532         int (*show)(struct seq_file *, void *);
2533         void *data;
2534 };
2535
2536 int scst_single_seq_open(struct inode *inode, struct file *file);
2537
2538 struct proc_dir_entry *scst_create_proc_entry(struct proc_dir_entry *root,
2539         const char *name, struct scst_proc_data *pdata);
2540
2541 #define SCST_DEF_RW_SEQ_OP(x)                          \
2542         .seq_op = {                                    \
2543                 .owner          = THIS_MODULE,         \
2544                 .open           = scst_single_seq_open,\
2545                 .read           = seq_read,            \
2546                 .write          = x,                   \
2547                 .llseek         = seq_lseek,           \
2548                 .release        = single_release,      \
2549         },
2550
2551 /*
2552  * Adds and deletes (stops) num SCST's threads. Returns 0 on success,
2553  * error code otherwise.
2554  */
2555 int scst_add_cmd_threads(int num);
2556 void scst_del_cmd_threads(int num);
2557
2558 int scst_alloc_sense(struct scst_cmd *cmd, int atomic);
2559 int scst_alloc_set_sense(struct scst_cmd *cmd, int atomic,
2560         const uint8_t *sense, unsigned int len);
2561
2562 void scst_set_sense(uint8_t *buffer, int len, int key,
2563         int asc, int ascq);
2564
2565 void scst_set_cmd_error_sense(struct scst_cmd *cmd, uint8_t *sense,
2566         unsigned int len);
2567
2568 /*
2569  * Returnes a pseudo-random number for debugging purposes. Available only with
2570  * DEBUG on
2571  */
2572 unsigned long scst_random(void);
2573
2574 /*
2575  * Sets response data length for cmd and truncates its SG vector accordingly.
2576  * The cmd->resp_data_len must not be set directly, it must be set only
2577  * using this function. Value of resp_data_len must be <= cmd->bufflen.
2578  */
2579 void scst_set_resp_data_len(struct scst_cmd *cmd, int resp_data_len);
2580
2581 /*
2582  * Checks if total memory allocated by commands is less, than defined
2583  * limit (scst_cur_max_cmd_mem) and returns 0, if it is so. Otherwise,
2584  * returnes 1 and sets on cmd QUEUE FULL or BUSY status as well as
2585  * SCST_CMD_STATE_PRE_XMIT_RESP state. Target drivers and dev handlers are
2586  * required to call this function if they allocate data buffers on their
2587  * own.
2588  */
2589 int scst_check_mem(struct scst_cmd *cmd);
2590
2591 /*
2592  * Get/put global ref counter that prevents from entering into suspended
2593  * activities stage, so protects from any global management operations.
2594  */
2595 void scst_get(void);
2596 void scst_put(void);
2597
2598 /*
2599  * Cmd ref counters
2600  */
2601 void scst_cmd_get(struct scst_cmd *cmd);
2602 void scst_cmd_put(struct scst_cmd *cmd);
2603
2604 /*
2605  * Allocates and returns pointer to SG vector with data size "size".
2606  * In *count returned the count of entries in the vector.
2607  * Returns NULL for failure.
2608  */
2609 struct scatterlist *scst_alloc(int size, unsigned long gfp_mask, int *count);
2610
2611 /* Frees SG vector returned by scst_alloc() */
2612 void scst_free(struct scatterlist *sg, int count);
2613
2614 /*
2615  * Adds local to the current thread data to tgt_dev
2616  * (they will be local for the tgt_dev and current thread).
2617  */
2618 void scst_add_thr_data(struct scst_tgt_dev *tgt_dev,
2619         struct scst_thr_data_hdr *data,
2620         void (*free_fn) (struct scst_thr_data_hdr *data));
2621
2622 /* Deletes all local to threads data from tgt_dev */
2623 void scst_del_all_thr_data(struct scst_tgt_dev *tgt_dev);
2624
2625 /* Deletes all local to threads data from all tgt_dev's of the dev */
2626 void scst_dev_del_all_thr_data(struct scst_device *dev);
2627
2628 /* Finds local to the current thread data. Returns NULL, if they not found. */
2629 struct scst_thr_data_hdr *scst_find_thr_data(struct scst_tgt_dev *tgt_dev);
2630
2631 static inline void scst_thr_data_get(struct scst_thr_data_hdr *data)
2632 {
2633         atomic_inc(&data->ref);
2634 }
2635
2636 static inline void scst_thr_data_put(struct scst_thr_data_hdr *data)
2637 {
2638         if (atomic_dec_and_test(&data->ref))
2639                 data->free_fn(data);
2640 }
2641
2642 /* SGV pool routines and flag bits */
2643
2644 /* Set if the allocated object must be not from the cache */
2645 #define SCST_POOL_ALLOC_NO_CACHED               1
2646
2647 /* Set if there should not be any memory allocations on a cache miss */
2648 #define SCST_POOL_NO_ALLOC_ON_CACHE_MISS        2
2649
2650 /* Set an object should be returned even if it doesn't have SG vector built */
2651 #define SCST_POOL_RETURN_OBJ_ON_ALLOC_FAIL      4
2652
2653 struct sgv_pool_obj;
2654 struct sgv_pool;
2655
2656 struct sgv_pool *sgv_pool_create(const char *name, int clustered);
2657 void sgv_pool_destroy(struct sgv_pool *pool);
2658
2659 void sgv_pool_set_allocator(struct sgv_pool *pool,
2660         struct page *(*alloc_pages_fn)(struct scatterlist *, gfp_t, void *),
2661         void (*free_pages_fn)(struct scatterlist *, int, void *));
2662
2663 struct scatterlist *sgv_pool_alloc(struct sgv_pool *pool, unsigned int size,
2664         unsigned long gfp_mask, int atomic, int *count,
2665         struct sgv_pool_obj **sgv, void *priv);
2666 void sgv_pool_free(struct sgv_pool_obj *sgv);
2667
2668 void *sgv_get_priv(struct sgv_pool_obj *sgv);
2669
2670 /**
2671  ** Generic parse() support routines.
2672  ** Done via pointer on functions to avoid unneeded dereferences on
2673  ** the fast path.
2674  **/
2675
2676 /* Calculates and returns block shift for the given sector size */
2677 int scst_calc_block_shift(int sector_size);
2678
2679 /* Generic parse() for SBC (disk) devices */
2680 int scst_sbc_generic_parse(struct scst_cmd *cmd,
2681         int (*get_block_shift)(struct scst_cmd *cmd));
2682
2683 /* Generic parse() for MMC (cdrom) devices */
2684 int scst_cdrom_generic_parse(struct scst_cmd *cmd,
2685         int (*get_block_shift)(struct scst_cmd *cmd));
2686
2687 /* Generic parse() for MO disk devices */
2688 int scst_modisk_generic_parse(struct scst_cmd *cmd,
2689         int (*get_block_shift)(struct scst_cmd *cmd));
2690
2691 /* Generic parse() for tape devices */
2692 int scst_tape_generic_parse(struct scst_cmd *cmd,
2693         int (*get_block_size)(struct scst_cmd *cmd));
2694
2695 /* Generic parse() for changer devices */
2696 int scst_changer_generic_parse(struct scst_cmd *cmd,
2697         int (*nothing)(struct scst_cmd *cmd));
2698
2699 /* Generic parse() for "processor" devices */
2700 int scst_processor_generic_parse(struct scst_cmd *cmd,
2701         int (*nothing)(struct scst_cmd *cmd));
2702
2703 /* Generic parse() for RAID devices */
2704 int scst_raid_generic_parse(struct scst_cmd *cmd,
2705         int (*nothing)(struct scst_cmd *cmd));
2706
2707 /**
2708  ** Generic dev_done() support routines.
2709  ** Done via pointer on functions to avoid unneeded dereferences on
2710  ** the fast path.
2711  **/
2712
2713 /* Generic dev_done() for block devices */
2714 int scst_block_generic_dev_done(struct scst_cmd *cmd,
2715         void (*set_block_shift)(struct scst_cmd *cmd, int block_shift));
2716
2717 /* Generic dev_done() for tape devices */
2718 int scst_tape_generic_dev_done(struct scst_cmd *cmd,
2719         void (*set_block_size)(struct scst_cmd *cmd, int block_size));
2720
2721 /*
2722  * Issues a MODE SENSE for control mode page data and sets the corresponding
2723  * dev's parameter from it. Returns 0 on success and not 0 otherwise.
2724  */
2725 int scst_obtain_device_parameters(struct scst_device *dev);
2726
2727 #endif /* __SCST_H */