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