7917c8d79d4712ad44fb1758636beca9ea3e113d
[mirror/scst/.git] / scst / include / scst.h
1 /*
2  *  include/scst.h
3  *
4  *  Copyright (C) 2004 - 2009 Vladislav Bolkhovitin <vst@vlnb.net>
5  *  Copyright (C) 2004 - 2005 Leonid Stoljar
6  *  Copyright (C) 2007 - 2009 ID7 Ltd.
7  *
8  *  Main SCSI target mid-level include file.
9  *
10  *  This program is free software; you can redistribute it and/or
11  *  modify it under the terms of the GNU General Public License
12  *  as published by the Free Software Foundation, version 2
13  *  of the License.
14  *
15  *  This program is distributed in the hope that it will be useful,
16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  *  GNU General Public License for more details.
19  */
20
21 #ifndef __SCST_H
22 #define __SCST_H
23
24 #include <linux/types.h>
25 #include <linux/version.h>
26 #include <linux/blkdev.h>
27 #include <linux/interrupt.h>
28 #include <linux/wait.h>
29
30 #define CONFIG_SCST_PROC
31
32 #ifdef CONFIG_SCST_PROC
33 #include <linux/proc_fs.h>
34 #include <linux/seq_file.h>
35 #endif
36
37 #include <scsi/scsi_cmnd.h>
38 #include <scsi/scsi_device.h>
39 #include <scsi/scsi_eh.h>
40 #include <scsi/scsi.h>
41
42 #include <scst_const.h>
43
44 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
45 #ifndef RHEL_RELEASE_CODE
46 typedef _Bool bool;
47 #endif
48 #define true  1
49 #define false 0
50 #endif
51
52 #include "scst_sgv.h"
53
54 /*
55  * Version numbers, the same as for the kernel.
56  *
57  * Changing it don't forget to change SCST_FIO_REV in scst_vdisk.c
58  * and FIO_REV in usr/fileio/common.h as well.
59  */
60 #define SCST_VERSION(a, b, c, d)    (((a) << 24) + ((b) << 16) + ((c) << 8) + d)
61 #define SCST_VERSION_CODE           SCST_VERSION(2, 0, 0, 0)
62 #ifdef CONFIG_SCST_PROC
63 #define SCST_VERSION_STRING_SUFFIX  "-procfs"
64 #else
65 #define SCST_VERSION_STRING_SUFFIX
66 #endif
67 #define SCST_VERSION_STRING         "2.0.0-pre1" SCST_VERSION_STRING_SUFFIX
68 #define SCST_INTERFACE_VERSION      \
69                 SCST_VERSION_STRING "$Revision$" SCST_CONST_VERSION
70
71
72 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18))
73 #define COMPLETION_INITIALIZER_ONSTACK(work) \
74         ({ init_completion(&work); work; })
75
76 /*
77  * Lockdep needs to run a non-constant initializer for on-stack
78  * completions - so we use the _ONSTACK() variant for those that
79  * are on the kernel stack:
80  */
81 #ifdef CONFIG_LOCKDEP
82 # define DECLARE_COMPLETION_ONSTACK(work) \
83         struct completion work = COMPLETION_INITIALIZER_ONSTACK(work)
84 #else
85 # define DECLARE_COMPLETION_ONSTACK(work) DECLARE_COMPLETION(work)
86 #endif
87
88 /**
89  * list_is_last - tests whether @list is the last entry in list @head
90  * @list: the entry to test
91  * @head: the head of the list
92  */
93 static inline int list_is_last(const struct list_head *list,
94                                 const struct list_head *head)
95 {
96         return list->next == head;
97 }
98
99 #endif
100
101 #define SCST_LOCAL_NAME                 "scst_lcl_drvr"
102
103 /*************************************************************
104  ** States of command processing state machine. At first,
105  ** "active" states, then - "passive" ones. This is to have
106  ** more efficient generated code of the corresponding
107  ** "switch" statements.
108  *************************************************************/
109
110 /* Internal parsing */
111 #define SCST_CMD_STATE_PRE_PARSE     0
112
113 /* Dev handler's parse() is going to be called */
114 #define SCST_CMD_STATE_DEV_PARSE     1
115
116 /* Allocation of the cmd's data buffer */
117 #define SCST_CMD_STATE_PREPARE_SPACE 2
118
119 /* Target driver's rdy_to_xfer() is going to be called */
120 #define SCST_CMD_STATE_RDY_TO_XFER   3
121
122 /* Target driver's pre_exec() is going to be called */
123 #define SCST_CMD_STATE_TGT_PRE_EXEC  4
124
125 /* Cmd is going to be sent for execution */
126 #define SCST_CMD_STATE_SEND_FOR_EXEC 5
127
128 /* Cmd is being checked if it should be executed locally */
129 #define SCST_CMD_STATE_LOCAL_EXEC    6
130
131 /* Cmd is ready for execution */
132 #define SCST_CMD_STATE_REAL_EXEC     7
133
134 /* Internal post-exec checks */
135 #define SCST_CMD_STATE_PRE_DEV_DONE  8
136
137 /* Internal MODE SELECT pages related checks */
138 #define SCST_CMD_STATE_MODE_SELECT_CHECKS 9
139
140 /* Dev handler's dev_done() is going to be called */
141 #define SCST_CMD_STATE_DEV_DONE      10
142
143 /* Target driver's xmit_response() is going to be called */
144 #define SCST_CMD_STATE_PRE_XMIT_RESP 11
145
146 /* Target driver's xmit_response() is going to be called */
147 #define SCST_CMD_STATE_XMIT_RESP     12
148
149 /* Cmd finished */
150 #define SCST_CMD_STATE_FINISHED      13
151
152 /* Internal cmd finished */
153 #define SCST_CMD_STATE_FINISHED_INTERNAL 14
154
155 #define SCST_CMD_STATE_LAST_ACTIVE   (SCST_CMD_STATE_FINISHED_INTERNAL+100)
156
157 /* A cmd is created, but scst_cmd_init_done() not called */
158 #define SCST_CMD_STATE_INIT_WAIT     (SCST_CMD_STATE_LAST_ACTIVE+1)
159
160 /* LUN translation (cmd->tgt_dev assignment) */
161 #define SCST_CMD_STATE_INIT          (SCST_CMD_STATE_LAST_ACTIVE+2)
162
163 /* Allocation of the cmd's data buffer */
164 #define SCST_CMD_STATE_PREPROCESS_DONE (SCST_CMD_STATE_LAST_ACTIVE+3)
165
166 /* Waiting for data from the initiator (until scst_rx_data() called) */
167 #define SCST_CMD_STATE_DATA_WAIT     (SCST_CMD_STATE_LAST_ACTIVE+4)
168
169 /* Waiting for CDB's execution finish */
170 #define SCST_CMD_STATE_REAL_EXECUTING (SCST_CMD_STATE_LAST_ACTIVE+5)
171
172 /* Waiting for response's transmission finish */
173 #define SCST_CMD_STATE_XMIT_WAIT     (SCST_CMD_STATE_LAST_ACTIVE+6)
174
175 /*************************************************************
176  * Can be retuned instead of cmd's state by dev handlers'
177  * functions, if the command's state should be set by default
178  *************************************************************/
179 #define SCST_CMD_STATE_DEFAULT        500
180
181 /*************************************************************
182  * Can be retuned instead of cmd's state by dev handlers'
183  * functions, if it is impossible to complete requested
184  * task in atomic context. The cmd will be restarted in thread
185  * context.
186  *************************************************************/
187 #define SCST_CMD_STATE_NEED_THREAD_CTX 1000
188
189 /*************************************************************
190  * Can be retuned instead of cmd's state by dev handlers'
191  * parse function, if the cmd processing should be stopped
192  * for now. The cmd will be restarted by dev handlers itself.
193  *************************************************************/
194 #define SCST_CMD_STATE_STOP           1001
195
196 /*************************************************************
197  ** States of mgmt command processing state machine
198  *************************************************************/
199
200 /* LUN translation (mcmd->tgt_dev assignment) */
201 #define SCST_MCMD_STATE_INIT     0
202
203 /* Mgmt cmd is ready for processing */
204 #define SCST_MCMD_STATE_READY    1
205
206 /* Mgmt cmd is being executing */
207 #define SCST_MCMD_STATE_EXECUTING 2
208
209 /* Post check when affected commands done */
210 #define SCST_MCMD_STATE_POST_AFFECTED_CMDS_DONE 3
211
212 /* Target driver's task_mgmt_fn_done() is going to be called */
213 #define SCST_MCMD_STATE_DONE     4
214
215 /* The mcmd finished */
216 #define SCST_MCMD_STATE_FINISHED 5
217
218 /*************************************************************
219  ** Constants for "atomic" parameter of SCST's functions
220  *************************************************************/
221 #define SCST_NON_ATOMIC              0
222 #define SCST_ATOMIC                  1
223
224 /*************************************************************
225  ** Values for pref_context parameter of scst_cmd_init_done(),
226  ** scst_rx_data(), scst_restart_cmd(), scst_tgt_cmd_done()
227  ** and scst_cmd_done()
228  *************************************************************/
229
230 enum scst_exec_context {
231         /*
232          * Direct cmd's processing (i.e. regular function calls in the current
233          * context) sleeping is not allowed
234          */
235         SCST_CONTEXT_DIRECT_ATOMIC,
236
237         /*
238          * Direct cmd's processing (i.e. regular function calls in the current
239          * context), sleeping is allowed, no restrictions
240          */
241         SCST_CONTEXT_DIRECT,
242
243         /* Tasklet or thread context required for cmd's processing */
244         SCST_CONTEXT_TASKLET,
245
246         /* Thread context required for cmd's processing */
247         SCST_CONTEXT_THREAD,
248
249         /*
250          * Context is the same as it was in previous call of the corresponding
251          * callback. For example, if dev handler's exec() does sync. data
252          * reading this value should be used for scst_cmd_done(). The same is
253          * true if scst_tgt_cmd_done() called directly from target driver's
254          * xmit_response(). Not allowed in scst_cmd_init_done() and
255          * scst_cmd_init_stage1_done().
256          */
257         SCST_CONTEXT_SAME
258 };
259
260 /*************************************************************
261  ** Values for status parameter of scst_rx_data()
262  *************************************************************/
263
264 /* Success */
265 #define SCST_RX_STATUS_SUCCESS       0
266
267 /*
268  * Data receiving finished with error, so set the sense and
269  * finish the command, including xmit_response() call
270  */
271 #define SCST_RX_STATUS_ERROR         1
272
273 /*
274  * Data receiving finished with error and the sense is set,
275  * so finish the command, including xmit_response() call
276  */
277 #define SCST_RX_STATUS_ERROR_SENSE_SET 2
278
279 /*
280  * Data receiving finished with fatal error, so finish the command,
281  * but don't call xmit_response()
282  */
283 #define SCST_RX_STATUS_ERROR_FATAL   3
284
285 /*************************************************************
286  ** Values for status parameter of scst_restart_cmd()
287  *************************************************************/
288
289 /* Success */
290 #define SCST_PREPROCESS_STATUS_SUCCESS       0
291
292 /*
293  * Command's processing finished with error, so set the sense and
294  * finish the command, including xmit_response() call
295  */
296 #define SCST_PREPROCESS_STATUS_ERROR         1
297
298 /*
299  * Command's processing finished with error and the sense is set,
300  * so finish the command, including xmit_response() call
301  */
302 #define SCST_PREPROCESS_STATUS_ERROR_SENSE_SET 2
303
304 /*
305  * Command's processing finished with fatal error, so finish the command,
306  * but don't call xmit_response()
307  */
308 #define SCST_PREPROCESS_STATUS_ERROR_FATAL   3
309
310 /* Thread context requested */
311 #define SCST_PREPROCESS_STATUS_NEED_THREAD   4
312
313 /*************************************************************
314  ** Values for AEN functions
315  *************************************************************/
316
317 /*
318  * SCSI Asynchronous Event. Parameter contains SCSI sense
319  * (Unit Attention). AENs generated only for 2 the following UAs:
320  * CAPACITY DATA HAS CHANGED and REPORTED LUNS DATA HAS CHANGED.
321  * Other UAs reported regularly as CHECK CONDITION status,
322  * because it doesn't look safe to report them using AENs, since
323  * reporting using AENs opens delivery race windows even in case of
324  * untagged commands.
325  */
326 #define SCST_AEN_SCSI                0
327
328 /*************************************************************
329  ** Allowed return/status codes for report_aen() callback and
330  ** scst_set_aen_delivery_status() function
331  *************************************************************/
332
333 /* Success */
334 #define SCST_AEN_RES_SUCCESS         0
335
336 /* Not supported */
337 #define SCST_AEN_RES_NOT_SUPPORTED  -1
338
339 /* Failure */
340 #define SCST_AEN_RES_FAILED         -2
341
342 /*************************************************************
343  ** Allowed return codes for xmit_response(), rdy_to_xfer()
344  *************************************************************/
345
346 /* Success */
347 #define SCST_TGT_RES_SUCCESS         0
348
349 /* Internal device queue is full, retry again later */
350 #define SCST_TGT_RES_QUEUE_FULL      -1
351
352 /*
353  * It is impossible to complete requested task in atomic context.
354  * The cmd will be restarted in thread  context.
355  */
356 #define SCST_TGT_RES_NEED_THREAD_CTX -2
357
358 /*
359  * Fatal error, if returned by xmit_response() the cmd will
360  * be destroyed, if by any other function, xmit_response()
361  * will be called with HARDWARE ERROR sense data
362  */
363 #define SCST_TGT_RES_FATAL_ERROR     -3
364
365 /*************************************************************
366  ** Allowed return codes for dev handler's exec()
367  *************************************************************/
368
369 /* The cmd is done, go to other ones */
370 #define SCST_EXEC_COMPLETED          0
371
372 /* The cmd should be sent to SCSI mid-level */
373 #define SCST_EXEC_NOT_COMPLETED      1
374
375 /*
376  * Thread context is required to execute the command.
377  * Exec() will be called again in the thread context.
378  */
379 #define SCST_EXEC_NEED_THREAD        2
380
381 /*
382  * Set if cmd is finished and there is status/sense to be sent.
383  * The status should be not sent (i.e. the flag not set) if the
384  * possibility to perform a command in "chunks" (i.e. with multiple
385  * xmit_response()/rdy_to_xfer()) is used (not implemented yet).
386  * Obsolete, use scst_cmd_get_is_send_status() instead.
387  */
388 #define SCST_TSC_FLAG_STATUS         0x2
389
390 /*************************************************************
391  ** Additional return code for dev handler's task_mgmt_fn()
392  *************************************************************/
393
394 /* Regular standard actions for the command should be done */
395 #define SCST_DEV_TM_NOT_COMPLETED     1
396
397 /*************************************************************
398  ** Session initialization phases
399  *************************************************************/
400
401 /* Set if session is being initialized */
402 #define SCST_SESS_IPH_INITING        0
403
404 /* Set if the session is successfully initialized */
405 #define SCST_SESS_IPH_SUCCESS        1
406
407 /* Set if the session initialization failed */
408 #define SCST_SESS_IPH_FAILED         2
409
410 /* Set if session is initialized and ready */
411 #define SCST_SESS_IPH_READY          3
412
413 /*************************************************************
414  ** Session shutdown phases
415  *************************************************************/
416
417 /* Set if session is initialized and ready */
418 #define SCST_SESS_SPH_READY          0
419
420 /* Set if session is shutting down */
421 #define SCST_SESS_SPH_SHUTDOWN       1
422
423 /*************************************************************
424  ** Session's async (atomic) flags
425  *************************************************************/
426
427 /* Set if the sess's hw pending work is scheduled */
428 #define SCST_SESS_HW_PENDING_WORK_SCHEDULED     0
429
430 /*************************************************************
431  ** Cmd's async (atomic) flags
432  *************************************************************/
433
434 /* Set if the cmd is aborted and ABORTED sense will be sent as the result */
435 #define SCST_CMD_ABORTED                0
436
437 /* Set if the cmd is aborted by other initiator */
438 #define SCST_CMD_ABORTED_OTHER          1
439
440 /* Set if the cmd is aborted and counted in cmd_done_wait_count */
441 #define SCST_CMD_DONE_COUNTED           2
442
443 /* Set if no response should be sent to the target about this cmd */
444 #define SCST_CMD_NO_RESP                3
445
446 /* Set if the cmd is dead and can be destroyed at any time */
447 #define SCST_CMD_CAN_BE_DESTROYED       4
448
449 /*************************************************************
450  ** Tgt_dev's async. flags (tgt_dev_flags)
451  *************************************************************/
452
453 /* Set if tgt_dev has Unit Attention sense */
454 #define SCST_TGT_DEV_UA_PENDING         0
455
456 /* Set if tgt_dev is RESERVED by another session */
457 #define SCST_TGT_DEV_RESERVED           1
458
459 /* Set if the corresponding context is atomic */
460 #define SCST_TGT_DEV_AFTER_INIT_WR_ATOMIC       5
461 #define SCST_TGT_DEV_AFTER_INIT_OTH_ATOMIC      6
462 #define SCST_TGT_DEV_AFTER_RESTART_WR_ATOMIC    7
463 #define SCST_TGT_DEV_AFTER_RESTART_OTH_ATOMIC   8
464 #define SCST_TGT_DEV_AFTER_RX_DATA_ATOMIC       9
465 #define SCST_TGT_DEV_AFTER_EXEC_ATOMIC          10
466
467 #define SCST_TGT_DEV_CLUST_POOL                 11
468
469 #ifdef CONFIG_SCST_PROC
470
471 /*************************************************************
472  ** Name of the entry in /proc
473  *************************************************************/
474 #define SCST_PROC_ENTRY_NAME         "scsi_tgt"
475
476 #endif
477
478 /*************************************************************
479  ** Activities suspending timeout
480  *************************************************************/
481 #define SCST_SUSPENDING_TIMEOUT                 (90 * HZ)
482
483 /*************************************************************
484  ** Kernel cache creation helper
485  *************************************************************/
486 #ifndef KMEM_CACHE
487 #define KMEM_CACHE(__struct, __flags) kmem_cache_create(#__struct,\
488         sizeof(struct __struct), __alignof__(struct __struct),\
489         (__flags), NULL, NULL)
490 #endif
491
492 /*************************************************************
493  ** Vlaid_mask constants for scst_analyze_sense()
494  *************************************************************/
495
496 #define SCST_SENSE_KEY_VALID            1
497 #define SCST_SENSE_ASC_VALID            2
498 #define SCST_SENSE_ASCQ_VALID           4
499
500 #define SCST_SENSE_ASCx_VALID           (SCST_SENSE_ASC_VALID | \
501                                          SCST_SENSE_ASCQ_VALID)
502
503 #define SCST_SENSE_ALL_VALID            (SCST_SENSE_KEY_VALID | \
504                                          SCST_SENSE_ASC_VALID | \
505                                          SCST_SENSE_ASCQ_VALID)
506
507 /*************************************************************
508  *                     TYPES
509  *************************************************************/
510
511 struct scst_tgt;
512 struct scst_session;
513 struct scst_cmd;
514 struct scst_mgmt_cmd;
515 struct scst_device;
516 struct scst_tgt_dev;
517 struct scst_dev_type;
518 struct scst_acg;
519 struct scst_acg_dev;
520 struct scst_acn;
521 struct scst_aen;
522
523 /*
524  * SCST uses 64-bit numbers to represent LUN's internally. The value
525  * NO_SUCH_LUN is guaranteed to be different of every valid LUN.
526  */
527 #define NO_SUCH_LUN ((uint64_t)-1)
528
529 typedef enum dma_data_direction scst_data_direction;
530
531 enum scst_cdb_flags {
532         /* SCST_TRANSFER_LEN_TYPE_FIXED must be equiv 1 (FIXED_BIT in cdb) */
533         SCST_TRANSFER_LEN_TYPE_FIXED =          0x001,
534         SCST_SMALL_TIMEOUT =                    0x002,
535         SCST_LONG_TIMEOUT =                     0x004,
536         SCST_UNKNOWN_LENGTH =                   0x008,
537         SCST_INFO_NOT_FOUND =                   0x010, /* must be single bit */
538         SCST_VERIFY_BYTCHK_MISMATCH_ALLOWED =   0x020,
539         SCST_IMPLICIT_HQ =                      0x040,
540         SCST_SKIP_UA =                          0x080,
541         SCST_WRITE_MEDIUM =                     0x100,
542         SCST_LOCAL_CMD =                        0x200,
543         SCST_LOCAL_EXEC_NEEDED =                0x400,
544 };
545
546 /*
547  * Scsi_Target_Template: defines what functions a target driver will
548  * have to provide in order to work with the target mid-level.
549  * MUST HAVEs define functions that are expected to be in order to work.
550  * OPTIONAL says that there is a choice.
551  *
552  * Also, pay attention to the fact that a command is BLOCKING or NON-BLOCKING.
553  * NON-BLOCKING means that a function returns immediately and will not wait
554  * for actual data transfer to finish. Blocking in such command could have
555  * negative impact on overall system performance. If blocking is necessary,
556  * it is worth to consider creating dedicated thread(s) in target driver, to
557  * which the commands would be passed and which would perform blocking
558  * operations instead of SCST.
559  *
560  * If the function allowed to sleep or not is determined by its last
561  * argument, which is true, if sleeping is not allowed. In this case,
562  * if the function requires sleeping, it  can return
563  * SCST_TGT_RES_NEED_THREAD_CTX, and it will be recalled in the thread context,
564  * where sleeping is allowed.
565  */
566 struct scst_tgt_template {
567         /* public: */
568
569         /*
570          * SG tablesize allows to check whether scatter/gather can be used
571          * or not.
572          */
573         int sg_tablesize;
574
575         /*
576          * True, if this target adapter uses unchecked DMA onto an ISA bus.
577          */
578         unsigned unchecked_isa_dma:1;
579
580         /*
581          * True, if this target adapter can benefit from using SG-vector
582          * clustering (i.e. smaller number of segments).
583          */
584         unsigned use_clustering:1;
585
586         /*
587          * True, if this target adapter doesn't support SG-vector clustering
588          */
589         unsigned no_clustering:1;
590
591         /*
592          * True, if corresponding function supports execution in
593          * the atomic (non-sleeping) context
594          */
595         unsigned xmit_response_atomic:1;
596         unsigned rdy_to_xfer_atomic:1;
597
598 #ifdef CONFIG_SCST_PROC
599         /* True, if the template doesn't need the entry in /proc */
600         unsigned no_proc_entry:1;
601 #endif
602
603         /*
604          * The maximum time in seconds cmd can stay inside the target
605          * hardware, i.e. after rdy_to_xfer() and xmit_response(), before
606          * on_hw_pending_cmd_timeout() will be called, if defined.
607          *
608          * In the current implementation a cmd will be aborted in time t
609          * max_hw_pending_time <= t < 2*max_hw_pending_time.
610          */
611         int max_hw_pending_time;
612
613         /*
614          * This function is equivalent to the SCSI
615          * queuecommand. The target should transmit the response
616          * buffer and the status in the scst_cmd struct.
617          * The expectation is that this executing this command is NON-BLOCKING.
618          *
619          * After the response is actually transmitted, the target
620          * should call the scst_tgt_cmd_done() function of the
621          * mid-level, which will allow it to free up the command.
622          * Returns one of the SCST_TGT_RES_* constants.
623          *
624          * Pay attention to "atomic" attribute of the cmd, which can be get
625          * by scst_cmd_atomic(): it is true if the function called in the
626          * atomic (non-sleeping) context.
627          *
628          * MUST HAVE
629          */
630         int (*xmit_response) (struct scst_cmd *cmd);
631
632         /*
633          * This function informs the driver that data
634          * buffer corresponding to the said command have now been
635          * allocated and it is OK to receive data for this command.
636          * This function is necessary because a SCSI target does not
637          * have any control over the commands it receives. Most lower
638          * level protocols have a corresponding function which informs
639          * the initiator that buffers have been allocated e.g., XFER_
640          * RDY in Fibre Channel. After the data is actually received
641          * the low-level driver needs to call scst_rx_data() in order to
642          * continue processing this command.
643          * Returns one of the SCST_TGT_RES_* constants.
644          * This command is expected to be NON-BLOCKING.
645          *
646          * Pay attention to "atomic" attribute of the cmd, which can be get
647          * by scst_cmd_atomic(): it is true if the function called in the
648          * atomic (non-sleeping) context.
649          *
650          * OPTIONAL
651          */
652         int (*rdy_to_xfer) (struct scst_cmd *cmd);
653
654         /*
655          * Called if cmd stays inside the target hardware, i.e. after
656          * rdy_to_xfer() and xmit_response(), more than max_hw_pending_time
657          * time. The target driver supposed to cleanup this command and
658          * resume cmd's processing.
659          *
660          * OPTIONAL
661          */
662         void (*on_hw_pending_cmd_timeout) (struct scst_cmd *cmd);
663
664         /*
665          * Called to notify the driver that the command is about to be freed.
666          * Necessary, because for aborted commands xmit_response() could not
667          * be called. Could be called on IRQ context.
668          *
669          * OPTIONAL
670          */
671         void (*on_free_cmd) (struct scst_cmd *cmd);
672
673         /*
674          * This function allows target driver to handle data buffer
675          * allocations on its own.
676          *
677          * Target driver doesn't have to always allocate buffer in this
678          * function, but if it decide to do it, it must check that
679          * scst_cmd_get_data_buff_alloced() returns 0, otherwise to avoid
680          * double buffer allocation and memory leaks alloc_data_buf() shall
681          * fail.
682          *
683          * Shall return 0 in case of success or < 0 (preferrably -ENOMEM)
684          * in case of error, or > 0 if the regular SCST allocation should be
685          * done. In case of returning successfully,
686          * scst_cmd->tgt_data_buf_alloced will be set by SCST.
687          *
688          * It is possible that both target driver and dev handler request own
689          * memory allocation. In this case, data will be memcpy() between
690          * buffers, where necessary.
691          *
692          * If allocation in atomic context - cf. scst_cmd_atomic() - is not
693          * desired or fails and consequently < 0 is returned, this function
694          * will be re-called in thread context.
695          *
696          * Please note that the driver will have to handle itself all relevant
697          * details such as scatterlist setup, highmem, freeing the allocated
698          * memory, etc.
699          *
700          * OPTIONAL.
701          */
702         int (*alloc_data_buf) (struct scst_cmd *cmd);
703
704         /*
705          * This function informs the driver that data
706          * buffer corresponding to the said command have now been
707          * allocated and other preprocessing tasks have been done.
708          * A target driver could need to do some actions at this stage.
709          * After the target driver done the needed actions, it shall call
710          * scst_restart_cmd() in order to continue processing this command.
711          *
712          * Called only if the cmd is queued using scst_cmd_init_stage1_done()
713          * instead of scst_cmd_init_done().
714          *
715          * Returns void, the result is expected to be returned using
716          * scst_restart_cmd().
717          *
718          * This command is expected to be NON-BLOCKING.
719          *
720          * Pay attention to "atomic" attribute of the cmd, which can be get
721          * by scst_cmd_atomic(): it is true if the function called in the
722          * atomic (non-sleeping) context.
723          *
724          * OPTIONAL.
725          */
726         void (*preprocessing_done) (struct scst_cmd *cmd);
727
728         /*
729          * This function informs the driver that the said command is about
730          * to be executed.
731          *
732          * Returns one of the SCST_PREPROCESS_* constants.
733          *
734          * This command is expected to be NON-BLOCKING.
735          *
736          * Pay attention to "atomic" attribute of the cmd, which can be get
737          * by scst_cmd_atomic(): it is true if the function called in the
738          * atomic (non-sleeping) context.
739          *
740          * OPTIONAL
741          */
742         int (*pre_exec) (struct scst_cmd *cmd);
743
744         /*
745          * This function informs the driver that all affected by the
746          * corresponding task management function commands have beed completed.
747          * No return value expected.
748          *
749          * This function is expected to be NON-BLOCKING.
750          *
751          * Called without any locks held from a thread context.
752          *
753          * OPTIONAL
754          */
755         void (*task_mgmt_affected_cmds_done) (struct scst_mgmt_cmd *mgmt_cmd);
756
757         /*
758          * This function informs the driver that the corresponding task
759          * management function has been completed, i.e. all the corresponding
760          * commands completed and freed. No return value expected.
761          *
762          * This function is expected to be NON-BLOCKING.
763          *
764          * Called without any locks held from a thread context.
765          *
766          * MUST HAVE if the target supports task management.
767          */
768         void (*task_mgmt_fn_done) (struct scst_mgmt_cmd *mgmt_cmd);
769
770         /*
771          * This function should detect the target adapters that
772          * are present in the system. The function should return a value
773          * >= 0 to signify the number of detected target adapters.
774          * A negative value should be returned whenever there is
775          * an error.
776          *
777          * MUST HAVE
778          */
779         int (*detect) (struct scst_tgt_template *tgt_template);
780
781         /*
782          * This function should free up the resources allocated to the device.
783          * The function should return 0 to indicate successful release
784          * or a negative value if there are some issues with the release.
785          * In the current version the return value is ignored.
786          *
787          * MUST HAVE
788          */
789         int (*release) (struct scst_tgt *tgt);
790
791         /*
792          * This function is used for Asynchronous Event Notifications.
793          *
794          * Returns one of the SCST_AEN_RES_* constants.
795          * After AEN is sent, target driver must call scst_aen_done() and,
796          * optionally, scst_set_aen_delivery_status().
797          *
798          * This command is expected to be NON-BLOCKING, but can sleep.
799          *
800          * MUST HAVE, if low-level protocol supports AENs.
801          */
802         int (*report_aen) (struct scst_aen *aen);
803
804 #ifdef CONFIG_SCST_PROC
805         /*
806          * Those functions can be used to export the driver's statistics and
807          * other infos to the world outside the kernel as well as to get some
808          * management commands from it.
809          *
810          * OPTIONAL
811          */
812         int (*read_proc) (struct seq_file *seq, struct scst_tgt *tgt);
813         int (*write_proc) (char *buffer, char **start, off_t offset,
814                 int length, int *eof, struct scst_tgt *tgt);
815 #endif
816
817         /*
818          * This function allows to enable or disable particular target.
819          * A disabled target doesn't receive and process any SCSI commands.
820          *
821          * SHOULD HAVE to avoid race when there are connected initiators,
822          * while target not yet completed the initial configuration. In this
823          * case the too early connected initiators would see not those devices,
824          * which they intended to see.
825          */
826         ssize_t (*enable_tgt) (struct scst_tgt *tgt, const char *buffer,
827                            size_t size);
828
829         /*
830          * This function shows if particular target is enabled or not.
831          *
832          * SHOULD HAVE, see above why.
833          */
834         bool (*is_tgt_enabled) (struct scst_tgt *tgt);
835
836         /*
837          * Name of the template. Must be unique to identify
838          * the template. MUST HAVE
839          */
840         const char name[SCST_MAX_NAME];
841
842         /*
843          * Number of additional threads to the pool of dedicated threads.
844          * Used if xmit_response() or rdy_to_xfer() is blocking.
845          * It is the target driver's duty to ensure that not more, than that
846          * number of threads, are blocked in those functions at any time.
847          */
848         int threads_num;
849
850         /* Optional default log flags */
851         const unsigned long default_trace_flags;
852
853         /* Optional pointer to trace flags */
854         unsigned long *trace_flags;
855
856         /* Optional local trace table */
857         struct scst_trace_log *trace_tbl;
858
859         /* Optional local trace table help string */
860         const char *trace_tbl_help;
861
862 #ifndef CONFIG_SCST_PROC
863         /* Optional sysfs attributes */
864         const struct attribute **tgtt_attrs;
865
866         /* Optional sysfs target attributes */
867         const struct attribute **tgt_attrs;
868 #endif
869
870         /** Private, must be inited to 0 by memset() **/
871
872         /* List of targets per template, protected by scst_mutex */
873         struct list_head tgt_list;
874
875         /* List entry of global templates list */
876         struct list_head scst_template_list_entry;
877
878 #ifdef CONFIG_SCST_PROC
879         /* The pointer to the /proc directory entry */
880         struct proc_dir_entry *proc_tgt_root;
881 #endif
882
883         /* Set if tgtt_kobj was initialized */
884         unsigned int tgtt_kobj_initialized:1;
885
886         struct kobject tgtt_kobj; /* kobject for this struct */
887
888         struct completion tgtt_kobj_release_cmpl;
889
890 #ifdef CONFIG_SCST_PROC
891         /* Device number in /proc */
892         int proc_dev_num;
893 #endif
894 };
895
896 struct scst_dev_type {
897         /* SCSI type of the supported device. MUST HAVE */
898         int type;
899
900         /*
901          * True, if corresponding function supports execution in
902          * the atomic (non-sleeping) context
903          */
904         unsigned parse_atomic:1;
905         unsigned exec_atomic:1;
906         unsigned dev_done_atomic:1;
907
908 #ifdef CONFIG_SCST_PROC
909         /* Set, if no /proc files should be automatically created by SCST */
910         unsigned no_proc:1;
911 #endif
912
913         /*
914          * Should be set, if exec() is synchronous. This is a hint to SCST core
915          * to optimize commands order management.
916          */
917         unsigned exec_sync:1;
918
919         /*
920          * Called to parse CDB from the cmd and initialize
921          * cmd->bufflen and cmd->data_direction (both - REQUIRED).
922          * Returns the command's next state or SCST_CMD_STATE_DEFAULT,
923          * if the next default state should be used, or
924          * SCST_CMD_STATE_NEED_THREAD_CTX if the function called in atomic
925          * context, but requires sleeping, or SCST_CMD_STATE_STOP if the
926          * command should not be further processed for now. In the
927          * SCST_CMD_STATE_NEED_THREAD_CTX case the function
928          * will be recalled in the thread context, where sleeping is allowed.
929          *
930          * Pay attention to "atomic" attribute of the cmd, which can be get
931          * by scst_cmd_atomic(): it is true if the function called in the
932          * atomic (non-sleeping) context.
933          *
934          * MUST HAVE
935          */
936         int (*parse) (struct scst_cmd *cmd);
937
938         /*
939          * Called to execute CDB. Useful, for instance, to implement
940          * data caching. The result of CDB execution is reported via
941          * cmd->scst_cmd_done() callback.
942          * Returns:
943          *  - SCST_EXEC_COMPLETED - the cmd is done, go to other ones
944          *  - SCST_EXEC_NEED_THREAD - thread context is required to execute
945          *      the command. Exec() will be called again in the thread context.
946          *  - SCST_EXEC_NOT_COMPLETED - the cmd should be sent to SCSI
947          *      mid-level.
948          *
949          * Pay attention to "atomic" attribute of the cmd, which can be get
950          * by scst_cmd_atomic(): it is true if the function called in the
951          * atomic (non-sleeping) context.
952          *
953          * If this function provides sync execution, you should set
954          * exec_sync flag and consider to setup dedicated threads by
955          * setting threads_num > 0.
956          *
957          * !! If this function is implemented, scst_check_local_events() !!
958          * !! shall be called inside it just before the actual command's !!
959          * !! execution.                                                 !!
960          *
961          * OPTIONAL, if not set, the commands will be sent directly to SCSI
962          * device.
963          */
964         int (*exec) (struct scst_cmd *cmd);
965
966         /*
967          * Called to notify dev handler about the result of cmd execution
968          * and perform some post processing. Cmd's fields is_send_status and
969          * resp_data_len should be set by this function, but SCST offers good
970          * defaults.
971          * Returns the command's next state or SCST_CMD_STATE_DEFAULT,
972          * if the next default state should be used, or
973          * SCST_CMD_STATE_NEED_THREAD_CTX if the function called in atomic
974          * context, but requires sleeping. In the last case, the function
975          * will be recalled in the thread context, where sleeping is allowed.
976          *
977          * Pay attention to "atomic" attribute of the cmd, which can be get
978          * by scst_cmd_atomic(): it is true if the function called in the
979          * atomic (non-sleeping) context.
980          */
981         int (*dev_done) (struct scst_cmd *cmd);
982
983         /*
984          * Called to notify dev hander that the command is about to be freed.
985          * Could be called on IRQ context.
986          */
987         void (*on_free_cmd) (struct scst_cmd *cmd);
988
989         /*
990          * Called to execute a task management command.
991          * Returns:
992          *  - SCST_MGMT_STATUS_SUCCESS - the command is done with success,
993          *      no firther actions required
994          *  - The SCST_MGMT_STATUS_* error code if the command is failed and
995          *      no further actions required
996          *  - SCST_DEV_TM_NOT_COMPLETED - regular standard actions for the
997          *      command should be done
998          *
999          * Called without any locks held from a thread context.
1000          */
1001         int (*task_mgmt_fn) (struct scst_mgmt_cmd *mgmt_cmd,
1002                 struct scst_tgt_dev *tgt_dev);
1003
1004         /*
1005          * Called when new device is attaching to the dev handler
1006          * Returns 0 on success, error code otherwise.
1007          */
1008         int (*attach) (struct scst_device *dev);
1009
1010         /* Called when new device is detaching from the dev handler */
1011         void (*detach) (struct scst_device *dev);
1012
1013         /*
1014          * Called when new tgt_dev (session) is attaching to the dev handler.
1015          * Returns 0 on success, error code otherwise.
1016          */
1017         int (*attach_tgt) (struct scst_tgt_dev *tgt_dev);
1018
1019         /* Called when tgt_dev (session) is detaching from the dev handler */
1020         void (*detach_tgt) (struct scst_tgt_dev *tgt_dev);
1021
1022 #ifdef CONFIG_SCST_PROC
1023         /*
1024          * Those functions can be used to export the handler's statistics and
1025          * other infos to the world outside the kernel as well as to get some
1026          * management commands from it.
1027          *
1028          * OPTIONAL
1029          */
1030         int (*read_proc) (struct seq_file *seq, struct scst_dev_type *dev_type);
1031         int (*write_proc) (char *buffer, char **start, off_t offset,
1032                 int length, int *eof, struct scst_dev_type *dev_type);
1033 #endif
1034
1035         /*
1036          * Name of the dev handler. Must be unique. MUST HAVE.
1037          *
1038          * It's SCST_MAX_NAME + few more bytes to match scst_user expectations.
1039          */
1040         char name[SCST_MAX_NAME + 10];
1041
1042         /*
1043          * Number of dedicated threads. If 0 - no dedicated threads will
1044          * be created, if <0 - creation of dedicated threads is prohibited.
1045          */
1046         int threads_num;
1047
1048         /* Optional default log flags */
1049         const unsigned long default_trace_flags;
1050
1051         /* Optional pointer to trace flags */
1052         unsigned long *trace_flags;
1053
1054         /* Optional local trace table */
1055         struct scst_trace_log *trace_tbl;
1056
1057         /* Optional local trace table help string */
1058         const char *trace_tbl_help;
1059
1060 #ifndef CONFIG_SCST_PROC
1061         /* Optional sysfs attributes */
1062         const struct attribute **devt_attrs;
1063
1064         /* Optional sysfs device attributes */
1065         const struct attribute **dev_attrs;
1066 #endif
1067
1068         /* Pointer to dev handler's private data */
1069         void *devt_priv;
1070
1071         /* Pointer to parent dev type in the sysfs hierarchy */
1072         struct scst_dev_type *parent;
1073
1074         struct module *module;
1075
1076         /** Private, must be inited to 0 by memset() **/
1077
1078         /* list entry in scst_dev_type_list */
1079         struct list_head dev_type_list_entry;
1080
1081 #ifdef CONFIG_SCST_PROC
1082         /* The pointer to the /proc directory entry */
1083         struct proc_dir_entry *proc_dev_type_root;
1084 #endif
1085
1086         unsigned int devt_kobj_initialized:1;
1087
1088         struct kobject devt_kobj; /* main handlers/driver */
1089
1090         /* To wait until devt_kobj released */
1091         struct completion devt_kobj_release_compl;
1092 };
1093
1094 struct scst_tgt {
1095         /* List of remote sessions per target, protected by scst_mutex */
1096         struct list_head sess_list;
1097
1098         /* List entry of targets per template (tgts_list) */
1099         struct list_head tgt_list_entry;
1100
1101         struct scst_tgt_template *tgtt; /* corresponding target template */
1102
1103         struct scst_acg *default_acg; /* The default acg for this target. */
1104
1105         /*
1106          * Maximum SG table size. Needed here, since different cards on the
1107          * same target template can have different SG table limitations.
1108          */
1109         int sg_tablesize;
1110
1111         /* Used for storage of target driver private stuff */
1112         void *tgt_priv;
1113
1114         /*
1115          * The following fields used to store and retry cmds if target's
1116          * internal queue is full, so the target is unable to accept
1117          * the cmd returning QUEUE FULL.
1118          * They protected by tgt_lock, where necessary.
1119          */
1120         bool retry_timer_active;
1121         struct timer_list retry_timer;
1122         atomic_t finished_cmds;
1123         int retry_cmds;
1124         spinlock_t tgt_lock;
1125         struct list_head retry_cmd_list;
1126
1127         /* Used to wait until session finished to unregister */
1128         wait_queue_head_t unreg_waitQ;
1129
1130 #ifdef CONFIG_SCST_PROC
1131         /* Device number in /proc */
1132         int proc_num;
1133 #endif
1134
1135         /* Name of the target */
1136         char *tgt_name;
1137
1138 #ifdef CONFIG_SCST_PROC
1139         /* Name on the default security group ("Default_target_name") */
1140         char *default_group_name;
1141 #endif
1142
1143         /* Set if tgt_kobj was initialized */
1144         unsigned int tgt_kobj_initialized:1;
1145
1146         struct kobject tgt_kobj; /* main targets/target kobject */
1147         struct kobject *tgt_sess_kobj; /* target/sessions/ */
1148         struct kobject *tgt_luns_kobj; /* target/luns/ */
1149         struct kobject *tgt_ini_grp_kobj; /* target/ini_groups/ */
1150 };
1151
1152 /* Hash size and hash fn for hash based lun translation */
1153 #define TGT_DEV_HASH_SHIFT      5
1154 #define TGT_DEV_HASH_SIZE       (1 << TGT_DEV_HASH_SHIFT)
1155 #define HASH_VAL(_val)          (_val & (TGT_DEV_HASH_SIZE - 1))
1156
1157 #ifdef CONFIG_SCST_MEASURE_LATENCY
1158
1159 /* Defines extended latency statistics */
1160 struct scst_ext_latency_stat {
1161         uint64_t scst_time_rd, tgt_time_rd, dev_time_rd;
1162         unsigned int processed_cmds_rd;
1163         uint64_t min_scst_time_rd, min_tgt_time_rd, min_dev_time_rd;
1164         uint64_t max_scst_time_rd, max_tgt_time_rd, max_dev_time_rd;
1165
1166         uint64_t scst_time_wr, tgt_time_wr, dev_time_wr;
1167         unsigned int processed_cmds_wr;
1168         uint64_t min_scst_time_wr, min_tgt_time_wr, min_dev_time_wr;
1169         uint64_t max_scst_time_wr, max_tgt_time_wr, max_dev_time_wr;
1170 };
1171
1172 #define SCST_IO_SIZE_THRESHOLD_SMALL            (8*1024)
1173 #define SCST_IO_SIZE_THRESHOLD_MEDIUM           (32*1024)
1174 #define SCST_IO_SIZE_THRESHOLD_LARGE            (128*1024)
1175 #define SCST_IO_SIZE_THRESHOLD_VERY_LARGE       (512*1024)
1176
1177 #define SCST_LATENCY_STAT_INDEX_SMALL           0
1178 #define SCST_LATENCY_STAT_INDEX_MEDIUM          1
1179 #define SCST_LATENCY_STAT_INDEX_LARGE           2
1180 #define SCST_LATENCY_STAT_INDEX_VERY_LARGE      3
1181 #define SCST_LATENCY_STAT_INDEX_OTHER           4
1182 #define SCST_LATENCY_STATS_NUM          (SCST_LATENCY_STAT_INDEX_OTHER + 1)
1183
1184 #endif /* CONFIG_SCST_MEASURE_LATENCY */
1185
1186 struct scst_session {
1187         /*
1188          * Initialization phase, one of SCST_SESS_IPH_* constants, protected by
1189          * sess_list_lock
1190          */
1191         int init_phase;
1192
1193         struct scst_tgt *tgt;   /* corresponding target */
1194
1195         /* Used for storage of target driver private stuff */
1196         void *tgt_priv;
1197
1198         unsigned long sess_aflags; /* session's async flags */
1199
1200         /*
1201          * Hash list of tgt_dev's for this session, protected by scst_mutex
1202          * and suspended activity
1203          */
1204         struct list_head sess_tgt_dev_list_hash[TGT_DEV_HASH_SIZE];
1205
1206         /*
1207          * List of cmds in this session. Used to find a cmd in the
1208          * session. Protected by sess_list_lock.
1209          */
1210         struct list_head search_cmd_list;
1211
1212         spinlock_t sess_list_lock; /* protects search_cmd_list, etc */
1213
1214         /*
1215          * List of cmds in this in the state after PRE_XMIT_RESP. All the cmds
1216          * moved here from search_cmd_list. Needed for hw_pending_work.
1217          * Protected by sess_list_lock.
1218          */
1219         struct list_head after_pre_xmit_cmd_list;
1220
1221         atomic_t refcnt;                /* get/put counter */
1222
1223         /*
1224          * Alive commands for this session. ToDo: make it part of the common
1225          * IO flow control.
1226          */
1227         atomic_t sess_cmd_count;
1228
1229         /* Access control for this session and list entry there */
1230         struct scst_acg *acg;
1231
1232         /* List entry for the sessions list inside ACG */
1233         struct list_head acg_sess_list_entry;
1234
1235 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20))
1236         struct delayed_work hw_pending_work;
1237 #else
1238         struct work_struct hw_pending_work;
1239 #endif
1240
1241         /* Name of attached initiator */
1242         const char *initiator_name;
1243
1244         /* List entry of sessions per target */
1245         struct list_head sess_list_entry;
1246
1247         /* List entry for the list that keeps session, waiting for the init */
1248         struct list_head sess_init_list_entry;
1249
1250         /*
1251          * List entry for the list that keeps session, waiting for the shutdown
1252          */
1253         struct list_head sess_shut_list_entry;
1254
1255         /*
1256          * Lists of deferred during session initialization commands.
1257          * Protected by sess_list_lock.
1258          */
1259         struct list_head init_deferred_cmd_list;
1260         struct list_head init_deferred_mcmd_list;
1261
1262         /*
1263          * Shutdown phase, one of SCST_SESS_SPH_* constants, unprotected.
1264          * Async. relating to init_phase, must be a separate variable, because
1265          * session could be unregistered before async. registration is finished.
1266          */
1267         unsigned long shut_phase;
1268
1269         /* Used if scst_unregister_session() called in wait mode */
1270         struct completion *shutdown_compl;
1271
1272         /* Set if sess_kobj was initialized */
1273         unsigned int sess_kobj_initialized:1;
1274
1275         struct kobject sess_kobj; /* kobject for this struct */
1276
1277         /*
1278          * Functions and data for user callbacks from scst_register_session()
1279          * and scst_unregister_session()
1280          */
1281         void *reg_sess_data;
1282         void (*init_result_fn) (struct scst_session *sess, void *data,
1283                                 int result);
1284         void (*unreg_done_fn) (struct scst_session *sess);
1285
1286 #ifdef CONFIG_SCST_MEASURE_LATENCY
1287         /*
1288          * Must be the last to allow to work with drivers who don't know
1289          * about this config time option.
1290          */
1291         spinlock_t lat_lock;
1292         uint64_t scst_time, tgt_time, dev_time;
1293         unsigned int processed_cmds;
1294         uint64_t min_scst_time, min_tgt_time, min_dev_time;
1295         uint64_t max_scst_time, max_tgt_time, max_dev_time;
1296         struct scst_ext_latency_stat sess_latency_stat[SCST_LATENCY_STATS_NUM];
1297 #endif
1298 };
1299
1300 struct scst_cmd_lists {
1301         spinlock_t cmd_list_lock;
1302         struct list_head active_cmd_list;
1303         wait_queue_head_t cmd_list_waitQ;
1304         struct list_head lists_list_entry;
1305 };
1306
1307 struct scst_cmd {
1308         /* List entry for below *_cmd_lists */
1309         struct list_head cmd_list_entry;
1310
1311         /* Pointer to lists of commands with the lock */
1312         struct scst_cmd_lists *cmd_lists;
1313
1314         atomic_t cmd_ref;
1315
1316         struct scst_session *sess;      /* corresponding session */
1317
1318         /* Cmd state, one of SCST_CMD_STATE_* constants */
1319         int state;
1320
1321         /*************************************************************
1322          ** Cmd's flags
1323          *************************************************************/
1324
1325         /*
1326          * Set if expected_sn should be incremented, i.e. cmd was sent
1327          * for execution
1328          */
1329         unsigned int sent_for_exec:1;
1330
1331         /* Set if the cmd's action is completed */
1332         unsigned int completed:1;
1333
1334         /* Set if we should ignore Unit Attention in scst_check_sense() */
1335         unsigned int ua_ignore:1;
1336
1337         /* Set if cmd is being processed in atomic context */
1338         unsigned int atomic:1;
1339
1340         /* Set if this command was sent in double UA possible state */
1341         unsigned int double_ua_possible:1;
1342
1343         /* Set if this command contains status */
1344         unsigned int is_send_status:1;
1345
1346         /* Set if cmd is being retried */
1347         unsigned int retry:1;
1348
1349         /* Set if cmd is internally generated */
1350         unsigned int internal:1;
1351
1352         /* Set if the device was blocked by scst_inc_on_dev_cmd() (for debug) */
1353         unsigned int inc_blocking:1;
1354
1355         /* Set if the device should be unblocked after cmd's finish */
1356         unsigned int needs_unblocking:1;
1357
1358         /* Set if scst_dec_on_dev_cmd() call is needed on the cmd's finish */
1359         unsigned int dec_on_dev_needed:1;
1360
1361         /* Set if cmd is queued as hw pending */
1362         unsigned int cmd_hw_pending:1;
1363
1364         /*
1365          * Set if the target driver wants to alloc data buffers on its own.
1366          * In this case alloc_data_buf() must be provided in the target driver
1367          * template.
1368          */
1369         unsigned int tgt_need_alloc_data_buf:1;
1370
1371         /*
1372          * Set by SCST if the custom data buffer allocation by the target driver
1373          * succeeded.
1374          */
1375         unsigned int tgt_data_buf_alloced:1;
1376
1377         /* Set if custom data buffer allocated by dev handler */
1378         unsigned int dh_data_buf_alloced:1;
1379
1380         /* Set if the target driver called scst_set_expected() */
1381         unsigned int expected_values_set:1;
1382
1383         /*
1384          * Set if the SG buffer was modified by scst_set_resp_data_len()
1385          */
1386         unsigned int sg_buff_modified:1;
1387
1388         /*
1389          * Set if scst_cmd_init_stage1_done() called and the target
1390          * want that preprocessing_done() will be called
1391          */
1392         unsigned int preprocessing_only:1;
1393
1394         /* Set if cmd's SN was set */
1395         unsigned int sn_set:1;
1396
1397         /* Set if hq_cmd_count was incremented */
1398         unsigned int hq_cmd_inced:1;
1399
1400         /*
1401          * Set if scst_cmd_init_stage1_done() called and the target wants
1402          * that the SN for the cmd won't be assigned until scst_restart_cmd()
1403          */
1404         unsigned int set_sn_on_restart_cmd:1;
1405
1406         /* Set if the cmd's must not use sgv cache for data buffer */
1407         unsigned int no_sgv:1;
1408
1409         /*
1410          * Set if target driver may need to call dma_sync_sg() or similar
1411          * function before transferring cmd' data to the target device
1412          * via DMA.
1413          */
1414         unsigned int may_need_dma_sync:1;
1415
1416         /* Set if the cmd was done or aborted out of its SN */
1417         unsigned int out_of_sn:1;
1418
1419         /* Set if increment expected_sn in cmd->scst_cmd_done() */
1420         unsigned int inc_expected_sn_on_done:1;
1421
1422         /* Set if tgt_sn field is valid */
1423         unsigned int tgt_sn_set:1;
1424
1425         /* Set if cmd is done */
1426         unsigned int done:1;
1427
1428         /* Set if cmd is finished */
1429         unsigned int finished:1;
1430
1431         /*
1432          * Set if the cmd was delayed by task management debugging code.
1433          * Used only if CONFIG_SCST_DEBUG_TM is on.
1434          */
1435         unsigned int tm_dbg_delayed:1;
1436
1437         /*
1438          * Set if the cmd must be ignored by task management debugging code.
1439          * Used only if CONFIG_SCST_DEBUG_TM is on.
1440          */
1441         unsigned int tm_dbg_immut:1;
1442
1443         /**************************************************************/
1444
1445         unsigned long cmd_flags; /* cmd's async flags */
1446
1447         /* Keeps status of cmd's status/data delivery to remote initiator */
1448         int delivery_status;
1449
1450         struct scst_tgt_template *tgtt; /* to save extra dereferences */
1451         struct scst_tgt *tgt;           /* to save extra dereferences */
1452         struct scst_device *dev;        /* to save extra dereferences */
1453
1454         struct scst_tgt_dev *tgt_dev;   /* corresponding device for this cmd */
1455
1456         uint64_t lun;                   /* LUN for this cmd */
1457
1458         unsigned long start_time;
1459
1460 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
1461         struct scsi_request *scsi_req;  /* SCSI request */
1462 #endif
1463
1464         /* List entry for tgt_dev's SN related lists */
1465         struct list_head sn_cmd_list_entry;
1466
1467         /* Cmd's serial number, used to execute cmd's in order of arrival */
1468         unsigned long sn;
1469
1470         /* The corresponding sn_slot in tgt_dev->sn_slots */
1471         atomic_t *sn_slot;
1472
1473         /* List entry for sess's search_cmd_list and after_pre_xmit_cmd_list */
1474         struct list_head sess_cmd_list_entry;
1475
1476         /*
1477          * Used to found the cmd by scst_find_cmd_by_tag(). Set by the
1478          * target driver on the cmd's initialization time
1479          */
1480         uint64_t tag;
1481
1482         uint32_t tgt_sn; /* SN set by target driver (for TM purposes) */
1483
1484         /* CDB and its len */
1485         uint8_t cdb[SCST_MAX_CDB_SIZE];
1486         short cdb_len; /* it might be -1 */
1487         unsigned short ext_cdb_len;
1488         uint8_t *ext_cdb;
1489
1490         enum scst_cdb_flags op_flags;
1491         const char *op_name;
1492
1493         enum scst_cmd_queue_type queue_type;
1494
1495         int timeout; /* CDB execution timeout in seconds */
1496         int retries; /* Amount of retries that will be done by SCSI mid-level */
1497
1498         /* SCSI data direction, one of SCST_DATA_* constants */
1499         scst_data_direction data_direction;
1500
1501         /* Remote initiator supplied values, if any */
1502         scst_data_direction expected_data_direction;
1503         int expected_transfer_len;
1504         int expected_in_transfer_len; /* for bidi writes */
1505
1506         /*
1507          * Cmd data length. Could be different from bufflen for commands like
1508          * VERIFY, which transfer different amount of data (if any), than
1509          * processed.
1510          */
1511         int data_len;
1512
1513         /* Completition routine */
1514         void (*scst_cmd_done) (struct scst_cmd *cmd, int next_state,
1515                 enum scst_exec_context pref_context);
1516
1517         struct sgv_pool_obj *sgv;       /* sgv object */
1518         int bufflen;                    /* cmd buffer length */
1519         struct scatterlist *sg;         /* cmd data buffer SG vector */
1520         int sg_cnt;                     /* SG segments count */
1521
1522         /*
1523          * Response data length in data buffer. This field must not be set
1524          * directly, use scst_set_resp_data_len() for that
1525          */
1526         int resp_data_len;
1527
1528         /* scst_get_sg_buf_[first,next]() support */
1529         int get_sg_buf_entry_num;
1530
1531         /* Bidirectional transfers support */
1532         int in_bufflen;                 /* WRITE buffer length */
1533         struct sgv_pool_obj *in_sgv;    /* WRITE sgv object */
1534         struct scatterlist *in_sg;      /* WRITE data buffer SG vector */
1535         int in_sg_cnt;                  /* WRITE SG segments count */
1536
1537         /*
1538          * Used if both target driver and dev handler request own memory
1539          * allocation. In other cases, both are equal to sg and sg_cnt
1540          * correspondingly.
1541          *
1542          * If target driver requests own memory allocations, it MUST use
1543          * functions scst_cmd_get_tgt_sg*() to get sg and sg_cnt! Otherwise,
1544          * it may use functions scst_cmd_get_sg*().
1545          */
1546         struct scatterlist *tgt_sg;
1547         int tgt_sg_cnt;
1548         struct scatterlist *tgt_in_sg;  /* bidirectional */
1549         int tgt_in_sg_cnt;              /* bidirectional */
1550
1551         /*
1552          * The status fields in case of errors must be set using
1553          * scst_set_cmd_error_status()!
1554          */
1555         uint8_t status;         /* status byte from target device */
1556         uint8_t msg_status;     /* return status from host adapter itself */
1557         uint8_t host_status;    /* set by low-level driver to indicate status */
1558         uint8_t driver_status;  /* set by mid-level */
1559
1560         uint8_t *sense;         /* pointer to sense buffer */
1561         unsigned short sense_valid_len; /* length of valid sense data */
1562         unsigned short sense_buflen; /* length of the sense buffer, if any */
1563
1564         /* Start time when cmd was sent to rdy_to_xfer() or xmit_response() */
1565         unsigned long hw_pending_start;
1566
1567         /* Used for storage of target driver private stuff */
1568         void *tgt_priv;
1569
1570         /* Used for storage of dev handler private stuff */
1571         void *dh_priv;
1572
1573         /*
1574          * Used to restore the SG vector if it was modified by
1575          * scst_set_resp_data_len()
1576          */
1577         int orig_sg_cnt, orig_sg_entry, orig_entry_len;
1578
1579         /* Used to retry commands in case of double UA */
1580         int dbl_ua_orig_resp_data_len, dbl_ua_orig_data_direction;
1581
1582         /* List corresponding mgmt cmd, if any, protected by sess_list_lock */
1583         struct list_head mgmt_cmd_list;
1584
1585         /* List entry for dev's blocked_cmd_list */
1586         struct list_head blocked_cmd_list_entry;
1587
1588         struct scst_cmd *orig_cmd; /* Used to issue REQUEST SENSE */
1589
1590 #ifdef CONFIG_SCST_MEASURE_LATENCY
1591         /*
1592          * Must be the last to allow to work with drivers who don't know
1593          * about this config time option.
1594          */
1595         uint64_t start, curr_start, parse_time, alloc_buf_time;
1596         uint64_t restart_waiting_time, rdy_to_xfer_time;
1597         uint64_t pre_exec_time, exec_time, dev_done_time;
1598         uint64_t xmit_time, tgt_on_free_time, dev_on_free_time;
1599 #endif
1600 };
1601
1602 struct scst_rx_mgmt_params {
1603         int fn;
1604         uint64_t tag;
1605         const uint8_t *lun;
1606         int lun_len;
1607         uint32_t cmd_sn;
1608         int atomic;
1609         void *tgt_priv;
1610         unsigned char tag_set;
1611         unsigned char lun_set;
1612         unsigned char cmd_sn_set;
1613 };
1614
1615 struct scst_mgmt_cmd_stub {
1616         struct scst_mgmt_cmd *mcmd;
1617
1618         /* List entry in cmd->mgmt_cmd_list */
1619         struct list_head cmd_mgmt_cmd_list_entry;
1620 };
1621
1622 struct scst_mgmt_cmd {
1623         /* List entry for *_mgmt_cmd_list */
1624         struct list_head mgmt_cmd_list_entry;
1625
1626         struct scst_session *sess;
1627
1628         /* Mgmt cmd state, one of SCST_MCMD_STATE_* constants */
1629         int state;
1630
1631         int fn;
1632
1633         unsigned int completed:1;       /* set, if the mcmd is completed */
1634         /* Set if device(s) should be unblocked after mcmd's finish */
1635         unsigned int needs_unblocking:1;
1636         unsigned int lun_set:1;         /* set, if lun field is valid */
1637         unsigned int cmd_sn_set:1;      /* set, if cmd_sn field is valid */
1638         /* set, if scst_mgmt_affected_cmds_done was called */
1639         unsigned int affected_cmds_done_called:1;
1640
1641         /*
1642          * Number of commands to finish before sending response,
1643          * protected by scst_mcmd_lock
1644          */
1645         int cmd_finish_wait_count;
1646
1647         /*
1648          * Number of commands to complete (done) before resetting reservation,
1649          * protected by scst_mcmd_lock
1650          */
1651         int cmd_done_wait_count;
1652
1653         /* Number of completed commands, protected by scst_mcmd_lock */
1654         int completed_cmd_count;
1655
1656         uint64_t lun;   /* LUN for this mgmt cmd */
1657         /* or (and for iSCSI) */
1658         uint64_t tag;   /* tag of the corresponding cmd */
1659
1660         uint32_t cmd_sn; /* affected command's highest SN */
1661
1662         /* corresponding cmd (to be aborted, found by tag) */
1663         struct scst_cmd *cmd_to_abort;
1664
1665         /* corresponding device for this mgmt cmd (found by lun) */
1666         struct scst_tgt_dev *mcmd_tgt_dev;
1667
1668         /* completition status, one of the SCST_MGMT_STATUS_* constants */
1669         int status;
1670
1671         /* Used for storage of target driver private stuff */
1672         void *tgt_priv;
1673 };
1674
1675 struct scst_device {
1676         struct scst_dev_type *handler;  /* corresponding dev handler */
1677
1678         struct scst_mem_lim dev_mem_lim;
1679
1680         unsigned short type;    /* SCSI type of the device */
1681
1682         /*************************************************************
1683          ** Dev's flags. Updates serialized by dev_lock or suspended
1684          ** activity
1685          *************************************************************/
1686
1687         /* Set if dev is RESERVED */
1688         unsigned short dev_reserved:1;
1689
1690         /* Set if double reset UA is possible */
1691         unsigned short dev_double_ua_possible:1;
1692
1693         /* If set, dev is read only */
1694         unsigned short rd_only:1;
1695
1696         /**************************************************************/
1697
1698         /*************************************************************
1699          ** Dev's control mode page related values. Updates serialized
1700          ** by scst_block_dev(). It's long to not interfere with the
1701          ** above flags.
1702          *************************************************************/
1703
1704         unsigned long queue_alg:4;
1705         unsigned long tst:3;
1706         unsigned long tas:1;
1707         unsigned long swp:1;
1708         unsigned long d_sense:1;
1709
1710         /*
1711          * Set if device implements own ordered commands management. If not set
1712          * and queue_alg is SCST_CONTR_MODE_QUEUE_ALG_RESTRICTED_REORDER,
1713          * expected_sn will be incremented only after commands finished.
1714          */
1715         unsigned long has_own_order_mgmt:1;
1716
1717         /**************************************************************/
1718
1719         /* Used for storage of dev handler private stuff */
1720         void *dh_priv;
1721
1722 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
1723         /* Used to translate SCSI's cmd to SCST's cmd */
1724         struct gendisk *rq_disk;
1725 #endif
1726
1727         /* Corresponding real SCSI device, could be NULL for virtual devices */
1728         struct scsi_device *scsi_dev;
1729
1730         /* Pointer to lists of commands with the lock */
1731         struct scst_cmd_lists *p_cmd_lists;
1732
1733         /* Lists of commands with lock, if dedicated threads are used */
1734         struct scst_cmd_lists cmd_lists;
1735
1736         /* Per-device dedicated IO context */
1737         struct io_context *dev_io_ctx;
1738
1739         /* How many cmds alive on this dev */
1740         atomic_t dev_cmd_count;
1741
1742         /* How many write cmds alive on this dev. Temporary, ToDo */
1743         atomic_t write_cmd_count;
1744
1745         spinlock_t dev_lock;            /* device lock */
1746
1747         /*
1748          * How many times device was blocked for new cmds execution.
1749          * Protected by dev_lock
1750          */
1751         int block_count;
1752
1753         /*
1754          * How many there are "on_dev" commands, i.e. ones those are being
1755          * executed by the underlying SCSI/virtual device.
1756          */
1757         atomic_t on_dev_count;
1758
1759         struct list_head blocked_cmd_list; /* protected by dev_lock */
1760
1761         /* Used to wait for requested amount of "on_dev" commands */
1762         wait_queue_head_t on_dev_waitQ;
1763
1764         /* A list entry used during TM, protected by scst_mutex */
1765         struct list_head tm_dev_list_entry;
1766
1767         /* Virtual device internal ID */
1768         int virt_id;
1769
1770         /* Pointer to virtual device name, for convenience only */
1771         char *virt_name;
1772
1773         /* List entry in global devices list */
1774         struct list_head dev_list_entry;
1775
1776         /*
1777          * List of tgt_dev's, one per session, protected by scst_mutex or
1778          * dev_lock for reads and both for writes
1779          */
1780         struct list_head dev_tgt_dev_list;
1781
1782         /* List of acg_dev's, one per acg, protected by scst_mutex */
1783         struct list_head dev_acg_dev_list;
1784
1785         /* List of dedicated threads, protected by scst_mutex */
1786         struct list_head threads_list;
1787
1788         /* Device number */
1789         int dev_num;
1790
1791         /* Set if tgt_kobj was initialized */
1792         unsigned int dev_kobj_initialized:1;
1793
1794         struct kobject dev_kobj; /* kobject for this struct */
1795         struct kobject *dev_exp_kobj; /* exported groups */
1796
1797         /* Export number in the dev's sysfs list. Protected by scst_mutex */
1798         int dev_exported_lun_num;
1799 };
1800
1801 /*
1802  * Used to store threads local tgt_dev specific data
1803  */
1804 struct scst_thr_data_hdr {
1805         /* List entry in tgt_dev->thr_data_list */
1806         struct list_head thr_data_list_entry;
1807         struct task_struct *owner_thr; /* the owner thread */
1808         atomic_t ref;
1809         /* Function that will be called on the tgt_dev destruction */
1810         void (*free_fn) (struct scst_thr_data_hdr *data);
1811 };
1812
1813 /*
1814  * Used to store per-session specific device information
1815  */
1816 struct scst_tgt_dev {
1817         /* List entry in sess->sess_tgt_dev_list_hash */
1818         struct list_head sess_tgt_dev_list_entry;
1819
1820         struct scst_device *dev; /* to save extra dereferences */
1821         uint64_t lun;            /* to save extra dereferences */
1822
1823         gfp_t gfp_mask;
1824         struct sgv_pool *pool;
1825         int max_sg_cnt;
1826
1827         unsigned long tgt_dev_flags;    /* tgt_dev's async flags */
1828
1829         /* Used for storage of dev handler private stuff */
1830         void *dh_priv;
1831
1832         /* How many cmds alive on this dev in this session */
1833         atomic_t tgt_dev_cmd_count;
1834
1835         /*
1836          * Used to execute cmd's in order of arrival, honoring SCSI task
1837          * attributes.
1838          *
1839          * Protected by sn_lock, except expected_sn, which is protected by
1840          * itself. Curr_sn must have the same size as expected_sn to
1841          * overflow simultaneously.
1842          */
1843         int def_cmd_count;
1844         spinlock_t sn_lock;
1845         unsigned long expected_sn;
1846         unsigned long curr_sn;
1847         int hq_cmd_count;
1848         struct list_head deferred_cmd_list;
1849         struct list_head skipped_sn_list;
1850
1851         /*
1852          * Set if the prev cmd was ORDERED. Size must allow unprotected
1853          * modifications independant to the neighbour fields.
1854          */
1855         unsigned long prev_cmd_ordered;
1856
1857         int num_free_sn_slots; /* if it's <0, then all slots are busy */
1858         atomic_t *cur_sn_slot;
1859         atomic_t sn_slots[15];
1860
1861         /* List of scst_thr_data_hdr and lock */
1862         spinlock_t thr_data_lock;
1863         struct list_head thr_data_list;
1864
1865         /* Per-(device, session) dedicated IO context */
1866         struct io_context *tgt_dev_io_ctx;
1867
1868         spinlock_t tgt_dev_lock;        /* per-session device lock */
1869
1870         /* List of UA's for this device, protected by tgt_dev_lock */
1871         struct list_head UA_list;
1872
1873         struct scst_session *sess;      /* corresponding session */
1874         struct scst_acg_dev *acg_dev;   /* corresponding acg_dev */
1875
1876         /* List entry in dev->dev_tgt_dev_list */
1877         struct list_head dev_tgt_dev_list_entry;
1878
1879         /* Internal tmp list entry */
1880         struct list_head extra_tgt_dev_list_entry;
1881
1882         /* Set if INQUIRY DATA HAS CHANGED UA is needed */
1883         unsigned int inq_changed_ua_needed:1;
1884
1885         /*
1886          * Stored Unit Attention sense and its length for possible
1887          * subsequent REQUEST SENSE. Both protected by tgt_dev_lock.
1888          */
1889         unsigned short tgt_dev_valid_sense_len;
1890         uint8_t tgt_dev_sense[SCST_SENSE_BUFFERSIZE];
1891
1892 #ifdef CONFIG_SCST_MEASURE_LATENCY
1893         /*
1894          * Must be the last to allow to work with drivers who don't know
1895          * about this config time option.
1896          *
1897          * Protected by sess->lat_lock.
1898          */
1899         uint64_t scst_time, tgt_time, dev_time;
1900         unsigned int processed_cmds;
1901         struct scst_ext_latency_stat dev_latency_stat[SCST_LATENCY_STATS_NUM];
1902 #endif
1903 };
1904
1905 /*
1906  * Used to store ACG-specific device information, like LUN
1907  */
1908 struct scst_acg_dev {
1909         struct scst_device *dev; /* corresponding device */
1910
1911         uint64_t lun; /* device's LUN in this acg */
1912
1913         /* If set, the corresponding LU is read only */
1914         unsigned int rd_only:1;
1915
1916         /* Set if acg_dev_kobj was initialized */
1917         unsigned int acg_dev_kobj_initialized:1;
1918
1919         struct scst_acg *acg; /* parent acg */
1920
1921         /* List entry in dev->dev_acg_dev_list */
1922         struct list_head dev_acg_dev_list_entry;
1923
1924         /* List entry in acg->acg_dev_list */
1925         struct list_head acg_dev_list_entry;
1926
1927         /* kobject for this structure */
1928         struct kobject acg_dev_kobj;
1929 };
1930
1931 /*
1932  * ACG - access control group. Used to store group related
1933  * control information.
1934  */
1935 struct scst_acg {
1936         /* List of acg_dev's in this acg, protected by scst_mutex */
1937         struct list_head acg_dev_list;
1938
1939         /* List of attached sessions, protected by scst_mutex */
1940         struct list_head acg_sess_list;
1941
1942         /* List of attached acn's, protected by scst_mutex */
1943         struct list_head acn_list;
1944
1945         /* List entry in scst_acg_list */
1946         struct list_head scst_acg_list_entry;
1947
1948         /* Name of this acg */
1949         const char *acg_name;
1950
1951 #ifdef CONFIG_SCST_PROC
1952         /* The pointer to the /proc directory entry */
1953         struct proc_dir_entry *acg_proc_root;
1954 #endif
1955 };
1956
1957 /*
1958  * ACN - access control name. Used to store names, by which
1959  * incoming sessions will be assigned to appropriate ACG.
1960  */
1961 struct scst_acn {
1962         /* Initiator's name */
1963         const char *name;
1964         /* List entry in acg->acn_list */
1965         struct list_head acn_list_entry;
1966 };
1967
1968 /*
1969  * Used to store per-session UNIT ATTENTIONs
1970  */
1971 struct scst_tgt_dev_UA {
1972         /* List entry in tgt_dev->UA_list */
1973         struct list_head UA_list_entry;
1974
1975         /* Set if UA is global for session */
1976         unsigned short global_UA:1;
1977
1978         /* Unit Attention valid sense len */
1979         unsigned short UA_valid_sense_len;
1980         /* Unit Attention sense buf */
1981         uint8_t UA_sense_buffer[SCST_SENSE_BUFFERSIZE];
1982 };
1983
1984 /* Used to deliver AENs */
1985 struct scst_aen {
1986         int event_fn; /* AEN fn */
1987
1988         struct scst_session *sess;      /* corresponding session */
1989         uint64_t lun;                   /* corresponding LUN in SCSI form */
1990
1991         union {
1992                 /* SCSI AEN data */
1993                 struct {
1994                         int aen_sense_len;
1995                         uint8_t aen_sense[SCST_STANDARD_SENSE_LEN];
1996                 };
1997         };
1998
1999         /* Keeps status of AEN's delivery to remote initiator */
2000         int delivery_status;
2001 };
2002
2003 #ifndef smp_mb__after_set_bit
2004 /* There is no smp_mb__after_set_bit() in the kernel */
2005 #define smp_mb__after_set_bit()                 smp_mb()
2006 #endif
2007
2008 /*
2009  * Registers target template
2010  * Returns 0 on success or appropriate error code otherwise
2011  */
2012 int __scst_register_target_template(struct scst_tgt_template *vtt,
2013         const char *version);
2014 static inline int scst_register_target_template(struct scst_tgt_template *vtt)
2015 {
2016         return __scst_register_target_template(vtt, SCST_INTERFACE_VERSION);
2017 }
2018
2019 /*
2020  * Unregisters target template
2021  */
2022 void scst_unregister_target_template(struct scst_tgt_template *vtt);
2023
2024 /*
2025  * Registers and returns target adapter
2026  * Returns new target structure on success or NULL otherwise.
2027  *
2028  * If parameter "target_name" isn't NULL, then security group with name
2029  * "Default_##target_name", if created, will be used as the default
2030  * instead of "Default" one for all initiators not assigned to any other group.
2031  */
2032 struct scst_tgt *scst_register(struct scst_tgt_template *vtt,
2033         const char *target_name);
2034
2035 /*
2036  * Unregisters target adapter
2037  */
2038 void scst_unregister(struct scst_tgt *tgt);
2039
2040 /*
2041  * Registers and returns a session
2042  *
2043  * Returns new session on success or NULL otherwise
2044  *
2045  * Parameters:
2046  *   tgt    - target
2047  *   atomic - true, if the function called in the atomic context. If false,
2048  *      this function will block until the session registration is completed.
2049  *   initiator_name - remote initiator's name, any NULL-terminated string,
2050  *      e.g. iSCSI name, which used as the key to found appropriate access
2051  *      control group. Could be NULL, then the default target's LUNs are used.
2052  *   data - any target driver supplied data
2053  *   result_fn - pointer to the function that will be
2054  *      asynchronously called when session initialization finishes.
2055  *      Can be NULL. Parameters:
2056  *       - sess - session
2057  *       - data - target driver supplied to scst_register_session() data
2058  *       - result - session initialization result, 0 on success or
2059  *                  appropriate error code otherwise
2060  *
2061  * Note: A session creation and initialization is a complex task,
2062  *       which requires sleeping state, so it can't be fully done
2063  *       in interrupt context. Therefore the "bottom half" of it, if
2064  *       scst_register_session() is called from atomic context, will be
2065  *       done in SCST thread context. In this case scst_register_session()
2066  *       will return not completely initialized session, but the target
2067  *       driver can supply commands to this session via scst_rx_cmd().
2068  *       Those commands processing will be delayed inside SCST until
2069  *       the session initialization is finished, then their processing
2070  *       will be restarted. The target driver will be notified about
2071  *       finish of the session initialization by function result_fn().
2072  *       On success the target driver could do nothing, but if the
2073  *       initialization fails, the target driver must ensure that
2074  *       no more new commands being sent or will be sent to SCST after
2075  *       result_fn() returns. All already sent to SCST commands for
2076  *       failed session will be returned in xmit_response() with BUSY status.
2077  *       In case of failure the driver shall call scst_unregister_session()
2078  *       inside result_fn(), it will NOT be called automatically.
2079  */
2080 struct scst_session *scst_register_session(struct scst_tgt *tgt, int atomic,
2081         const char *initiator_name, void *data,
2082         void (*result_fn) (struct scst_session *sess, void *data, int result));
2083
2084 /*
2085  * Unregisters a session.
2086  * Parameters:
2087  *   sess - session to be unregistered
2088  *   wait - if true, instructs to wait until all commands, which
2089  *      currently is being executed and belonged to the session, finished.
2090  *      Otherwise, target driver should be prepared to receive
2091  *      xmit_response() for the session's command after
2092  *      scst_unregister_session() returns.
2093  *   unreg_done_fn - pointer to the function that will be
2094  *      asynchronously called when the last session's command finishes and
2095  *      the session is about to be completely freed. Can be NULL.
2096  *      Parameter:
2097  *       - sess - session
2098  *
2099  * Notes:
2100  *
2101  * - All outstanding commands will be finished regularly. After
2102  *   scst_unregister_session() returned no new commands must be sent to
2103  *   SCST via scst_rx_cmd().
2104  *
2105  * - The caller must ensure that no scst_rx_cmd() or scst_rx_mgmt_fn_*() is
2106  *   called in paralell with scst_unregister_session().
2107  *
2108  * - Can be called before result_fn() of scst_register_session() called,
2109  *   i.e. during the session registration/initialization.
2110  *
2111  * - It is highly recommended to call scst_unregister_session() as soon as it
2112  *   gets clear that session will be unregistered and not to wait until all
2113  *   related commands finished. This function provides the wait functionality,
2114  *   but it also starts recovering stuck commands, if there are any.
2115  *   Otherwise, your target driver could wait for those commands forever.
2116  */
2117 void scst_unregister_session(struct scst_session *sess, int wait,
2118         void (*unreg_done_fn) (struct scst_session *sess));
2119
2120 /*
2121  * Registers dev handler driver
2122  * Returns 0 on success or appropriate error code otherwise
2123  */
2124 int __scst_register_dev_driver(struct scst_dev_type *dev_type,
2125         const char *version);
2126 static inline int scst_register_dev_driver(struct scst_dev_type *dev_type)
2127 {
2128         return __scst_register_dev_driver(dev_type, SCST_INTERFACE_VERSION);
2129 }
2130
2131 /*
2132  * Unregisters dev handler driver
2133  */
2134 void scst_unregister_dev_driver(struct scst_dev_type *dev_type);
2135
2136 /*
2137  * Registers dev handler driver for virtual devices (eg VDISK)
2138  * Returns 0 on success or appropriate error code otherwise
2139  */
2140 int __scst_register_virtual_dev_driver(struct scst_dev_type *dev_type,
2141         const char *version);
2142 static inline int scst_register_virtual_dev_driver(
2143         struct scst_dev_type *dev_type)
2144 {
2145         return __scst_register_virtual_dev_driver(dev_type,
2146                 SCST_INTERFACE_VERSION);
2147 }
2148
2149 /*
2150  * Unregisters dev handler driver for virtual devices
2151  */
2152 void scst_unregister_virtual_dev_driver(struct scst_dev_type *dev_type);
2153
2154 /*
2155  * Creates and sends new command to SCST.
2156  * Must not be called in parallel with scst_unregister_session() for the
2157  * same sess. Returns the command on success or NULL otherwise
2158  */
2159 struct scst_cmd *scst_rx_cmd(struct scst_session *sess,
2160         const uint8_t *lun, int lun_len, const uint8_t *cdb,
2161         int cdb_len, int atomic);
2162
2163 /*
2164  * Notifies SCST that the driver finished its part of the command
2165  * initialization, and the command is ready for execution.
2166  * The second argument sets preferred command execition context.
2167  * See SCST_CONTEXT_* constants for details.
2168  *
2169  * !!IMPORTANT!!
2170  *
2171  * If cmd->set_sn_on_restart_cmd not set, this function, as well as
2172  * scst_cmd_init_stage1_done() and scst_restart_cmd(), must not be
2173  * called simultaneously for the same session (more precisely,
2174  * for the same session/LUN, i.e. tgt_dev), i.e. they must be
2175  * somehow externally serialized. This is needed to have lock free fast path in
2176  * scst_cmd_set_sn(). For majority of targets those functions are naturally
2177  * serialized by the single source of commands. Only iSCSI immediate commands
2178  * with multiple connections per session seems to be an exception. For it, some
2179  * mutex/lock shall be used for the serialization.
2180  */
2181 void scst_cmd_init_done(struct scst_cmd *cmd,
2182         enum scst_exec_context pref_context);
2183
2184 /*
2185  * Notifies SCST that the driver finished the first stage of the command
2186  * initialization, and the command is ready for execution, but after
2187  * SCST done the command's preprocessing preprocessing_done() function
2188  * should be called. The second argument sets preferred command execition
2189  * context. See SCST_CONTEXT_* constants for details.
2190  *
2191  * See also scst_cmd_init_done() comment for the serialization requirements.
2192  */
2193 static inline void scst_cmd_init_stage1_done(struct scst_cmd *cmd,
2194         enum scst_exec_context pref_context, int set_sn)
2195 {
2196         cmd->preprocessing_only = 1;
2197         cmd->set_sn_on_restart_cmd = !set_sn;
2198         scst_cmd_init_done(cmd, pref_context);
2199 }
2200
2201 /*
2202  * Notifies SCST that the driver finished its part of the command's
2203  * preprocessing and it is ready for further processing.
2204  * The second argument sets data receiving completion status
2205  * (see SCST_PREPROCESS_STATUS_* constants for details)
2206  * The third argument sets preferred command execition context
2207  * (see SCST_CONTEXT_* constants for details).
2208  *
2209  * See also scst_cmd_init_done() comment for the serialization requirements.
2210  */
2211 void scst_restart_cmd(struct scst_cmd *cmd, int status,
2212         enum scst_exec_context pref_context);
2213
2214 /*
2215  * Notifies SCST that the driver received all the necessary data
2216  * and the command is ready for further processing.
2217  * The second argument sets data receiving completion status
2218  * (see SCST_RX_STATUS_* constants for details)
2219  * The third argument sets preferred command execition context
2220  * (see SCST_CONTEXT_* constants for details)
2221  */
2222 void scst_rx_data(struct scst_cmd *cmd, int status,
2223         enum scst_exec_context pref_context);
2224
2225 /*
2226  * Notifies SCST that the driver sent the response and the command
2227  * can be freed now. Don't forget to set the delivery status, if it
2228  * isn't success, using scst_set_delivery_status() before calling
2229  * this function. The third argument sets preferred command execition
2230  * context (see SCST_CONTEXT_* constants for details)
2231  */
2232 void scst_tgt_cmd_done(struct scst_cmd *cmd,
2233         enum scst_exec_context pref_context);
2234
2235 /*
2236  * Creates new management command sends it for execution.
2237  * Must not be called in parallel with scst_unregister_session() for the
2238  * same sess. Returns 0 for success, error code otherwise.
2239  */
2240 int scst_rx_mgmt_fn(struct scst_session *sess,
2241         const struct scst_rx_mgmt_params *params);
2242
2243 /*
2244  * Creates new management command using tag and sends it for execution.
2245  * Can be used for SCST_ABORT_TASK only.
2246  * Must not be called in parallel with scst_unregister_session() for the
2247  * same sess. Returns 0 for success, error code otherwise.
2248  *
2249  * Obsolete in favor of scst_rx_mgmt_fn()
2250  */
2251 static inline int scst_rx_mgmt_fn_tag(struct scst_session *sess, int fn,
2252         uint64_t tag, int atomic, void *tgt_priv)
2253 {
2254         struct scst_rx_mgmt_params params;
2255
2256         BUG_ON(fn != SCST_ABORT_TASK);
2257
2258         memset(&params, 0, sizeof(params));
2259         params.fn = fn;
2260         params.tag = tag;
2261         params.tag_set = 1;
2262         params.atomic = atomic;
2263         params.tgt_priv = tgt_priv;
2264         return scst_rx_mgmt_fn(sess, &params);
2265 }
2266
2267 /*
2268  * Creates new management command using LUN and sends it for execution.
2269  * Currently can be used for any fn, except SCST_ABORT_TASK.
2270  * Must not be called in parallel with scst_unregister_session() for the
2271  * same sess. Returns 0 for success, error code otherwise.
2272  *
2273  * Obsolete in favor of scst_rx_mgmt_fn()
2274  */
2275 static inline int scst_rx_mgmt_fn_lun(struct scst_session *sess, int fn,
2276         const uint8_t *lun, int lun_len, int atomic, void *tgt_priv)
2277 {
2278         struct scst_rx_mgmt_params params;
2279
2280         BUG_ON(fn == SCST_ABORT_TASK);
2281
2282         memset(&params, 0, sizeof(params));
2283         params.fn = fn;
2284         params.lun = lun;
2285         params.lun_len = lun_len;
2286         params.lun_set = 1;
2287         params.atomic = atomic;
2288         params.tgt_priv = tgt_priv;
2289         return scst_rx_mgmt_fn(sess, &params);
2290 }
2291
2292 /*
2293  * Provides various info about command's CDB.
2294  *
2295  * Returns: 0 on success, <0 if command is unknown, >0 if command is invalid.
2296  */
2297 int scst_get_cdb_info(struct scst_cmd *cmd);
2298
2299 /*
2300  * Set error SCSI status in the command and prepares it for returning it
2301  */
2302 void scst_set_cmd_error_status(struct scst_cmd *cmd, int status);
2303
2304 /*
2305  * Set error in the command and fill the sense buffer
2306  */
2307 void scst_set_cmd_error(struct scst_cmd *cmd, int key, int asc, int ascq);
2308
2309 /*
2310  * Sets BUSY or TASK QUEUE FULL status
2311  */
2312 void scst_set_busy(struct scst_cmd *cmd);
2313
2314 /*
2315  * Check if sense in the sense buffer, if any, in the correct format. If not,
2316  * convert it to the correct format.
2317  */
2318 void scst_check_convert_sense(struct scst_cmd *cmd);
2319
2320 /*
2321  * Sets initial Unit Attention for sess, replacing default scst_sense_reset_UA
2322  */
2323 void scst_set_initial_UA(struct scst_session *sess, int key, int asc, int ascq);
2324
2325 /*
2326  * Notifies SCST core that dev changed its capacity
2327  */
2328 void scst_capacity_data_changed(struct scst_device *dev);
2329
2330 /*
2331  * Finds a command based on the supplied tag comparing it with one
2332  * that previously set by scst_cmd_set_tag().
2333  * Returns the command on success or NULL otherwise
2334  */
2335 struct scst_cmd *scst_find_cmd_by_tag(struct scst_session *sess, uint64_t tag);
2336
2337 /*
2338  * Finds a command based on user supplied data and comparision
2339  * callback function, that should return true, if the command is found.
2340  * Returns the command on success or NULL otherwise
2341  */
2342 struct scst_cmd *scst_find_cmd(struct scst_session *sess, void *data,
2343                                int (*cmp_fn) (struct scst_cmd *cmd,
2344                                               void *data));
2345
2346 /*
2347  * Translates SCST's data direction to DMA one from backend storage
2348  * perspective.
2349  */
2350 enum dma_data_direction scst_to_dma_dir(int scst_dir);
2351
2352 /*
2353  * Translates SCST data direction to DMA data direction from the perspective
2354  * of the target device.
2355  */
2356 enum dma_data_direction scst_to_tgt_dma_dir(int scst_dir);
2357
2358 /*
2359  * Returns true, if cmd's CDB is locally handled by SCST and 0 otherwise.
2360  * Dev handlers parse() and dev_done() not called for such commands.
2361  */
2362 static inline bool scst_is_cmd_local(struct scst_cmd *cmd)
2363 {
2364         return (cmd->op_flags & SCST_LOCAL_CMD) != 0;
2365 }
2366
2367 /* Returns true, if cmd can deliver UA */
2368 static inline bool scst_is_ua_command(struct scst_cmd *cmd)
2369 {
2370         return (cmd->op_flags & SCST_SKIP_UA) == 0;
2371 }
2372
2373 /*
2374  * Registers a virtual device.
2375  * Parameters:
2376  *   dev_type - the device's device handler
2377  *   dev_name - the new device name, NULL-terminated string. Must be uniq
2378  *              among all virtual devices in the system. The value isn't
2379  *              copied, only the reference is stored, so the value must
2380  *              remain valid during the device lifetime.
2381  * Returns assinged to the device ID on success, or negative value otherwise
2382  */
2383 int scst_register_virtual_device(struct scst_dev_type *dev_handler,
2384         const char *dev_name);
2385
2386 /*
2387  * Unegisters a virtual device.
2388  * Parameters:
2389  *   id - the device's ID, returned by the registration function
2390  */
2391 void scst_unregister_virtual_device(int id);
2392
2393 /*
2394  * Get/Set functions for tgt's sg_tablesize
2395  */
2396 static inline int scst_tgt_get_sg_tablesize(struct scst_tgt *tgt)
2397 {
2398         return tgt->sg_tablesize;
2399 }
2400
2401 static inline void scst_tgt_set_sg_tablesize(struct scst_tgt *tgt, int val)
2402 {
2403         tgt->sg_tablesize = val;
2404 }
2405
2406 /*
2407  * Get/Set functions for tgt's target private data
2408  */
2409 static inline void *scst_tgt_get_tgt_priv(struct scst_tgt *tgt)
2410 {
2411         return tgt->tgt_priv;
2412 }
2413
2414 static inline void scst_tgt_set_tgt_priv(struct scst_tgt *tgt, void *val)
2415 {
2416         tgt->tgt_priv = val;
2417 }
2418
2419 /*
2420  * Get/Set functions for session's target private data
2421  */
2422 static inline void *scst_sess_get_tgt_priv(struct scst_session *sess)
2423 {
2424         return sess->tgt_priv;
2425 }
2426
2427 static inline void scst_sess_set_tgt_priv(struct scst_session *sess,
2428                                               void *val)
2429 {
2430         sess->tgt_priv = val;
2431 }
2432
2433 /**
2434  * Returns TRUE if cmd is being executed in atomic context.
2435  *
2436  * Note: checkpatch will complain on the use of in_atomic() below. You can
2437  * safely ignore this warning since in_atomic() is used here only for debugging
2438  * purposes.
2439  */
2440 static inline int scst_cmd_atomic(struct scst_cmd *cmd)
2441 {
2442         int res = cmd->atomic;
2443 #ifdef CONFIG_SCST_EXTRACHECKS
2444         if (unlikely((in_atomic() || in_interrupt() || irqs_disabled()) &&
2445                      !res)) {
2446                 printk(KERN_ERR "ERROR: atomic context and non-atomic cmd\n");
2447                 dump_stack();
2448                 cmd->atomic = 1;
2449                 res = 1;
2450         }
2451 #endif
2452         return res;
2453 }
2454
2455 static inline enum scst_exec_context __scst_estimate_context(bool direct)
2456 {
2457         if (in_irq())
2458                 return SCST_CONTEXT_TASKLET;
2459         else if (irqs_disabled())
2460                 return SCST_CONTEXT_THREAD;
2461         else
2462                 return direct ? SCST_CONTEXT_DIRECT :
2463                                 SCST_CONTEXT_DIRECT_ATOMIC;
2464 }
2465
2466 static inline enum scst_exec_context scst_estimate_context(void)
2467 {
2468         return __scst_estimate_context(0);
2469 }
2470
2471 static inline enum scst_exec_context scst_estimate_context_direct(void)
2472 {
2473         return __scst_estimate_context(1);
2474 }
2475
2476 /* Returns cmd's CDB */
2477 static inline const uint8_t *scst_cmd_get_cdb(struct scst_cmd *cmd)
2478 {
2479         return cmd->cdb;
2480 }
2481
2482 /* Returns cmd's CDB length */
2483 static inline int scst_cmd_get_cdb_len(struct scst_cmd *cmd)
2484 {
2485         return cmd->cdb_len;
2486 }
2487
2488 /* Returns cmd's extended CDB */
2489 static inline const uint8_t *scst_cmd_get_ext_cdb(struct scst_cmd *cmd)
2490 {
2491         return cmd->ext_cdb;
2492 }
2493
2494 /* Returns cmd's extended CDB length */
2495 static inline int scst_cmd_get_ext_cdb_len(struct scst_cmd *cmd)
2496 {
2497         return cmd->ext_cdb_len;
2498 }
2499
2500 /* Sets cmd's extended CDB and its length */
2501 static inline void scst_cmd_set_ext_cdb(struct scst_cmd *cmd,
2502         uint8_t *ext_cdb, unsigned int ext_cdb_len)
2503 {
2504         cmd->ext_cdb = ext_cdb;
2505         cmd->ext_cdb_len = ext_cdb_len;
2506 }
2507
2508 /* Returns cmd's session */
2509 static inline struct scst_session *scst_cmd_get_session(struct scst_cmd *cmd)
2510 {
2511         return cmd->sess;
2512 }
2513
2514 /* Returns cmd's response data length */
2515 static inline int scst_cmd_get_resp_data_len(struct scst_cmd *cmd)
2516 {
2517         return cmd->resp_data_len;
2518 }
2519
2520 /* Returns if status should be sent for cmd */
2521 static inline int scst_cmd_get_is_send_status(struct scst_cmd *cmd)
2522 {
2523         return cmd->is_send_status;
2524 }
2525
2526 /*
2527  * Returns pointer to cmd's SG data buffer.
2528  *
2529  * Usage of this function is not recommended, use scst_get_buf_*()
2530  * family of functions instead.
2531  */
2532 static inline struct scatterlist *scst_cmd_get_sg(struct scst_cmd *cmd)
2533 {
2534         return cmd->sg;
2535 }
2536
2537 /*
2538  * Returns cmd's sg_cnt.
2539  *
2540  * Usage of this function is not recommended, use scst_get_buf_*()
2541  * family of functions instead.
2542  */
2543 static inline int scst_cmd_get_sg_cnt(struct scst_cmd *cmd)
2544 {
2545         return cmd->sg_cnt;
2546 }
2547
2548 /*
2549  * Returns cmd's data buffer length.
2550  *
2551  * In case if you need to iterate over data in the buffer, usage of
2552  * this function is not recommended, use scst_get_buf_*()
2553  * family of functions instead.
2554  */
2555 static inline unsigned int scst_cmd_get_bufflen(struct scst_cmd *cmd)
2556 {
2557         return cmd->bufflen;
2558 }
2559
2560 /*
2561  * Returns pointer to cmd's bidirectional in (WRITE) SG data buffer.
2562  *
2563  * Usage of this function is not recommended, use scst_get_in_buf_*()
2564  * family of functions instead.
2565  */
2566 static inline struct scatterlist *scst_cmd_get_in_sg(struct scst_cmd *cmd)
2567 {
2568         return cmd->in_sg;
2569 }
2570
2571 /*
2572  * Returns cmd's bidirectional in (WRITE) sg_cnt.
2573  *
2574  * Usage of this function is not recommended, use scst_get_in_buf_*()
2575  * family of functions instead.
2576  */
2577 static inline int scst_cmd_get_in_sg_cnt(struct scst_cmd *cmd)
2578 {
2579         return cmd->in_sg_cnt;
2580 }
2581
2582 /*
2583  * Returns cmd's bidirectional in (WRITE) data buffer length.
2584  *
2585  * In case if you need to iterate over data in the buffer, usage of
2586  * this function is not recommended, use scst_get_in_buf_*()
2587  * family of functions instead.
2588  */
2589 static inline unsigned int scst_cmd_get_in_bufflen(struct scst_cmd *cmd)
2590 {
2591         return cmd->in_bufflen;
2592 }
2593
2594 /* Returns pointer to cmd's target's SG data buffer */
2595 static inline struct scatterlist *scst_cmd_get_tgt_sg(struct scst_cmd *cmd)
2596 {
2597         return cmd->tgt_sg;
2598 }
2599
2600 /* Returns cmd's target's sg_cnt */
2601 static inline int scst_cmd_get_tgt_sg_cnt(struct scst_cmd *cmd)
2602 {
2603         return cmd->tgt_sg_cnt;
2604 }
2605
2606 /* Sets cmd's target's SG data buffer */
2607 static inline void scst_cmd_set_tgt_sg(struct scst_cmd *cmd,
2608         struct scatterlist *sg, int sg_cnt)
2609 {
2610         cmd->tgt_sg = sg;
2611         cmd->tgt_sg_cnt = sg_cnt;
2612         cmd->tgt_data_buf_alloced = 1;
2613 }
2614
2615 /* Returns pointer to cmd's target's IN SG data buffer */
2616 static inline struct scatterlist *scst_cmd_get_in_tgt_sg(struct scst_cmd *cmd)
2617 {
2618         return cmd->tgt_in_sg;
2619 }
2620
2621 /* Returns cmd's target's IN sg_cnt */
2622 static inline int scst_cmd_get_tgt_in_sg_cnt(struct scst_cmd *cmd)
2623 {
2624         return cmd->tgt_in_sg_cnt;
2625 }
2626
2627 /* Sets cmd's target's IN SG data buffer */
2628 static inline void scst_cmd_set_tgt_in_sg(struct scst_cmd *cmd,
2629         struct scatterlist *sg, int sg_cnt)
2630 {
2631         WARN_ON(!cmd->tgt_data_buf_alloced);
2632
2633         cmd->tgt_in_sg = sg;
2634         cmd->tgt_in_sg_cnt = sg_cnt;
2635 }
2636
2637 /* Returns cmd's data direction */
2638 static inline scst_data_direction scst_cmd_get_data_direction(
2639         struct scst_cmd *cmd)
2640 {
2641         return cmd->data_direction;
2642 }
2643
2644 /* Returns cmd's status byte from host device */
2645 static inline uint8_t scst_cmd_get_status(struct scst_cmd *cmd)
2646 {
2647         return cmd->status;
2648 }
2649
2650 /* Returns cmd's status from host adapter itself */
2651 static inline uint8_t scst_cmd_get_msg_status(struct scst_cmd *cmd)
2652 {
2653         return cmd->msg_status;
2654 }
2655
2656 /* Returns cmd's status set by low-level driver to indicate its status */
2657 static inline uint8_t scst_cmd_get_host_status(struct scst_cmd *cmd)
2658 {
2659         return cmd->host_status;
2660 }
2661
2662 /* Returns cmd's status set by SCSI mid-level */
2663 static inline uint8_t scst_cmd_get_driver_status(struct scst_cmd *cmd)
2664 {
2665         return cmd->driver_status;
2666 }
2667
2668 /* Returns pointer to cmd's sense buffer */
2669 static inline uint8_t *scst_cmd_get_sense_buffer(struct scst_cmd *cmd)
2670 {
2671         return cmd->sense;
2672 }
2673
2674 /* Returns cmd's valid sense length */
2675 static inline int scst_cmd_get_sense_buffer_len(struct scst_cmd *cmd)
2676 {
2677         return cmd->sense_valid_len;
2678 }
2679
2680 /*
2681  * Get/Set functions for cmd's target SN
2682  */
2683 static inline uint64_t scst_cmd_get_tag(struct scst_cmd *cmd)
2684 {
2685         return cmd->tag;
2686 }
2687
2688 static inline void scst_cmd_set_tag(struct scst_cmd *cmd, uint64_t tag)
2689 {
2690         cmd->tag = tag;
2691 }
2692
2693 /*
2694  * Get/Set functions for cmd's target private data.
2695  * Variant with *_lock must be used if target driver uses
2696  * scst_find_cmd() to avoid race with it, except inside scst_find_cmd()'s
2697  * callback, where lock is already taken.
2698  */
2699 static inline void *scst_cmd_get_tgt_priv(struct scst_cmd *cmd)
2700 {
2701         return cmd->tgt_priv;
2702 }
2703
2704 static inline void scst_cmd_set_tgt_priv(struct scst_cmd *cmd, void *val)
2705 {
2706         cmd->tgt_priv = val;
2707 }
2708
2709 void *scst_cmd_get_tgt_priv_lock(struct scst_cmd *cmd);
2710 void scst_cmd_set_tgt_priv_lock(struct scst_cmd *cmd, void *val);
2711
2712 /*
2713  * Get/Set functions for tgt_need_alloc_data_buf flag
2714  */
2715 static inline int scst_cmd_get_tgt_need_alloc_data_buf(struct scst_cmd *cmd)
2716 {
2717         return cmd->tgt_need_alloc_data_buf;
2718 }
2719
2720 static inline void scst_cmd_set_tgt_need_alloc_data_buf(struct scst_cmd *cmd)
2721 {
2722         cmd->tgt_need_alloc_data_buf = 1;
2723 }
2724
2725 /*
2726  * Get/Set functions for tgt_data_buf_alloced flag
2727  */
2728 static inline int scst_cmd_get_tgt_data_buff_alloced(struct scst_cmd *cmd)
2729 {
2730         return cmd->tgt_data_buf_alloced;
2731 }
2732
2733 static inline void scst_cmd_set_tgt_data_buff_alloced(struct scst_cmd *cmd)
2734 {
2735         cmd->tgt_data_buf_alloced = 1;
2736 }
2737
2738 /*
2739  * Get/Set functions for dh_data_buf_alloced flag
2740  */
2741 static inline int scst_cmd_get_dh_data_buff_alloced(struct scst_cmd *cmd)
2742 {
2743         return cmd->dh_data_buf_alloced;
2744 }
2745
2746 static inline void scst_cmd_set_dh_data_buff_alloced(struct scst_cmd *cmd)
2747 {
2748         cmd->dh_data_buf_alloced = 1;
2749 }
2750
2751 /*
2752  * Get/Set functions for no_sgv flag
2753  */
2754 static inline int scst_cmd_get_no_sgv(struct scst_cmd *cmd)
2755 {
2756         return cmd->no_sgv;
2757 }
2758
2759 static inline void scst_cmd_set_no_sgv(struct scst_cmd *cmd)
2760 {
2761         cmd->no_sgv = 1;
2762 }
2763
2764 /*
2765  * Get/Set functions for tgt_sn
2766  */
2767 static inline int scst_cmd_get_tgt_sn(struct scst_cmd *cmd)
2768 {
2769         BUG_ON(!cmd->tgt_sn_set);
2770         return cmd->tgt_sn;
2771 }
2772
2773 static inline void scst_cmd_set_tgt_sn(struct scst_cmd *cmd, uint32_t tgt_sn)
2774 {
2775         cmd->tgt_sn_set = 1;
2776         cmd->tgt_sn = tgt_sn;
2777 }
2778
2779 /*
2780  * Returns 1 if the cmd was aborted, so its status is invalid and no
2781  * reply shall be sent to the remote initiator. A target driver should
2782  * only clear internal resources, associated with cmd.
2783  */
2784 static inline int scst_cmd_aborted(struct scst_cmd *cmd)
2785 {
2786         return test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags) &&
2787                 !test_bit(SCST_CMD_ABORTED_OTHER, &cmd->cmd_flags);
2788 }
2789
2790 /* Returns sense data format for cmd's dev */
2791 static inline bool scst_get_cmd_dev_d_sense(struct scst_cmd *cmd)
2792 {
2793         return (cmd->dev != NULL) ? cmd->dev->d_sense : 0;
2794 }
2795
2796 /*
2797  * Get/Set functions for expected data direction, transfer length
2798  * and its validity flag
2799  */
2800 static inline int scst_cmd_is_expected_set(struct scst_cmd *cmd)
2801 {
2802         return cmd->expected_values_set;
2803 }
2804
2805 static inline scst_data_direction scst_cmd_get_expected_data_direction(
2806         struct scst_cmd *cmd)
2807 {
2808         return cmd->expected_data_direction;
2809 }
2810
2811 static inline int scst_cmd_get_expected_transfer_len(
2812         struct scst_cmd *cmd)
2813 {
2814         return cmd->expected_transfer_len;
2815 }
2816
2817 static inline int scst_cmd_get_expected_in_transfer_len(
2818         struct scst_cmd *cmd)
2819 {
2820         return cmd->expected_in_transfer_len;
2821 }
2822
2823 static inline void scst_cmd_set_expected(struct scst_cmd *cmd,
2824         scst_data_direction expected_data_direction,
2825         int expected_transfer_len)
2826 {
2827         cmd->expected_data_direction = expected_data_direction;
2828         cmd->expected_transfer_len = expected_transfer_len;
2829         cmd->expected_values_set = 1;
2830 }
2831
2832 static inline void scst_cmd_set_expected_in_transfer_len(struct scst_cmd *cmd,
2833         int expected_in_transfer_len)
2834 {
2835         WARN_ON(!cmd->expected_values_set);
2836         cmd->expected_in_transfer_len = expected_in_transfer_len;
2837 }
2838
2839 /*
2840  * Get/clear functions for cmd's may_need_dma_sync
2841  */
2842 static inline int scst_get_may_need_dma_sync(struct scst_cmd *cmd)
2843 {
2844         return cmd->may_need_dma_sync;
2845 }
2846
2847 static inline void scst_clear_may_need_dma_sync(struct scst_cmd *cmd)
2848 {
2849         cmd->may_need_dma_sync = 0;
2850 }
2851
2852 /*
2853  * Get/set functions for cmd's delivery_status. It is one of
2854  * SCST_CMD_DELIVERY_* constants. It specifies the status of the
2855  * command's delivery to initiator.
2856  */
2857 static inline int scst_get_delivery_status(struct scst_cmd *cmd)
2858 {
2859         return cmd->delivery_status;
2860 }
2861
2862 static inline void scst_set_delivery_status(struct scst_cmd *cmd,
2863         int delivery_status)
2864 {
2865         cmd->delivery_status = delivery_status;
2866 }
2867
2868 /*
2869  * Get/Set function for mgmt cmd's target private data
2870  */
2871 static inline void *scst_mgmt_cmd_get_tgt_priv(struct scst_mgmt_cmd *mcmd)
2872 {
2873         return mcmd->tgt_priv;
2874 }
2875
2876 static inline void scst_mgmt_cmd_set_tgt_priv(struct scst_mgmt_cmd *mcmd,
2877         void *val)
2878 {
2879         mcmd->tgt_priv = val;
2880 }
2881
2882 /* Returns mgmt cmd's completition status (SCST_MGMT_STATUS_* constants) */
2883 static inline int scst_mgmt_cmd_get_status(struct scst_mgmt_cmd *mcmd)
2884 {
2885         return mcmd->status;
2886 }
2887
2888 /* Returns mgmt cmd's TM fn */
2889 static inline int scst_mgmt_cmd_get_fn(struct scst_mgmt_cmd *mcmd)
2890 {
2891         return mcmd->fn;
2892 }
2893
2894 /*
2895  * Called by dev handler's task_mgmt_fn() to notify SCST core that mcmd
2896  * is going to complete asynchronously.
2897  */
2898 void scst_prepare_async_mcmd(struct scst_mgmt_cmd *mcmd);
2899
2900 /*
2901  * Called by dev handler to notify SCST core that async. mcmd is completed
2902  * with status "status".
2903  */
2904 void scst_async_mcmd_completed(struct scst_mgmt_cmd *mcmd, int status);
2905
2906 /* Returns AEN's fn */
2907 static inline int scst_aen_get_event_fn(struct scst_aen *aen)
2908 {
2909         return aen->event_fn;
2910 }
2911
2912 /* Returns AEN's session */
2913 static inline struct scst_session *scst_aen_get_sess(struct scst_aen *aen)
2914 {
2915         return aen->sess;
2916 }
2917
2918 /* Returns AEN's LUN */
2919 static inline uint64_t scst_aen_get_lun(struct scst_aen *aen)
2920 {
2921         return aen->lun;
2922 }
2923
2924 /* Returns SCSI AEN's sense */
2925 static inline const uint8_t *scst_aen_get_sense(struct scst_aen *aen)
2926 {
2927         return aen->aen_sense;
2928 }
2929
2930 /* Returns SCSI AEN's sense length */
2931 static inline int scst_aen_get_sense_len(struct scst_aen *aen)
2932 {
2933         return aen->aen_sense_len;
2934 }
2935
2936 /*
2937  * Get/set functions for AEN's delivery_status. It is one of
2938  * SCST_AEN_RES_* constants. It specifies the status of the
2939  * command's delivery to initiator.
2940  */
2941 static inline int scst_get_aen_delivery_status(struct scst_aen *aen)
2942 {
2943         return aen->delivery_status;
2944 }
2945
2946 static inline void scst_set_aen_delivery_status(struct scst_aen *aen,
2947         int status)
2948 {
2949         aen->delivery_status = status;
2950 }
2951
2952 /*
2953  * Notifies SCST that the driver has sent the AEN and it
2954  * can be freed now. Don't forget to set the delivery status, if it
2955  * isn't success, using scst_set_aen_delivery_status() before calling
2956  * this function.
2957  */
2958 void scst_aen_done(struct scst_aen *aen);
2959
2960 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
2961
2962 /*
2963  * The macro's sg_page(), sg_virt(), sg_init_table(), sg_assign_page() and
2964  * sg_set_page() have been introduced in the 2.6.24 kernel. The definitions
2965  * below are backports of the 2.6.24 macro's for older kernels. There is one
2966  * exception however: when compiling SCST on a system with a pre-2.6.24 kernel
2967  * (e.g. RHEL 5.x) where the OFED kernel headers have been installed, do not
2968  * define the backported macro's because OFED has already defined these.
2969  */
2970
2971 #ifndef __BACKPORT_LINUX_SCATTERLIST_H_TO_2_6_23__
2972
2973 static inline struct page *sg_page(struct scatterlist *sg)
2974 {
2975         return sg->page;
2976 }
2977
2978 static inline void *sg_virt(struct scatterlist *sg)
2979 {
2980         return page_address(sg_page(sg)) + sg->offset;
2981 }
2982
2983 static inline void sg_init_table(struct scatterlist *sgl, unsigned int nents)
2984 {
2985         memset(sgl, 0, sizeof(*sgl) * nents);
2986 }
2987
2988 static inline void sg_assign_page(struct scatterlist *sg, struct page *page)
2989 {
2990         sg->page = page;
2991 }
2992
2993 static inline void sg_set_page(struct scatterlist *sg, struct page *page,
2994                                unsigned int len, unsigned int offset)
2995 {
2996         sg_assign_page(sg, page);
2997         sg->offset = offset;
2998         sg->length = len;
2999 }
3000
3001 static inline struct scatterlist *sg_next(struct scatterlist *sg)
3002 {
3003         sg++;
3004         return sg;
3005 }
3006
3007 #endif /* __BACKPORT_LINUX_SCATTERLIST_H_TO_2_6_23__ */
3008
3009 #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24) */
3010
3011 static inline void sg_clear(struct scatterlist *sg)
3012 {
3013         memset(sg, 0, sizeof(*sg));
3014 #ifdef CONFIG_DEBUG_SG
3015         sg->sg_magic = SG_MAGIC;
3016 #endif
3017 }
3018
3019 enum scst_sg_copy_dir {
3020         SCST_SG_COPY_FROM_TARGET,
3021         SCST_SG_COPY_TO_TARGET
3022 };
3023
3024 /*
3025  * Copies data between cmd->tgt_sg and cmd->sg in direction defined by
3026  * copy_dir parameter.
3027  */
3028 void scst_copy_sg(struct scst_cmd *cmd, enum scst_sg_copy_dir copy_dir);
3029
3030 /*
3031  * Functions for access to the commands data (SG) buffer,
3032  * including HIGHMEM environment. Should be used instead of direct
3033  * access. Returns the mapped buffer length for success, 0 for EOD,
3034  * negative error code otherwise.
3035  *
3036  * "Buf" argument returns the mapped buffer
3037  *
3038  * The "put" function unmaps the buffer.
3039  */
3040 static inline int __scst_get_buf(struct scst_cmd *cmd, struct scatterlist *sg,
3041         int sg_cnt, uint8_t **buf)
3042 {
3043         int res = 0;
3044         int i = cmd->get_sg_buf_entry_num;
3045
3046         *buf = NULL;
3047
3048         if ((i >= sg_cnt) || unlikely(sg == NULL))
3049                 goto out;
3050
3051         *buf = page_address(sg_page(&sg[i]));
3052         *buf += sg[i].offset;
3053
3054         res = sg[i].length;
3055         cmd->get_sg_buf_entry_num++;
3056
3057 out:
3058         return res;
3059 }
3060
3061 static inline int scst_get_buf_first(struct scst_cmd *cmd, uint8_t **buf)
3062 {
3063         cmd->get_sg_buf_entry_num = 0;
3064         cmd->may_need_dma_sync = 1;
3065         return __scst_get_buf(cmd, cmd->sg, cmd->sg_cnt, buf);
3066 }
3067
3068 static inline int scst_get_buf_next(struct scst_cmd *cmd, uint8_t **buf)
3069 {
3070         return __scst_get_buf(cmd, cmd->sg, cmd->sg_cnt, buf);
3071 }
3072
3073 static inline void scst_put_buf(struct scst_cmd *cmd, void *buf)
3074 {
3075         /* Nothing to do */
3076 }
3077
3078 static inline int scst_get_in_buf_first(struct scst_cmd *cmd, uint8_t **buf)
3079 {
3080         cmd->get_sg_buf_entry_num = 0;
3081         cmd->may_need_dma_sync = 1;
3082         return __scst_get_buf(cmd, cmd->in_sg, cmd->in_sg_cnt, buf);
3083 }
3084
3085 static inline int scst_get_in_buf_next(struct scst_cmd *cmd, uint8_t **buf)
3086 {
3087         return __scst_get_buf(cmd, cmd->in_sg, cmd->in_sg_cnt, buf);
3088 }
3089
3090 static inline void scst_put_in_buf(struct scst_cmd *cmd, void *buf)
3091 {
3092         /* Nothing to do */
3093 }
3094
3095 /*
3096  * Returns approximate higher rounded buffers count that
3097  * scst_get_buf_[first|next]() return.
3098  */
3099 static inline int scst_get_buf_count(struct scst_cmd *cmd)
3100 {
3101         return (cmd->sg_cnt == 0) ? 1 : cmd->sg_cnt;
3102 }
3103
3104 /*
3105  * Returns approximate higher rounded buffers count that
3106  * scst_get_in_buf_[first|next]() return.
3107  */
3108 static inline int scst_get_in_buf_count(struct scst_cmd *cmd)
3109 {
3110         return (cmd->in_sg_cnt == 0) ? 1 : cmd->in_sg_cnt;
3111 }
3112
3113 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23) && !defined(BACKPORT_LINUX_WORKQUEUE_TO_2_6_19)
3114 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20))
3115 static inline int cancel_delayed_work_sync(struct delayed_work *work)
3116 #else
3117 static inline int cancel_delayed_work_sync(struct work_struct *work)
3118 #endif
3119 {
3120         int res;
3121
3122         res = cancel_delayed_work(work);
3123         flush_scheduled_work();
3124         return res;
3125 }
3126 #endif
3127
3128 /*
3129  * Suspends and resumes any activity.
3130  * Function scst_suspend_activity() doesn't return 0, until there are any
3131  * active commands (state after SCST_CMD_STATE_INIT). If "interruptible"
3132  * is true, it returns after SCST_SUSPENDING_TIMEOUT or if it was interrupted
3133  * by a signal with the coresponding error status < 0. If "interruptible"
3134  * is false, it will wait virtually forever.
3135  *
3136  * New arriving commands stay in that state until scst_resume_activity()
3137  * is called.
3138  */
3139 int scst_suspend_activity(bool interruptible);
3140 void scst_resume_activity(void);
3141
3142 /*
3143  * Main SCST commands processing routing. Must be used only by dev handlers.
3144  * Argument atomic is true if function called in atomic context.
3145  */
3146 void scst_process_active_cmd(struct scst_cmd *cmd, bool atomic);
3147
3148 /*
3149  * SCST commands processing routine, which should be called by dev handler
3150  * after its parse() callback returned SCST_CMD_STATE_STOP. Arguments
3151  * the same as for scst_process_active_cmd().
3152  */
3153 void scst_post_parse_process_active_cmd(struct scst_cmd *cmd, bool atomic);
3154
3155 /*
3156  * Checks if command can be executed (reservations, etc.) or there are local
3157  * events, like pending UAs. Returns < 0 if command must be aborted, > 0 if
3158  * there is an event and command should be immediately completed, or 0
3159  * otherwise.
3160  *
3161  * !! Dev handlers implementing exec() callback must call this function there !!
3162  * !! just before the actual command's execution                              !!
3163  */
3164 int scst_check_local_events(struct scst_cmd *cmd);
3165
3166 /*
3167  * Returns the next state of the SCSI target state machine in case if command's
3168  * completed abnormally.
3169  */
3170 int scst_get_cmd_abnormal_done_state(const struct scst_cmd *cmd);
3171
3172 /*
3173  * Sets state of the SCSI target state machine in case if command's completed
3174  * abnormally.
3175  */
3176 void scst_set_cmd_abnormal_done_state(struct scst_cmd *cmd);
3177
3178 struct scst_trace_log {
3179         unsigned int val;
3180         const char *token;
3181 };
3182
3183 #ifdef CONFIG_SCST_PROC
3184
3185 /*
3186  * Returns target driver's root entry in SCST's /proc hierarchy.
3187  * The driver can create own files/directories here, which should
3188  * be deleted in the driver's release().
3189  */
3190 struct proc_dir_entry *scst_proc_get_tgt_root(
3191         struct scst_tgt_template *vtt);
3192
3193 /*
3194  * Returns device handler's root entry in SCST's /proc hierarchy.
3195  * The driver can create own files/directories here, which should
3196  * be deleted in the driver's detach()/release().
3197  */
3198 struct proc_dir_entry *scst_proc_get_dev_type_root(
3199         struct scst_dev_type *dtt);
3200
3201 /**
3202  ** Two library functions and the structure to help the drivers
3203  ** that use scst_debug.* facilities manage "trace_level" /proc entry.
3204  ** The functions service "standard" log levels and allow to work
3205  ** with driver specific levels, which should be passed inside as
3206  ** NULL-terminated array of struct scst_trace_log's, where:
3207  **   - val - the level's numeric value
3208  **   - token - its string representation
3209  **/
3210
3211 int scst_proc_log_entry_read(struct seq_file *seq, unsigned long log_level,
3212         const struct scst_trace_log *tbl);
3213 int scst_proc_log_entry_write(struct file *file, const char __user *buf,
3214         unsigned long length, unsigned long *log_level,
3215         unsigned long default_level, const struct scst_trace_log *tbl);
3216
3217 /*
3218  * helper data structure and function to create proc entry.
3219  */
3220 struct scst_proc_data {
3221         const struct file_operations seq_op;
3222         int (*show)(struct seq_file *, void *);
3223         void *data;
3224 };
3225
3226 int scst_single_seq_open(struct inode *inode, struct file *file);
3227
3228 struct proc_dir_entry *scst_create_proc_entry(struct proc_dir_entry *root,
3229         const char *name, struct scst_proc_data *pdata);
3230
3231 #define SCST_DEF_RW_SEQ_OP(x)                          \
3232         .seq_op = {                                    \
3233                 .owner          = THIS_MODULE,         \
3234                 .open           = scst_single_seq_open,\
3235                 .read           = seq_read,            \
3236                 .write          = x,                   \
3237                 .llseek         = seq_lseek,           \
3238                 .release        = single_release,      \
3239         },
3240
3241 #else /* CONFIG_SCST_PROC */
3242
3243 /*
3244  * Returns target driver's root sysfs kobject.
3245  * The driver can create own files/directories/links here.
3246  */
3247 static inline struct kobject *scst_sysfs_get_tgtt_kobj(
3248         struct scst_tgt_template *tgtt)
3249 {
3250         return &tgtt->tgtt_kobj;
3251 }
3252
3253 /*
3254  * Returns target's root sysfs kobject.
3255  * The driver can create own files/directories/links here.
3256  */
3257 static inline struct kobject *scst_sysfs_get_tgt_kobj(
3258         struct scst_tgt *tgt)
3259 {
3260         return &tgt->tgt_kobj;
3261 }
3262
3263 /*
3264  * Returns device handler's root sysfs kobject.
3265  * The driver can create own files/directories/links here.
3266  */
3267 static inline struct kobject *scst_sysfs_get_devt_kobj(
3268         struct scst_dev_type *devt)
3269 {
3270         return &devt->devt_kobj;
3271 }
3272
3273 /*
3274  * Returns device's root sysfs kobject.
3275  * The driver can create own files/directories/links here.
3276  */
3277 static inline struct kobject *scst_sysfs_get_dev_kobj(
3278         struct scst_device *dev)
3279 {
3280         return &dev->dev_kobj;
3281 }
3282
3283 #endif /* CONFIG_SCST_PROC */
3284
3285 /* Returns target name */
3286 static inline const char *scst_get_tgt_name(const struct scst_tgt *tgt)
3287 {
3288         return tgt->tgt_name;
3289 }
3290
3291 /*
3292  * Adds and deletes (stops) num of global SCST's threads. Returns 0 on
3293  * success, error code otherwise.
3294  */
3295 int scst_add_global_threads(int num);
3296 void scst_del_global_threads(int num);
3297
3298 int scst_alloc_sense(struct scst_cmd *cmd, int atomic);
3299 int scst_alloc_set_sense(struct scst_cmd *cmd, int atomic,
3300         const uint8_t *sense, unsigned int len);
3301
3302 /*
3303  * Sets the corresponding field in the sense buffer taking sense type
3304  * into account. Returns resulting sense length.
3305  */
3306 int scst_set_sense(uint8_t *buffer, int len, bool d_sense,
3307         int key, int asc, int ascq);
3308
3309 /*
3310  * Returns true if the sense is valid and carrying a Unit Attention or
3311  * false otherwise.
3312  */
3313 bool scst_is_ua_sense(const uint8_t *sense, int len);
3314
3315 /*
3316  * Returnes true if sense matches to (key, asc, ascq) and false otherwise.
3317  * Valid_mask is one or several SCST_SENSE_*_VALID constants setting valid
3318  * (key, asc, ascq) values.
3319  */
3320 bool scst_analyze_sense(const uint8_t *sense, int len,
3321         unsigned int valid_mask, int key, int asc, int ascq);
3322
3323 /*
3324  * Returnes a pseudo-random number for debugging purposes. Available only in
3325  * the DEBUG build.
3326  */
3327 unsigned long scst_random(void);
3328
3329 /*
3330  * Sets response data length for cmd and truncates its SG vector accordingly.
3331  * The cmd->resp_data_len must not be set directly, it must be set only
3332  * using this function. Value of resp_data_len must be <= cmd->bufflen.
3333  */
3334 void scst_set_resp_data_len(struct scst_cmd *cmd, int resp_data_len);
3335
3336 /*
3337  * Get/put global ref counter that prevents from entering into suspended
3338  * activities stage, so protects from any global management operations.
3339  */
3340 void scst_get(void);
3341 void scst_put(void);
3342
3343 /*
3344  * Cmd ref counters
3345  */
3346 void scst_cmd_get(struct scst_cmd *cmd);
3347 void scst_cmd_put(struct scst_cmd *cmd);
3348
3349 /*
3350  * Allocates and returns pointer to SG vector with data size "size".
3351  * In *count returned the count of entries in the vector.
3352  * Returns NULL for failure.
3353  */
3354 struct scatterlist *scst_alloc(int size, gfp_t gfp_mask, int *count);
3355
3356 /* Frees SG vector returned by scst_alloc() */
3357 void scst_free(struct scatterlist *sg, int count);
3358
3359 /*
3360  * Adds local to the current thread data to tgt_dev
3361  * (they will be local for the tgt_dev and current thread).
3362  */
3363 void scst_add_thr_data(struct scst_tgt_dev *tgt_dev,
3364         struct scst_thr_data_hdr *data,
3365         void (*free_fn) (struct scst_thr_data_hdr *data));
3366
3367 /* Deletes all local to threads data from tgt_dev */
3368 void scst_del_all_thr_data(struct scst_tgt_dev *tgt_dev);
3369
3370 /* Deletes all local to threads data from all tgt_dev's of the dev */
3371 void scst_dev_del_all_thr_data(struct scst_device *dev);
3372
3373 /* Finds local to the thread data. Returns NULL, if they not found. */
3374 struct scst_thr_data_hdr *__scst_find_thr_data(struct scst_tgt_dev *tgt_dev,
3375         struct task_struct *tsk);
3376
3377 /* Finds local to the current thread data. Returns NULL, if they not found. */
3378 static inline struct scst_thr_data_hdr *scst_find_thr_data(
3379         struct scst_tgt_dev *tgt_dev)
3380 {
3381         return __scst_find_thr_data(tgt_dev, current);
3382 }
3383
3384 static inline void scst_thr_data_get(struct scst_thr_data_hdr *data)
3385 {
3386         atomic_inc(&data->ref);
3387 }
3388
3389 static inline void scst_thr_data_put(struct scst_thr_data_hdr *data)
3390 {
3391         if (atomic_dec_and_test(&data->ref))
3392                 data->free_fn(data);
3393 }
3394
3395 /**
3396  ** Generic parse() support routines.
3397  ** Done via pointer on functions to avoid unneeded dereferences on
3398  ** the fast path.
3399  **/
3400
3401 /* Calculates and returns block shift for the given sector size */
3402 int scst_calc_block_shift(int sector_size);
3403
3404 /* Generic parse() for SBC (disk) devices */
3405 int scst_sbc_generic_parse(struct scst_cmd *cmd,
3406         int (*get_block_shift)(struct scst_cmd *cmd));
3407
3408 /* Generic parse() for MMC (cdrom) devices */
3409 int scst_cdrom_generic_parse(struct scst_cmd *cmd,
3410         int (*get_block_shift)(struct scst_cmd *cmd));
3411
3412 /* Generic parse() for MO disk devices */
3413 int scst_modisk_generic_parse(struct scst_cmd *cmd,
3414         int (*get_block_shift)(struct scst_cmd *cmd));
3415
3416 /* Generic parse() for tape devices */
3417 int scst_tape_generic_parse(struct scst_cmd *cmd,
3418         int (*get_block_size)(struct scst_cmd *cmd));
3419
3420 /* Generic parse() for changer devices */
3421 int scst_changer_generic_parse(struct scst_cmd *cmd,
3422         int (*nothing)(struct scst_cmd *cmd));
3423
3424 /* Generic parse() for "processor" devices */
3425 int scst_processor_generic_parse(struct scst_cmd *cmd,
3426         int (*nothing)(struct scst_cmd *cmd));
3427
3428 /* Generic parse() for RAID devices */
3429 int scst_raid_generic_parse(struct scst_cmd *cmd,
3430         int (*nothing)(struct scst_cmd *cmd));
3431
3432 /**
3433  ** Generic dev_done() support routines.
3434  ** Done via pointer on functions to avoid unneeded dereferences on
3435  ** the fast path.
3436  **/
3437
3438 /* Generic dev_done() for block devices */
3439 int scst_block_generic_dev_done(struct scst_cmd *cmd,
3440         void (*set_block_shift)(struct scst_cmd *cmd, int block_shift));
3441
3442 /* Generic dev_done() for tape devices */
3443 int scst_tape_generic_dev_done(struct scst_cmd *cmd,
3444         void (*set_block_size)(struct scst_cmd *cmd, int block_size));
3445
3446 /*
3447  * Issues a MODE SENSE for control mode page data and sets the corresponding
3448  * dev's parameter from it. Returns 0 on success and not 0 otherwise.
3449  */
3450 int scst_obtain_device_parameters(struct scst_device *dev);
3451
3452 /*
3453  * Has to be put here open coded, because Linux doesn't have equivalent, which
3454  * allows exclusive wake ups of threads in LIFO order. We need it to let (yet)
3455  * unneeded threads sleep and not pollute CPU cache by their stacks.
3456  */
3457 static inline void add_wait_queue_exclusive_head(wait_queue_head_t *q,
3458         wait_queue_t *wait)
3459 {
3460         unsigned long flags;
3461
3462         wait->flags |= WQ_FLAG_EXCLUSIVE;
3463         spin_lock_irqsave(&q->lock, flags);
3464         __add_wait_queue(q, wait);
3465         spin_unlock_irqrestore(&q->lock, flags);
3466 }
3467
3468 #endif /* __SCST_H */