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