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