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