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