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