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