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