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