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