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