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