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