1f1c5666e821285a951272c62e4a6401e08f08cc
[mirror/scst/.git] / scst / include / scsi_tgt.h
1 /*
2  *  include/scsi_tgt.h
3  *  
4  *  Copyright (C) 2004-2006 Vladislav Bolkhovitin <vst@vlnb.net>
5  *                 and Leonid Stoljar
6  *  
7  *  Main SCSI target mid-level include file.
8  * 
9  *  This program is free software; you can redistribute it and/or
10  *  modify it under the terms of the GNU General Public License
11  *  as published by the Free Software Foundation, version 2
12  *  of the License.
13  * 
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  *  GNU General Public License for more details.
18  */
19
20 #ifndef __SCST_H
21 #define __SCST_H
22
23 #include <linux/types.h>
24 #include <linux/version.h>
25 #include <linux/blkdev.h>
26 #include <linux/interrupt.h>
27 #ifdef SCST_HIGHMEM
28 #include <asm/kmap_types.h>
29 #endif
30 #include <../drivers/scsi/scsi.h>
31
32 /* Version numbers, the same as for the kernel */
33 #define SCST_VERSION_CODE 0x000906
34 #define SCST_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
35 #define SCST_VERSION_STRING "0.9.6-pre1"
36
37 /*************************************************************
38  ** States of command processing state machine
39  *************************************************************/
40
41 /* A cmd is created, but scst_cmd_init_done() not called */
42 #define SCST_CMD_STATE_INIT_WAIT     1
43
44 /* LUN translation (cmd->tgt_dev assignment) */
45 #define SCST_CMD_STATE_INIT          2
46
47 /* 
48  * Again LUN translation (cmd->tgt_dev assignment), used if dev handler
49  * wants to restart cmd on another LUN
50  */
51 #define SCST_CMD_STATE_REINIT        3
52
53 /* Dev handler's parse() is going to be called */
54 #define SCST_CMD_STATE_DEV_PARSE     4
55
56 /* Allocation of the cmd's data buffer */
57 #define SCST_CMD_STATE_PREPARE_SPACE 5
58
59 /* Target driver's rdy_to_xfer() is going to be called */
60 #define SCST_CMD_STATE_RDY_TO_XFER   6
61
62 /* Waiting for data from the initiator (until scst_rx_data() called) */
63 #define SCST_CMD_STATE_DATA_WAIT     7
64
65 /* CDB is going to be sent to SCSI mid-level for execution */
66 #define SCST_CMD_STATE_SEND_TO_MIDLEV 8
67
68 /* Waiting for CDB's execution finish */
69 #define SCST_CMD_STATE_EXECUTING     9
70
71 /* Dev handler's dev_done() is going to be called */
72 #define SCST_CMD_STATE_DEV_DONE      10
73
74 /* Target driver's xmit_response() is going to be called */
75 #define SCST_CMD_STATE_XMIT_RESP     11
76
77 /* Waiting for response's transmission finish */
78 #define SCST_CMD_STATE_XMIT_WAIT     12
79
80 /* The cmd finished */
81 #define SCST_CMD_STATE_FINISHED      14
82
83 /************************************************************* 
84  ** Can be retuned instead of cmd's state by dev handlers' 
85  ** functions, if the command's state should be set by default
86  *************************************************************/
87 #define SCST_CMD_STATE_DEFAULT       0
88
89 /************************************************************* 
90  ** Can be retuned instead of cmd's state by dev handlers' 
91  ** functions, if it is impossible to complete requested
92  ** task in atomic context. The cmd will be restarted in thread 
93  ** context.
94  *************************************************************/
95 #define SCST_CMD_STATE_NEED_THREAD_CTX       100
96
97 /*************************************************************
98  ** States of mgmt command processing state machine
99  *************************************************************/
100
101 /* LUN translation (mcmd->tgt_dev assignment) */
102 #define SCST_MGMT_CMD_STATE_INIT     1
103
104 /* Mgmt cmd is ready for processing */
105 #define SCST_MGMT_CMD_STATE_READY    2
106
107 /* Mgmt cmd is being executing */
108 #define SCST_MGMT_CMD_STATE_EXECUTING 3
109
110 /* Target driver's task_mgmt_fn_done() is going to be called */
111 #define SCST_MGMT_CMD_STATE_DONE     4
112
113 /* The mcmd finished */
114 #define SCST_MGMT_CMD_STATE_FINISHED 5
115
116 /*************************************************************
117  ** Constants for "atomic" parameter of SCST's functions
118  *************************************************************/
119 #define SCST_NON_ATOMIC              0
120 #define SCST_ATOMIC                  1
121
122 /************************************************************* 
123  ** Values for pref_context parameter of scst_cmd_init_done() and 
124  ** scst_rx_data() 
125  *************************************************************/
126
127 /* 
128  * Direct cmd's processing (i.e. regular function calls in the current 
129  * context), sleeping is allowed, no restrictions
130  */
131 #define SCST_CONTEXT_DIRECT          0
132
133 /* 
134  * Direct cmd's processing (i.e. regular function calls in the current 
135  * context) sleeping is not allowed
136  */
137 #define SCST_CONTEXT_DIRECT_ATOMIC   1
138
139 /* Tasklet or thread context required for cmd's processing */
140 #define SCST_CONTEXT_TASKLET         2
141
142 /* Thread context required for cmd's processing */
143 #define SCST_CONTEXT_THREAD          3
144
145 /*
146  * Additional bit to set processible environment.
147  * Private for SCST, ie must not be used target drivers.
148  */
149 #define SCST_PROCESSIBLE_ENV         0x10000000
150
151 /************************************************************* 
152  ** Values for status parameter of scst_rx_data() 
153  *************************************************************/
154
155 /* Success */
156 #define SCST_RX_STATUS_SUCCESS       0
157
158 /* 
159  * Data receiving finished with error, so set the sense and 
160  * finish the command, including xmit_response() call
161  */
162 #define SCST_RX_STATUS_ERROR         1
163
164 /* 
165  * Data receiving finished with error and the sense is set,  
166  * so finish the command, including xmit_response() call
167  */
168 #define SCST_RX_STATUS_ERROR_SENSE_SET 2
169
170 /* 
171  * Data receiving finished with fatal error, so finish the command, 
172  * but don't call xmit_response()
173  */
174 #define SCST_RX_STATUS_ERROR_FATAL   3
175
176 /*************************************************************
177  ** Allowed return codes for xmit_response(), rdy_to_xfer(), 
178  ** report_aen() 
179  *************************************************************/
180
181 /* Success */
182 #define SCST_TGT_RES_SUCCESS         0
183
184 /* Internal device queue is full, retry again later */
185 #define SCST_TGT_RES_QUEUE_FULL      -1
186
187 /* 
188  * It is impossible to complete requested task in atomic context. 
189  * The cmd will be restarted in thread  context.
190  */
191 #define SCST_TGT_RES_NEED_THREAD_CTX -2
192
193 /* 
194  * Fatal error, if returned by xmit_response() the cmd will 
195  * be destroyed, if by any other function, xmit_response() 
196  * will be called with HARDWARE ERROR sense data
197  */
198 #define SCST_TGT_RES_FATAL_ERROR     -3
199
200 /*************************************************************
201  ** Allowed return codes for dev handler's exec()
202  *************************************************************/
203
204 /* The cmd is done, go to other ones */
205 #define SCST_EXEC_COMPLETED          0
206
207 /* The cmd should be sent to SCSI mid-level */
208 #define SCST_EXEC_NOT_COMPLETED      1
209
210 /* 
211  * Thread context is required to execute the command. 
212  * Exec() will be called again in the thread context.
213  */
214 #define SCST_EXEC_NEED_THREAD        2
215
216 /*************************************************************
217  ** Allowed return codes for dev handler's task_mgmt_fn()
218  *************************************************************/
219
220 /* The command is done with success, no firther actions required */
221 #define SCST_DEV_TM_COMPLETED_SUCCESS 0
222
223 /* The command is failed, no firther actions required */
224 #define SCST_DEV_TM_COMPLETED_FAILED  -1
225
226 /* Regular standard actions for the command should be done */
227 #define SCST_DEV_TM_NOT_COMPLETED     1
228
229 /************************************************************* 
230  ** Default timeout for cmd's CDB execution 
231  ** by SCSI mid-level (cmd's "timeout" field).
232  *************************************************************/
233 #define SCST_DEFAULT_TIMEOUT         (30*HZ)
234
235 /************************************************************* 
236  ** Data direction aliases 
237  *************************************************************/
238 #define SCST_DATA_UNKNOWN            DMA_BIDIRECTIONAL
239 #define SCST_DATA_WRITE              DMA_TO_DEVICE
240 #define SCST_DATA_READ               DMA_FROM_DEVICE
241 #define SCST_DATA_NONE               DMA_NONE
242
243 /*************************************************************
244  ** Flags of cmd->tgt_resp_flags
245  *************************************************************/
246
247 /* 
248  * Set if cmd is finished and there is status/sense to be sent. 
249  * The status should be not sent (i.e. the flag not set) if the 
250  * possibility to perform a command in "chunks" (i.e. with multiple 
251  * xmit_response()/rdy_to_xfer()) is used (not implemented and,
252  * probably, will never be).
253  */
254 #define SCST_TSC_FLAG_STATUS         0x2
255
256 /************************************************************* 
257  ** Values for management functions
258  *************************************************************/
259 #define SCST_ABORT_TASK              0
260 #define SCST_ABORT_TASK_SET          1
261 #define SCST_CLEAR_ACA               2
262 #define SCST_CLEAR_TASK_SET          3
263 #define SCST_LUN_RESET               4
264 #define SCST_TARGET_RESET            5
265
266 /** SCST extensions **/
267
268 /* 
269  * Notifies about I_T nexus loss event in the corresponding session.
270  * Aborts all tasks there, resets the reservation, if any, and sets
271  * up the I_T Nexus loss UA.
272  */
273 #define SCST_NEXUS_LOSS_SESS         6
274
275 /* Aborts all tasks in the corresponding session with TASK_ABORTED status */
276 #define SCST_ABORT_ALL_TASKS_SESS    7
277
278 /* 
279  * Notifies about I_T nexus loss event. Aborts all tasks in all sessions
280  * of the tgt, resets the reservations, if any,  and sets up the I_T Nexus
281  * loss UA.
282  */
283 #define SCST_NEXUS_LOSS              8
284
285 /* Aborts all tasks in all sessions of the tgt with TASK_ABORTED status */
286 #define SCST_ABORT_ALL_TASKS         9
287
288 /************************************************************* 
289  ** Values for mgmt cmd's "status"
290  *************************************************************/
291 #define SCST_MGMT_STATUS_SUCCESS     0
292 #define SCST_MGMT_STATUS_FAILED     -1
293
294 /************************************************************* 
295  ** Session initialization phases
296  *************************************************************/
297
298 /* Set if session is being initialized */
299 #define SCST_SESS_IPH_INITING        0
300
301 /* Set if the session is successfully initialized */
302 #define SCST_SESS_IPH_SUCCESS        1
303
304 /* Set if the session initialization failed */
305 #define SCST_SESS_IPH_FAILED         2
306
307 /* Set if session is initialized and ready */
308 #define SCST_SESS_IPH_READY          3
309
310 /*************************************************************
311  ** Cmd's async (atomic) flags 
312  *************************************************************/
313
314 /* Set if the cmd is aborted and ABORTED sense will be sent as the result */
315 #define SCST_CMD_ABORTED                0
316
317 /* Set if the cmd is aborted by other initiator */
318 #define SCST_CMD_ABORTED_OTHER          1
319
320 /* Set if no response should be sent to the target about this cmd */
321 #define SCST_CMD_NO_RESP                2
322
323 /*
324  * Set if the cmd is being executed. Needed to guarantee that 
325  * "no further responses from the task are sent to
326  * the SCSI initiator port" after response from the TM function is 
327  * sent (SAM) as well as correct ABORT TASK status code
328  */
329 #define SCST_CMD_EXECUTING              3
330
331 /*
332  * Set if the cmd status/data are being xmitted. The purpose is the
333  * same as for SCST_CMD_EXECUTING
334  */
335 #define SCST_CMD_XMITTING               4
336
337 /* Set if the cmd was done or aborted out of its SN */
338 #define SCST_CMD_OUT_OF_SN              5
339
340 /* Set if the cmd is dead and can be destroyed at any time */
341 #define SCST_CMD_CAN_BE_DESTROYED       6
342
343 /*************************************************************
344  ** Tgt_dev's flags 
345  *************************************************************/
346
347 /* Set if tgt_dev has Unit Attention sense */
348 #define SCST_TGT_DEV_UA_PENDING      0
349
350 /* Set if tgt_dev is RESERVED by another session */
351 #define SCST_TGT_DEV_RESERVED        1
352
353 #ifdef DEBUG_TM
354 #define SCST_TGT_DEV_UNDER_TM_DBG    10
355 #endif
356
357 /************************************************************* 
358  ** Commands that are not listed anywhere else 
359  *************************************************************/
360 #ifndef REPORT_DEVICE_IDENTIFIER
361 #define REPORT_DEVICE_IDENTIFIER    0xA3
362 #endif
363 #ifndef INIT_ELEMENT_STATUS
364 #define INIT_ELEMENT_STATUS         0x07
365 #endif
366 #ifndef INIT_ELEMENT_STATUS_RANGE
367 #define INIT_ELEMENT_STATUS_RANGE   0x37
368 #endif
369 #ifndef PREVENT_ALLOW_MEDIUM
370 #define PREVENT_ALLOW_MEDIUM        0x1E
371 #endif
372 #ifndef READ_ATTRIBUTE
373 #define READ_ATTRIBUTE              0x8C
374 #endif
375 #ifndef REQUEST_VOLUME_ADDRESS
376 #define REQUEST_VOLUME_ADDRESS      0xB5
377 #endif
378 #ifndef WRITE_ATTRIBUTE
379 #define WRITE_ATTRIBUTE             0x8D
380 #endif
381 #ifndef WRITE_VERIFY_16
382 #define WRITE_VERIFY_16             0x8E
383 #endif
384 #ifndef VERIFY_6
385 #define VERIFY_6                    0x13
386 #endif
387 #ifndef VERIFY_12
388 #define VERIFY_12                   0xAF
389 #endif
390
391 /*************************************************************
392  ** Control byte field in CDB
393  *************************************************************/
394 #ifndef CONTROL_BYTE_LINK_BIT
395 #define CONTROL_BYTE_LINK_BIT       0x01
396 #endif
397 #ifndef CONTROL_BYTE_NACA_BIT
398 #define CONTROL_BYTE_NACA_BIT       0x04
399 #endif
400
401 /*************************************************************
402  ** Byte 1 in INQUIRY CDB
403  *************************************************************/
404 #define SCST_INQ_EVPD                0x01
405
406 /*************************************************************
407  ** Byte 3 in Standard INQUIRY data
408  *************************************************************/
409 #define SCST_INQ_BYTE3               3
410
411 #define SCST_INQ_NORMACA_BIT         0x20
412
413 /*************************************************************
414  ** Byte 2 in RESERVE_10 CDB
415  *************************************************************/
416 #define SCST_RES_3RDPTY              0x10
417 #define SCST_RES_LONGID              0x02
418
419 /************************************************************* 
420  ** Misc SCSI constants
421  *************************************************************/
422 #define SCST_SENSE_ASC_UA_RESET      0x29
423
424 /*************************************************************
425  ** Name of the entry in /proc
426  *************************************************************/
427 #define SCST_PROC_ENTRY_NAME         "scsi_tgt"
428
429 /*************************************************************
430  ** Used with scst_set_cmd_error() 
431  *************************************************************/
432 #define SCST_LOAD_SENSE(key_asc_ascq) key_asc_ascq
433
434 #define SCST_SENSE_VALID(sense)      ((((uint8_t *)(sense))[0] & 0x70) == 0x70)
435
436 #define SCST_NO_SENSE(sense)         (((uint8_t *)(sense))[2] == 0)
437
438 /*************************************************************
439  *                     TYPES
440  *************************************************************/
441
442 struct scst_tgt;
443 struct scst_session;
444 struct scst_cmd;
445 struct scst_mgmt_cmd;
446 struct scst_device;
447 struct scst_tgt_dev;
448 struct scst_dev_type;
449 struct scst_info_cdb;
450 struct scst_acg;
451 struct scst_acg_dev;
452 struct scst_acn;
453
454 typedef uint32_t lun_t;
455
456 typedef enum dma_data_direction scst_data_direction;
457
458 /* 
459  * Scsi_Target_Template: defines what functions a target driver will
460  * have to provide in order to work with the target mid-level. 
461  * MUST HAVEs define functions that are expected to be in order to work. 
462  * OPTIONAL says that there is a choice.
463  * Also, pay attention to the fact that a command is BLOCKING or NON-BLOCKING.
464  * NON-BLOCKING means that a function returns immediately and will not wait
465  * for actual data transfer to finish. Blocking in such command could have 
466  * negative impact on overall system performance. If blocking is necessary, 
467  * it is worth to consider creating dedicated thread(s) in target driver, to 
468  * which the commands would be passed and which would perform blocking 
469  * operations instead of SCST.
470  * If the function allowed to sleep or not is determined by its last 
471  * argument, which is true, if sleeping is not allowed. In this case, 
472  * if the function requires sleeping, it  can return 
473  * SCST_TGT_RES_NEED_THREAD_CTX, and it will be recalled in the thread context,
474  * where sleeping is allowed.
475  */
476 struct scst_tgt_template
477 {
478         /* public: */
479
480         /* 
481          * Name of the template. Must be unique to identify
482          * the template. MUST HAVE
483          */
484         const char name[15];
485
486         /* 
487          * SG tablesize allows to check whether scatter/gather can be used
488          * or not. 
489          */
490         int sg_tablesize;
491
492         /*
493          * True, if this target adapter uses unchecked DMA onto an ISA bus.
494          */
495         unsigned unchecked_isa_dma:1;
496
497         /*
498          * True, if this target adapter wants to use clustering 
499          * (i.e. smaller number of segments).
500          */
501         unsigned use_clustering:1;
502
503         /*
504          * True, if corresponding function supports execution in
505          * the atomic (non-sleeping) context
506          */
507         unsigned xmit_response_atomic:1;
508         unsigned rdy_to_xfer_atomic:1;
509
510         /* True, if the template doesn't need the entry in /proc */
511         unsigned no_proc_entry:1;
512
513         /*
514          * True, if the target requires that *ALL* affecting by a task
515          * management command outstanding SCSI commands finished before
516          * sending the TM command reply. Otherwise, the TM reply will be
517          * send immediately after it is insured, that the affecting SCSI
518          * commands will reach xmit_response() with ABORTED flag set (see
519          * also scst_cmd_aborted()).
520          */
521         unsigned tm_sync_reply:1;
522
523         /*
524          * This function should detect the target adapters that
525          * are present in the system. The function should return a value
526          * >= 0 to signify the number of detected target adapters. 
527          * A negative value should be returned whenever there is
528          * an error. 
529          *
530          * MUST HAVE
531          */
532         int (*detect) (struct scst_tgt_template *tgt_template);
533
534         /*
535          * This function should free up the resources allocated to the device. 
536          * The function should return 0 to indicate successful release 
537          * or a negative value if there are some issues with the release. 
538          * In the current version the return value is ignored.
539          *
540          * MUST HAVE
541          */
542         int (*release) (struct scst_tgt *tgt);
543
544         /*
545          * This function is equivalent to the SCSI
546          * queuecommand. The target should transmit the response
547          * buffer and the status in the scst_cmd struct. 
548          * The expectation is that this executing this command is NON-BLOCKING. 
549          * 
550          * After the response is actually transmitted, the target 
551          * should call the scst_tgt_cmd_done() function of the 
552          * mid-level, which will allow it to free up the command.
553          * Returns one of the SCST_TGT_RES_* constants.
554          *
555          * Pay attention to "atomic" attribute of the cmd, which can be get
556          * by scst_cmd_atomic(): it is true if the function called in the
557          * atomic (non-sleeping) context.
558          *
559          * MUST HAVE
560          */
561         int (*xmit_response) (struct scst_cmd *cmd);
562
563         /*
564          * This function allows the target driver to handle data buffer
565          * allocations on its own.
566          * Shall return 0 in case of success, and != 0 (preferrably -ENOMEM)
567          * in case of error. In case of returning successfully,
568          * scst_cmd->data_buf_alloced will be set by SCST.
569          *
570          * If allocation in atomic context - cf. scst_cmd_atomic() - is not
571          * desired or fails and consequently != 0 is returned, this function
572          * will be re-called in thread context.
573          *
574          * Please note that the driver will have to handle all relevant details
575          * such as scatterlist setup, highmem, freeing the allocated memory, ...
576          * itself.
577          *
578          * OPTIONAL.
579          */
580         int (*alloc_data_buf) (struct scst_cmd *cmd);
581
582         /*
583          * This function informs the driver that data
584          * buffer corresponding to the said command have now been
585          * allocated and it is OK to receive data for this command.
586          * This function is necessary because a SCSI target does not
587          * have any control over the commands it receives. Most lower
588          * level protocols have a corresponding function which informs
589          * the initiator that buffers have been allocated e.g., XFER_
590          * RDY in Fibre Channel. After the data is actually received
591          * the low-level driver needs to call scst_rx_data() in order to 
592          * continue processing this command.
593          * Returns one of the SCST_TGT_RES_* constants.
594          * This command is expected to be NON-BLOCKING.
595          *
596          * Pay attention to "atomic" attribute of the cmd, which can be get
597          * by scst_cmd_atomic(): it is true if the function called in the
598          * atomic (non-sleeping) context.
599          *
600          * MUST HAVE.
601          */
602         int (*rdy_to_xfer) (struct scst_cmd *cmd);
603
604         /* 
605          * Called to notify the driver that the command is about to be freed.
606          * Necessary, because for aborted commands xmit_response() could not
607          * be called. Could be called on IRQ context.
608          *
609          * MUST HAVE
610          */
611         void (*on_free_cmd) (struct scst_cmd *cmd);
612
613         /*
614          * This function informs the driver that a
615          * received task management function has been completed. This
616          * function is necessary because low-level protocols have some
617          * means of informing the initiator about the completion of a
618          * Task Management function. This function being called will
619          * signify that a Task Management function is completed as far
620          * as the mid-level is concerned. Any information that must be
621          * stored about the command is the responsibility of the low-
622          * level driver. No return value expected. 
623          * This function is expected to be NON-BLOCKING
624          *
625          * Pay attention to "atomic" attribute of the cmd, which can be get
626          * by scst_cmd_atomic(): it is true if the function called in the
627          * atomic (non-sleeping) context.
628          *
629          * MUST HAVE if the target supports ABORTs
630          */
631         void (*task_mgmt_fn_done) (struct scst_mgmt_cmd *mgmt_cmd);
632
633         /*
634          * This function is used for Asynchronous Event Notification. 
635          * It is the responsibility of the driver to notify any/all
636          * initiators about the Asynchronous Event reported.
637          * Returns one of the SCST_TGT_RES_* constants.
638          * This command is expected to be NON-BLOCKING, but can sleep.
639          *
640          * MUST HAVE if low-level protocol supports AEN
641          *
642          * ToDo
643          */
644         int (*report_aen) (int mgmt_fn, const uint8_t *lun, int lun_len);
645
646         /* 
647          * This function can be used to export the driver's statistics and 
648          * other infos to the world outside the kernel. 
649          *
650          * OPTIONAL
651          */
652         int (*proc_info) (char *buffer, char **start, off_t offset, 
653                 int length, int *eof, struct scst_tgt *tgt, int inout);
654
655         /* Private, must be inited to 0 by memset() */
656
657         /* List of targets per template, protected by scst_mutex */
658         struct list_head tgt_list;
659
660         /* List entry of global templates list */
661         struct list_head scst_template_list_entry;
662
663         /* The pointer to the /proc directory entry */
664         struct proc_dir_entry *proc_tgt_root;
665
666         /* Dedicated thread number */
667         int thread_num;
668         
669         /* Device number in /proc */
670         int proc_dev_num;
671 };
672
673 struct scst_dev_type
674 {
675         /* Name of the dev handler. Must be unique. MUST HAVE */
676         char name[15];
677
678         /* SCSI type of the supported device. MUST HAVE */
679         int type;
680
681         /*
682          * True, if corresponding function supports execution in
683          * the atomic (non-sleeping) context
684          */
685         unsigned parse_atomic:1;
686         unsigned exec_atomic:1;
687         unsigned dev_done_atomic:1;
688
689         /* 
690          * Called when new device is attaching to the dev handler
691          * Returns 0 on success, error code otherwise.
692          */
693         int (*attach) (struct scst_device *dev);
694
695         /* Called when new device is detaching from the dev handler */
696         void (*detach) (struct scst_device *dev);
697
698         /* 
699          * Called when new tgt_dev (session) is attaching to the dev handler.
700          * Returns 0 on success, error code otherwise.
701          */
702         int (*attach_tgt) (struct scst_tgt_dev *tgt_dev);
703
704         /* Called when tgt_dev (session) is detaching from the dev handler */
705         void (*detach_tgt) (struct scst_tgt_dev *tgt_dev);
706
707         /* 
708          * Called to parse CDB from the cmd and initialize 
709          * cmd->bufflen and cmd->data_direction (both - REQUIRED).
710          * Returns the command's next state or SCST_CMD_STATE_DEFAULT, 
711          * if the next default state should be used, or 
712          * SCST_CMD_STATE_NEED_THREAD_CTX if the function called in atomic 
713          * context, but requires sleeping. In the last case, the function 
714          * will be recalled in the thread context, where sleeping is allowed.
715          *
716          * Pay attention to "atomic" attribute of the cmd, which can be get
717          * by scst_cmd_atomic(): it is true if the function called in the
718          * atomic (non-sleeping) context.
719          *
720          * MUST HAVE
721          */
722         int (*parse) (struct scst_cmd *cmd,
723                       const struct scst_info_cdb *cdb_info);
724
725         /* 
726          * Called to execute CDB. Useful, for instance, to implement 
727          * data caching. The result of CDB execution is reported via 
728          * cmd->scst_cmd_done() callback.
729          * Returns: 
730          *  - SCST_EXEC_COMPLETED - the cmd is done, go to other ones
731          *  - SCST_EXEC_NEED_THREAD - thread context is required to execute
732          *    the command. Exec() will be called again in the thread context.
733          *  - SCST_EXEC_NOT_COMPLETED - the cmd should be sent to SCSI mid-level.
734          *
735          * Pay attention to "atomic" attribute of the cmd, which can be get
736          * by scst_cmd_atomic(): it is true if the function called in the
737          * atomic (non-sleeping) context.
738          *
739          * OPTIONAL, if not set, the commands will be sent directly to SCSI
740          * device.
741          */
742         int (*exec) (struct scst_cmd *cmd);
743
744         /* 
745          * Called to notify dev handler about the result of cmd execution
746          * and perform some post processing. Cmd's fields tgt_resp_flags and
747          * resp_data_len should be set by this function, but SCST offers good
748          * defaults.
749          * Returns the command's next state or SCST_CMD_STATE_DEFAULT, 
750          * if the next default state should be used, or 
751          * SCST_CMD_STATE_NEED_THREAD_CTX if the function called in atomic 
752          * context, but requires sleeping. In the last case, the function 
753          * will be recalled in the thread context, where sleeping is allowed.
754          *
755          * Pay attention to "atomic" attribute of the cmd, which can be get
756          * by scst_cmd_atomic(): it is true if the function called in the
757          * atomic (non-sleeping) context.
758          */
759         int (*dev_done) (struct scst_cmd *cmd);
760
761         /* 
762          * Called to notify dev hander that the command is about to be freed.
763          * Could be called on IRQ context.
764          */
765         void (*on_free_cmd) (struct scst_cmd *cmd);
766
767         /* 
768          * Called to execute a task management command. 
769          * Returns: 
770          *  - SCST_DEV_TM_COMPLETED_SUCCESS - the command is done with success,
771          *      no firther actions required
772          *  - SCST_DEV_TM_COMPLETED_FAILED - the command is failed, 
773          *      no firther actions required
774          *  - SCST_DEV_TM_NOT_COMPLETED - regular standard actions for the command
775          *      should be done
776          *
777          * Called with BH off. Might be called under a lock and IRQ off.
778          */
779         int (*task_mgmt_fn) (struct scst_mgmt_cmd *mgmt_cmd, 
780                 struct scst_tgt_dev *tgt_dev);
781
782         /* 
783          * This function can be used to export the handler's statistics and 
784          * other infos to the world outside the kernel. 
785          *
786          * OPTIONAL
787          */
788         int (*proc_info) (char *buffer, char **start, off_t offset,
789                 int length, int *eof, struct scst_dev_type *dev_type, 
790                 int inout);
791
792         struct module *module;
793
794         /* private: */
795
796         /* list entry in scst_dev_type_list */
797         struct list_head dev_type_list_entry;
798         
799         /* The pointer to the /proc directory entry */
800         struct proc_dir_entry *proc_dev_type_root;
801 };
802
803 struct scst_tgt
804 {
805         /* List of remote sessions per target, protected by scst_mutex */
806         struct list_head sess_list;
807
808         /* List entry of targets per template (tgts_list) */
809         struct list_head tgt_list_entry;
810
811         struct scst_tgt_template *tgtt; /* corresponding target template */
812
813         /* Used to wait until session finished to unregister */
814         wait_queue_head_t unreg_waitQ;
815
816         /* Device number in /proc */
817         int proc_num;
818
819         /*
820          * The following fields used to store and retry cmds if
821          * target's internal queue is full, so the target is unable to accept
822          * the cmd returning QUEUE FULL
823          */
824         atomic_t finished_cmds;
825         int retry_cmds;         /* protected by tgt_lock */
826         spinlock_t tgt_lock;
827         struct list_head retry_cmd_list; /* protected by tgt_lock */
828         struct timer_list retry_timer;
829         int retry_timer_active;
830
831         /* Maximum SG table size */
832         int sg_tablesize;
833
834         /* Used for storage of target driver private stuff */
835         void *tgt_priv;
836 };
837
838 struct scst_session
839 {
840         /* Initialization phase, one of SCST_SESS_IPH_* constants */
841         int init_phase;
842
843         atomic_t refcnt;                /* get/put counter */
844
845         /* Alive commands for this session. Serialized by scst_list_lock */
846         int sess_cmd_count;             
847
848         /************************************************************* 
849          ** Session's flags. Serialized by scst_list_lock
850          *************************************************************/
851
852         /* Set if the session is shutting down */
853         unsigned int shutting_down:1;
854
855         /* Set if the session is waiting in suspended state */
856         unsigned int waiting:1;
857
858         /**************************************************************/
859
860         /*
861          * List of tgt_dev's for this session, protected by scst_mutex
862          * and suspended activity
863          */
864         struct list_head sess_tgt_dev_list;
865
866         /* Access control for this session and list entry there */
867         struct scst_acg *acg;
868
869         /* List entry for the sessions list inside ACG */
870         struct list_head acg_sess_list_entry;
871
872         /* Used for storage of target driver private stuff */
873         void *tgt_priv;
874
875         /* 
876          * List of cmds in this session. Used to find a cmd in the
877          * session. Protected by scst_list_lock.
878          *
879          * ToDo: make it protected by own lock.
880          */
881         struct list_head search_cmd_list;
882         
883         struct scst_tgt *tgt;   /* corresponding target */
884
885         /*
886          * List entry for the list that keeps all sessions, which were
887          * stopped due to device block
888          */
889         struct list_head dev_wait_sess_list_entry;
890
891         /* Name of attached initiator */
892         const char *initiator_name;
893
894         /* Used if scst_unregister_session() called in wait mode */
895         struct semaphore *shutdown_mutex;
896         
897         /* List entry of sessions per target */
898         struct list_head sess_list_entry;
899
900         /* List entry for the list that keeps session, waiting for the init */
901         struct list_head sess_mgmt_list_entry;
902
903         /* 
904          * Lists of deffered during session initialization commands.
905          * Protected by scst_list_lock.
906          */
907         struct list_head init_deferred_cmd_list;
908         struct list_head init_deferred_mcmd_list;
909
910         /*
911          * Functions and data for user callbacks from scst_register_session()
912          * and scst_unregister_session()
913          */
914         void *reg_sess_data;
915         void (*init_result_fn) (struct scst_session *sess, void *data,
916                                 int result);
917         void (*unreg_done_fn) (struct scst_session *sess);
918 };
919
920 enum scst_cmd_queue_type
921 {
922         SCST_CMD_QUEUE_UNTAGGED = 0,
923         SCST_CMD_QUEUE_SIMPLE,
924         SCST_CMD_QUEUE_ORDERED,
925         SCST_CMD_QUEUE_HEAD_OF_QUEUE,
926         SCST_CMD_QUEUE_ACA
927 };
928
929 struct scst_cmd
930 {
931         /* List entry for global *_cmd_list */
932         struct list_head cmd_list_entry;
933
934         struct scst_session *sess;      /* corresponding session */
935
936         /* Cmd state, one of SCST_CMD_STATE_* constants */
937         int state;
938
939         /*************************************************************
940          ** Cmd's flags 
941          *************************************************************/
942         /* 
943          * Set if expected_sn was incremented, i.e. cmd was sent to 
944          * SCSI mid-level for execution
945          */
946         unsigned int sent_to_midlev:1;
947
948         /* Set if the cmd's action is completed */
949         unsigned int completed:1;
950
951         /* Set if we should ignore Unit Attention in scst_check_sense() */
952         unsigned int ua_ignore:1;
953
954         /* Set if cmd is being processed in atomic context */
955         unsigned int atomic:1;
956
957         /* Set if cmd must be processed only in non-atomic context */
958         unsigned int non_atomic_only:1;
959
960         /* Set if cmd is internally generated */
961         unsigned int internal:1;
962
963         /* Set if cmd is being retried */
964         unsigned int retry:1;
965
966         /* Set if the device should be unblock after cmd's finish */
967         unsigned int blocking:1;
968
969         /*
970          * Set if the target driver wants to alloc data buffers on its own.
971          * In this case alloc_data_buf() must be provided in the target driver
972          * template.
973          */
974         unsigned int data_buf_tgt_alloc:1;
975
976         /*
977          * Set by SCST if the custom data buffer allocation by the target driver
978          * succeeded.
979          */
980         unsigned int data_buf_alloced:1;
981
982         /* Set if the target driver called scst_set_expected() */
983         unsigned int expected_values_set:1;
984
985         /*
986          * Set if the cmd is being processed from the thread/tasklet,
987          * i.e. if another cmd is moved to the active list during processing
988          * of the current one, then another cmd will be processed after
989          * the current. Helps to save some context switches.
990          */
991         unsigned int processible_env:1;
992
993         /*
994          * Set if the cmd was delayed by task management debugging code.
995          * Used only if DEBUG_TM is on.
996          */
997         unsigned int tm_dbg_delayed:1;
998
999         /*
1000          * Set if the cmd must be ignored by task management debugging code.
1001          * Used only if DEBUG_TM is on.
1002          */
1003         unsigned int tm_dbg_immut:1;
1004
1005         /*
1006          * Set if the SG buffer was modified by scst_set_resp_data_len()
1007          */
1008         unsigned int sg_buff_modified:1;
1009
1010         /*
1011          * Set if the cmd's memory requirements are checked and found
1012          * acceptable
1013          */
1014         unsigned int mem_checked:1;
1015
1016         /*
1017          * Set if target driver may need to call dma_sync_sg() or similar
1018          * function before transferring cmd' data to the target device
1019          * via DMA.
1020          */
1021         unsigned int may_need_dma_sync:1;
1022
1023         /**************************************************************/
1024
1025         unsigned long cmd_flags;        /* cmd's async flags */
1026
1027         struct scst_tgt_template *tgtt; /* to save extra dereferences */
1028         struct scst_tgt *tgt;           /* to save extra dereferences */
1029         struct scst_device *dev;        /* to save extra dereferences */
1030
1031         lun_t lun;                      /* LUN for this cmd */
1032
1033         struct scst_tgt_dev *tgt_dev;   /* corresponding device for this cmd */
1034
1035 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
1036         struct scsi_request *scsi_req;  /* SCSI request */
1037 #endif
1038
1039         /* List entry for tgt_dev's SN related lists */
1040         struct list_head sn_cmd_list_entry;
1041
1042         /* Cmd's serial number, used to execute cmd's in order of arrival */
1043         unsigned int sn;
1044
1045         /* List entry for session's search_cmd_list */
1046         struct list_head search_cmd_list_entry;
1047
1048         /* 
1049          * Used to found the cmd by scst_find_cmd_by_tag(). Set by the
1050          * target driver on the cmd's initialization time
1051          */
1052         uint32_t tag;
1053
1054         /* CDB and its len */
1055         uint8_t cdb[MAX_COMMAND_SIZE];
1056         int cdb_len;
1057
1058         enum scst_cmd_queue_type queue_type;
1059
1060         int timeout;    /* CDB execution timeout */
1061         int retries;    /* Amount of retries that will be done by SCSI mid-level */
1062
1063         /* SCSI data direction, one of SCST_DATA_* constants */
1064         scst_data_direction data_direction;
1065         
1066         /* Remote initiator supplied values, if any */
1067         scst_data_direction expected_data_direction;
1068         unsigned int expected_transfer_len;
1069
1070         /* cmd data length */
1071         size_t data_len;
1072
1073         /* Completition routine */
1074         void (*scst_cmd_done) (struct scst_cmd *cmd, int next_state);
1075
1076         struct sgv_pool_obj *sgv;       /* sgv object */
1077
1078         size_t bufflen;                 /* cmd buffer length */
1079         struct scatterlist *sg;         /* cmd data buffer SG vector */
1080         int sg_cnt;                     /* SG segments count */
1081         
1082         /* scst_get_sg_buf_[first,next]() support */
1083         int get_sg_buf_entry_num;
1084
1085         /*
1086          * The following two fields should be corrected by the dev_done(),
1087          * if necessary
1088          */
1089         int tgt_resp_flags;     /* response flags (SCST_TSC_FLAG_* constants) */
1090
1091         /* 
1092          * Response data length in data buffer. This field must not be set
1093          * directly, use scst_set_resp_data_len() for that
1094          */
1095         int resp_data_len;
1096
1097         uint8_t status;         /* status byte from target device */
1098         uint8_t masked_status;  /* set from host device by status_byte() */
1099         uint8_t msg_status;     /* return status from host adapter itself */
1100         uint16_t host_status;   /* set by low-level driver to indicate status */
1101         uint16_t driver_status; /* set by mid-level */
1102
1103         /* 
1104          * Used to restore the SG vector if it was modified by
1105          * scst_set_resp_data_len()
1106          */
1107         int orig_sg_cnt, orig_sg_entry, orig_entry_len;
1108
1109         uint8_t sense_buffer[SCSI_SENSE_BUFFERSIZE];    /* sense buffer */
1110
1111         /* The corresponding mgmt cmd, if any. Protected by scst_list_lock */
1112         struct scst_mgmt_cmd *mgmt_cmnd;
1113
1114         /* List entry for dev's blocked_cmd_list */
1115         struct list_head blocked_cmd_list_entry;
1116
1117         /*
1118          * Fileio private fields
1119          */
1120         struct list_head fileio_cmd_list_entry;
1121         int fileio_in_list;
1122
1123         /* Used for storage of target driver private stuff */
1124         void *tgt_priv;
1125
1126         /* Used for storage of dev handler private stuff */
1127         void *dh_priv;
1128
1129         /* 
1130          * Used to store previous tgt_dev if dev handler returns 
1131          * SCST_CMD_STATE_REINIT state
1132          */
1133         struct scst_tgt_dev *tgt_dev_saved;
1134
1135         struct scst_cmd *orig_cmd; /* Used to issue REQUEST SENSE */
1136 };
1137
1138 struct scst_mgmt_cmd
1139 {
1140         /* List entry for *_mgmt_cmd_list */
1141         struct list_head mgmt_cmd_list_entry;
1142
1143         struct scst_session *sess;
1144
1145         /* Mgmt cmd state, one of SCST_MGMT_CMD_STATE_* constants */
1146         int state;
1147
1148         int fn;
1149
1150         unsigned int completed:1;       /* set, if the mcmd is completed */
1151
1152         /* Number of commands to complete before sending response */
1153         int cmd_wait_count;
1154
1155         /* Number of completed commands */
1156         int completed_cmd_count;
1157
1158         lun_t lun;      /* LUN for this mgmt cmd */
1159         /* or */
1160         uint32_t tag;   /* tag of the corresponding cmd */
1161
1162         /* corresponding cmd (to be aborted, found by tag) */
1163         struct scst_cmd *cmd_to_abort;
1164
1165         /* corresponding device for this mgmt cmd (found by lun) */
1166         struct scst_tgt_dev *mcmd_tgt_dev;
1167
1168         /* completition status, one of the SCST_MGMT_STATUS_* constants */
1169         int status;
1170
1171         /* Used for storage of target driver private stuff */
1172         void *tgt_priv;
1173 };
1174
1175 struct scst_device
1176 {
1177         struct scst_dev_type *handler;  /* corresponding dev handler */
1178
1179         /* Used to translate SCSI's cmd to SCST's cmd */
1180         struct gendisk *rq_disk;
1181
1182         /*************************************************************
1183          ** Dev's flags. Updates serialized by dev_lock or suspended
1184          ** activity
1185          *************************************************************/
1186
1187         /* Set if dev is RESERVED */
1188         unsigned int dev_reserved:1;
1189
1190         /* Set if dev accepts only one command at time  */
1191         unsigned int dev_serialized:1;
1192
1193         /* Set if double reset UA is possible */
1194         unsigned int dev_double_ua_possible:1;
1195
1196         /* Set if reset UA sent (to avoid double reset UAs) */
1197         unsigned int dev_reset_ua_sent:1;
1198
1199         /**************************************************************/
1200
1201         spinlock_t dev_lock;            /* device lock */
1202
1203         /* 
1204          * How many times device was blocked for new cmds execution.
1205          * Protected by dev_lock
1206          */
1207         int block_count;
1208
1209         /* 
1210          * How many there are "on_dev" commands, i.e. ones those are being
1211          * executed by the underlying SCSI/virtual device.
1212          */
1213         atomic_t on_dev_count;
1214
1215         struct list_head blocked_cmd_list; /* protected by dev_lock */
1216         
1217         /* Corresponding real SCSI device, could be NULL for virtual devices */
1218         struct scsi_device *scsi_dev;
1219         
1220         /* Used for storage of dev handler private stuff */
1221         void *dh_priv;
1222
1223         /* Used to wait for requested amount of "on_dev" commands */
1224         wait_queue_head_t on_dev_waitQ;
1225
1226         /* A list entry used during RESETs, protected by scst_mutex */
1227         struct list_head reset_dev_list_entry;
1228
1229         /* Virtual device internal ID */
1230         int virt_id;
1231         
1232         /* Pointer to virtual device name, for convenience only */
1233         const char *virt_name;
1234         
1235         /* List entry in global devices list */
1236         struct list_head dev_list_entry;
1237         
1238         /*
1239          * List of tgt_dev's, one per session, protected by scst_mutex and
1240          * suspended activity
1241          */
1242         struct list_head dev_tgt_dev_list;
1243         
1244         /* List of acg_dev's, one per acg, protected by scst_mutex */
1245         struct list_head dev_acg_dev_list;
1246 };
1247
1248 /* 
1249  * Used to store per-session specific device information
1250  */
1251 struct scst_tgt_dev
1252 {
1253         /* List entry in sess->sess_tgt_dev_list */
1254         struct list_head sess_tgt_dev_list_entry;
1255         
1256         struct scst_acg_dev *acg_dev;   /* corresponding acg_dev */
1257
1258         /* 
1259          * How many cmds alive on this dev in this session.
1260          * Protected by scst_list_lock.
1261          */
1262         int cmd_count; 
1263
1264         spinlock_t tgt_dev_lock;        /* per-session device lock */
1265
1266         /* List of UA's for this device, protected by tgt_dev_lock */
1267         struct list_head UA_list;
1268
1269         unsigned long tgt_dev_flags;    /* tgt_dev's flags */
1270         
1271         /* Used for storage of dev handler private stuff */
1272         void *dh_priv;
1273
1274         /* 
1275          * Used to execute cmd's in order of arrival.
1276          *
1277          * Protected by sn_lock, except next_sn and expected_sn.
1278          * Expected_sn protected by itself, since only one thread, which
1279          * processes SN matching command, can increment it at any time.
1280          * Next_sn must be the same type as expected_sn to overflow
1281          * simultaneously.
1282          */
1283         int next_sn; /* protected by scst_list_lock */
1284         int expected_sn;
1285         spinlock_t sn_lock;
1286         int def_cmd_count;
1287         struct list_head deferred_cmd_list;
1288         struct list_head skipped_sn_list;
1289         
1290         struct scst_session *sess;      /* corresponding session */
1291         
1292         /* list entry in dev->dev_tgt_dev_list */
1293         struct list_head dev_tgt_dev_list_entry;
1294         
1295         /* internal tmp list entry */
1296         struct list_head extra_tgt_dev_list_entry;
1297 };
1298
1299 /*
1300  * Used to store ACG-specific device information, like LUN
1301  */
1302 struct scst_acg_dev
1303 {
1304         struct scst_device *dev; /* corresponding device */
1305         lun_t lun;              /* device's LUN in this acg */
1306         unsigned int rd_only_flag:1; /* if != 0, then read only */
1307         struct scst_acg *acg;   /* parent acg */
1308         
1309         /* list entry in dev->dev_acg_dev_list */
1310         struct list_head dev_acg_dev_list_entry;
1311         
1312         /* list entry in acg->acg_dev_list */
1313         struct list_head acg_dev_list_entry;
1314 };
1315
1316 /*
1317  * ACG - access control group. Used to store group related
1318  * control information.
1319  */
1320 struct scst_acg
1321 {
1322         /* List of acg_dev's in this acg, protected by scst_mutex */
1323         struct list_head acg_dev_list;
1324
1325         /* List of attached sessions, protected by scst_mutex */
1326         struct list_head acg_sess_list;
1327
1328         /* List of attached acn's, protected by scst_mutex */
1329         struct list_head acn_list;
1330
1331         /* List entry in scst_acg_list */
1332         struct list_head scst_acg_list_entry;
1333
1334         /* Name of this acg */
1335         const char *acg_name;
1336
1337         /* The pointer to the /proc directory entry */
1338         struct proc_dir_entry *acg_proc_root;
1339 };
1340
1341 /*
1342  * ACN - access control name. Used to store names, by which
1343  * incoming sessions will be assigned to appropriate ACG.
1344  */
1345 struct scst_acn
1346 {
1347         /* Initiator's name */
1348         const char *name;
1349         /* List entry in acg->acn_list */
1350         struct list_head acn_list_entry;
1351 };
1352
1353 /* 
1354  * Used to store per-session UNIT ATTENTIONs
1355  */
1356 struct scst_tgt_dev_UA
1357 {
1358         /* List entry in tgt_dev->UA_list */
1359         struct list_head UA_list_entry;
1360         /* Unit Attention sense */
1361         uint8_t UA_sense_buffer[SCSI_SENSE_BUFFERSIZE];
1362 };
1363
1364 enum scst_cdb_flags
1365 {
1366         SCST_TRANSFER_LEN_TYPE_FIXED = 0x01, /* must be equviv 1 (FIXED_BIT in cdb) */
1367         SCST_SMALL_TIMEOUT = 0x02,
1368         SCST_LONG_TIMEOUT = 0x04,
1369         SCST_UNKNOWN_LENGTH = 0x08,
1370 };
1371
1372 struct scst_info_cdb
1373 {
1374         enum scst_cdb_flags flags;
1375         scst_data_direction direction;
1376         unsigned int transfer_len;
1377         unsigned short cdb_len;
1378         const char *op_name;
1379 };
1380
1381 /*
1382  * Sense data for the appropriate errors. Can be used with
1383  * scst_set_cmd_error()
1384  */
1385 #define scst_sense_no_sense                     NO_SENSE,        0x00, 0
1386 #define scst_sense_hardw_error                  HARDWARE_ERROR,  0x44, 0
1387 #define scst_sense_aborted_command              ABORTED_COMMAND, 0x00, 0
1388 #define scst_sense_invalid_opcode               ILLEGAL_REQUEST, 0x20, 0
1389 #define scst_sense_invalid_field_in_cdb         ILLEGAL_REQUEST, 0x24, 0
1390 #define scst_sense_invalid_field_in_parm_list   ILLEGAL_REQUEST, 0x26, 0
1391 #define scst_sense_reset_UA                     UNIT_ATTENTION,  0x29, 0
1392 #define scst_sense_nexus_loss_UA                UNIT_ATTENTION,  0x29, 0x7
1393 #define scst_sense_saving_params_unsup          ILLEGAL_REQUEST, 0x39, 0
1394 #define scst_sense_lun_not_supported            ILLEGAL_REQUEST, 0x25, 0
1395 #define scst_sense_data_protect                 DATA_PROTECT,    0x00, 0
1396 #define scst_sense_miscompare_error             MISCOMPARE,      0x1D, 0
1397 #define scst_sense_block_out_range_error        ILLEGAL_REQUEST, 0x21, 0
1398 #define scst_sense_medium_changed_UA            UNIT_ATTENTION,  0x28, 0
1399 #define scst_sense_read_error                   MEDIUM_ERROR,    0x11, 0
1400 #define scst_sense_write_error                  MEDIUM_ERROR,    0x03, 0
1401 #define scst_sense_not_ready                    NOT_READY,       0x04, 0x10
1402
1403 #ifndef smp_mb__after_set_bit
1404 /* There is no smp_mb__after_set_bit() in the kernel */
1405 #define smp_mb__after_set_bit()                 smp_mb();
1406 #endif
1407
1408 /* 
1409  * Registers target template
1410  * Returns 0 on success or appropriate error code otherwise
1411  */
1412 int scst_register_target_template(struct scst_tgt_template *vtt);
1413
1414 /* 
1415  * Unregisters target template
1416  */
1417 void scst_unregister_target_template(struct scst_tgt_template *vtt);
1418
1419 /* 
1420  * Registers and returns target adapter
1421  * Returns new target structure on success or NULL otherwise
1422  */
1423 struct scst_tgt *scst_register(struct scst_tgt_template *vtt);
1424
1425 /* 
1426  * Unregisters target adapter
1427  */
1428 void scst_unregister(struct scst_tgt *tgt);
1429
1430 /* 
1431  * Registers and returns a session
1432  *
1433  * Returns new session on success or NULL otherwise
1434  *
1435  * Parameters:
1436  *   tgt    - target
1437  *   atomic - true, if the function called in the atomic context
1438  *   initiator_name - remote initiator's name, any NULL-terminated string,
1439  *      e.g. iSCSI name, which used as the key to found appropriate access
1440  *      control group. Could be NULL, then "default" group is used. 
1441  *      The groups are set up via /proc interface.
1442  *   data - any target driver supplied data
1443  *   result_fn - pointer to the function that will be 
1444  *      asynchronously called when session initialization finishes.
1445  *      Can be NULL. Parameters:
1446  *       - sess - session
1447  *       - data - target driver supplied to scst_register_session() data
1448  *       - result - session initialization result, 0 on success or 
1449  *                  appropriate error code otherwise
1450  *
1451  * Note: A session creation and initialization is a complex task, 
1452  *       which requires sleeping state, so it can't be fully done
1453  *       in interrupt context. Therefore the "bottom half" of it, if
1454  *       scst_register_session() is called from atomic context, will be
1455  *       done in SCST thread context. In this case scst_register_session()
1456  *       will return not completely initialized session, but the target
1457  *       driver can supply commands to this session via scst_rx_cmd().
1458  *       Those commands processing will be delayed inside SCST until
1459  *       the session initialization is finished, then their processing
1460  *       will be restarted. The target driver will be notified about
1461  *       finish of the session initialization by function result_fn(). 
1462  *       On success the target driver could do nothing, but if the
1463  *       initialization fails, the target driver must ensure that
1464  *       no more new commands being sent or will be sent to SCST after
1465  *       result_fn() returns. All already sent to SCST commands for
1466  *       failed session will be returned in xmit_response() with BUSY status.
1467  *       In case of failure the driver shall call scst_unregister_session()
1468  *       inside result_fn(), it will NOT be called automatically.
1469  */
1470 struct scst_session *scst_register_session(struct scst_tgt *tgt, int atomic,
1471         const char *initiator_name, void *data,
1472         void (*result_fn) (struct scst_session *sess, void *data, int result));
1473
1474 /* 
1475  * Unregisters a session.
1476  * Parameters:
1477  *   sess - session to be unregistered
1478  *   wait - if true, instructs to wait until all commands, which
1479  *      currently is being executed and belonged to the session, finished.
1480  *      Otherwise, target driver should be prepared to receive
1481  *      xmit_response() for the session's command after 
1482  *      scst_unregister_session() returns.
1483  *   unreg_done_fn - pointer to the function that will be 
1484  *      asynchronously called when the last session's command finishes and
1485  *      the session is about to be completely freed. Can be NULL. 
1486  *      Parameter:
1487  *       - sess - session
1488  *
1489  * Note: All outstanding commands will be finished regularly. After
1490  *       scst_unregister_session() returned no new commands must be sent to
1491  *       SCST via scst_rx_cmd(). Also, the caller must ensure that no
1492  *       scst_rx_cmd() or scst_rx_mgmt_fn_*() is called in paralell with
1493  *       scst_unregister_session().
1494  *       Can be called before result_fn() of scst_register_session() called,
1495  *       i.e. during the session registration/initialization.
1496  */
1497 void scst_unregister_session(struct scst_session *sess, int wait,
1498         void (*unreg_done_fn) (struct scst_session *sess));
1499
1500 /* 
1501  * Registers dev handler driver
1502  * Returns 0 on success or appropriate error code otherwise
1503  */
1504 int scst_register_dev_driver(struct scst_dev_type *dev_type);
1505
1506 /* 
1507  * Unregisters dev handler driver
1508  */
1509 void scst_unregister_dev_driver(struct scst_dev_type *dev_type);
1510
1511 /* 
1512  * Registers dev handler driver for virtual devices (eg FILEIO)
1513  * Returns 0 on success or appropriate error code otherwise
1514  */
1515 int scst_register_virtual_dev_driver(struct scst_dev_type *dev_type);
1516
1517 /* 
1518  * Unregisters dev handler driver for virtual devices
1519  */
1520 void scst_unregister_virtual_dev_driver(struct scst_dev_type *dev_type);
1521
1522 /* 
1523  * Creates and sends new command to SCST.
1524  * Must not been called in parallel with scst_unregister_session() for the
1525  * same sess. Returns the command on success or NULL otherwise
1526  */
1527 struct scst_cmd *scst_rx_cmd(struct scst_session *sess,
1528                              const uint8_t *lun, int lun_len,
1529                              const uint8_t *cdb, int cdb_len, int atomic);
1530
1531 /* 
1532  * Notifies SCST that the driver finished its part of the command 
1533  * initialization, and the command is ready for execution.
1534  * The second argument sets preferred command execition context. 
1535  * See SCST_CONTEXT_* constants for details
1536  */
1537 void scst_cmd_init_done(struct scst_cmd *cmd, int pref_context);
1538
1539 /* 
1540  * Notifies SCST that the driver received all the necessary data 
1541  * and the command is ready for further processing.
1542  * The second argument sets data receiving completion status
1543  * (see SCST_RX_STATUS_* constants for details)
1544  * The third argument sets preferred command execition context
1545  * (see SCST_CONTEXT_* constants for details)
1546  */
1547 void scst_rx_data(struct scst_cmd *cmd, int status, int pref_context);
1548
1549 /* 
1550  * Notifies SCST that the driver sent the response and the command
1551  * can be freed now.
1552  */
1553 void scst_tgt_cmd_done(struct scst_cmd *cmd);
1554
1555 /* 
1556  * Creates new management command using tag and sends it for execution.
1557  * Can be used for SCST_ABORT_TASK only.
1558  * Must not been called in parallel with scst_unregister_session() for the 
1559  * same sess. Returns 0 for success, error code otherwise.
1560  */
1561 int scst_rx_mgmt_fn_tag(struct scst_session *sess, int fn, uint32_t tag,
1562                        int atomic, void *tgt_priv);
1563
1564 /* 
1565  * Creates new management command using LUN and sends it for execution.
1566  * Currently can be used for any fn, except SCST_ABORT_TASK.
1567  * Must not been called in parallel with scst_unregister_session() for the 
1568  * same sess. Returns 0 for success, error code otherwise.
1569  */
1570 int scst_rx_mgmt_fn_lun(struct scst_session *sess, int fn,
1571                         const uint8_t *lun, int lun_len,
1572                         int atomic, void *tgt_priv);
1573
1574 /*
1575  * Provides various CDB info
1576  * Parameters:
1577  *   cdb_p - pointer to CDB
1578  *   dev_type - SCSI device type
1579  *   info_p - the result structure (output)
1580  * Returns 0 on success, -1 otherwise
1581  */
1582 int scst_get_cdb_info(const uint8_t *cdb_p, int dev_type,
1583                       struct scst_info_cdb *info_p);
1584
1585 /* 
1586  * Set error SCSI status in the command and prepares it for returning it
1587  */
1588 void scst_set_cmd_error_status(struct scst_cmd *cmd, int status);
1589
1590 /* 
1591  * Set error in the command and fill the sense buffer
1592  */
1593 void scst_set_cmd_error(struct scst_cmd *cmd, int key, int asc, int ascq);
1594
1595 /* 
1596  * Sets BUSY or TASK QUEUE FULL status
1597  */
1598 void scst_set_busy(struct scst_cmd *cmd);
1599
1600 /* 
1601  * Finds a command based on the supplied tag comparing it with one
1602  * that previously set by scst_cmd_set_tag(). 
1603  * Returns the command on success or NULL otherwise
1604  */
1605 struct scst_cmd *scst_find_cmd_by_tag(struct scst_session *sess, uint32_t tag);
1606
1607 /* 
1608  * Finds a command based on user supplied data and comparision
1609  * callback function, that should return true, if the command is found.
1610  * Returns the command on success or NULL otherwise
1611  */
1612 struct scst_cmd *scst_find_cmd(struct scst_session *sess, void *data,
1613                                int (*cmp_fn) (struct scst_cmd *cmd,
1614                                               void *data));
1615
1616 /*
1617  * Translates SCST's data direction to DMA one
1618  */
1619 static inline int scst_to_dma_dir(int scst_dir)
1620 {
1621         return scst_dir;
1622 }
1623
1624 /*
1625  * Translates SCST data direction to DMA one from the perspective
1626  * of the target device.
1627  */
1628 static inline int scst_to_tgt_dma_dir(int scst_dir)
1629 {
1630         if (scst_dir == SCST_DATA_WRITE)
1631                 return DMA_FROM_DEVICE;
1632         else if (scst_dir == SCST_DATA_READ)
1633                 return DMA_TO_DEVICE;
1634         return scst_dir;
1635 }
1636
1637 /*
1638  * Registers a virtual device.
1639  * Parameters:
1640  *   dev_type - the device's device handler
1641  *   dev_name - the new device name, NULL-terminated string. Must be uniq
1642  *              among all virtual devices in the system. The value isn't
1643  *              copied, only the reference is stored, so the value must
1644  *              remain valid during the device lifetime.
1645  * Returns assinged to the device ID on success, or negative value otherwise
1646  */
1647 int scst_register_virtual_device(struct scst_dev_type *dev_handler, 
1648         const char *dev_name);
1649
1650 /*
1651  * Unegisters a virtual device.
1652  * Parameters:
1653  *   id - the device's ID, returned by the registration function
1654  */
1655 void scst_unregister_virtual_device(int id);
1656
1657 /*
1658  * Get/Set functions for tgt's target private data
1659  */
1660 static inline void *scst_tgt_get_tgt_priv(struct scst_tgt *tgt)
1661 {
1662         return tgt->tgt_priv;
1663 }
1664
1665 static inline void scst_tgt_set_tgt_priv(struct scst_tgt *tgt, void *val)
1666 {
1667         tgt->tgt_priv = val;
1668 }
1669
1670 /*
1671  * Get/Set functions for session's target private data
1672  */
1673 static inline void *scst_sess_get_tgt_priv(struct scst_session *sess)
1674 {
1675         return sess->tgt_priv;
1676 }
1677
1678 static inline void scst_sess_set_tgt_priv(struct scst_session *sess,
1679                                               void *val)
1680 {
1681         sess->tgt_priv = val;
1682 }
1683
1684 /* Returns TRUE if cmd is being executed in atomic context */
1685 static inline int scst_cmd_atomic(struct scst_cmd *cmd)
1686 {
1687         int res = cmd->atomic;
1688 #ifdef EXTRACHECKS
1689         if (unlikely(in_atomic() && !res)) {
1690                 printk(KERN_ERR "ERROR: in_atomic() and non-atomic cmd\n");
1691                 dump_stack();
1692                 cmd->atomic = 1;
1693                 res = 1;
1694         }
1695 #endif
1696         return res;
1697 }
1698
1699 /* Returns cmd's session */
1700 static inline struct scst_session *scst_cmd_get_session(struct scst_cmd *cmd)
1701 {
1702         return cmd->sess;
1703 }
1704
1705 /* Returns cmd's response data length */
1706 static inline int scst_cmd_get_resp_data_len(struct scst_cmd *cmd)
1707 {
1708         return cmd->resp_data_len;
1709 }
1710
1711 /* Returns cmd's response flags (SCST_TSC_FLAG_* constants) */
1712 static inline int scst_cmd_get_tgt_resp_flags(struct scst_cmd *cmd)
1713 {
1714         return cmd->tgt_resp_flags;
1715 }
1716
1717 /*
1718  * Returns pointer to cmd's SG data buffer.
1719  *
1720  * Usage of this function is not recommended, use scst_get_buf_*()
1721  * family of functions instead.
1722  */
1723 static inline struct scatterlist *scst_cmd_get_sg(struct scst_cmd *cmd)
1724 {
1725         return cmd->sg;
1726 }
1727
1728 /*
1729  * Returns cmd's data buffer length.
1730  *
1731  * In case if you need to iterate over data in the buffer, usage of
1732  * this function is not recommended, use scst_get_buf_*()
1733  * family of functions instead.
1734  */
1735 static inline unsigned int scst_cmd_get_bufflen(struct scst_cmd *cmd)
1736 {
1737         return cmd->bufflen;
1738 }
1739
1740 /* 
1741  * Returns cmd's sg_cnt.
1742  *
1743  * Usage of this function is not recommended, use scst_get_buf_*()
1744  * family of functions instead.
1745  */
1746 static inline unsigned short scst_cmd_get_sg_cnt(struct scst_cmd *cmd)
1747 {
1748         return cmd->sg_cnt;
1749 }
1750
1751 /* Returns cmd's data direction */
1752 static inline scst_data_direction scst_cmd_get_data_direction(
1753         struct scst_cmd *cmd)
1754 {
1755         return cmd->data_direction;
1756 }
1757
1758 /* Returns cmd's relative data offset */
1759 static inline unsigned int scst_cmd_get_offset(struct scst_cmd *cmd)
1760 {
1761         return 0;
1762 }
1763
1764 /* Returns cmd's status byte from host device */
1765 static inline uint8_t scst_cmd_get_status(struct scst_cmd *cmd)
1766 {
1767         return cmd->status;
1768 }
1769
1770 /* Returns cmd's status byte set from host device by status_byte() */
1771 static inline uint8_t scst_cmd_get_masked_status(struct scst_cmd *cmd)
1772 {
1773         return cmd->masked_status;
1774 }
1775
1776 /* Returns cmd's status from host adapter itself */
1777 static inline uint8_t scst_cmd_get_msg_status(struct scst_cmd *cmd)
1778 {
1779         return cmd->msg_status;
1780 }
1781
1782 /* Returns cmd's status set by low-level driver to indicate its status */
1783 static inline uint16_t scst_cmd_get_host_status(struct scst_cmd *cmd)
1784 {
1785         return cmd->host_status;
1786 }
1787
1788 /* Returns cmd's status set by SCSI mid-level */
1789 static inline uint16_t scst_cmd_get_driver_status(struct scst_cmd *cmd)
1790 {
1791         return cmd->driver_status;
1792 }
1793
1794 /* Returns pointer to cmd's sense buffer */
1795 static inline uint8_t *scst_cmd_get_sense_buffer(struct scst_cmd *cmd)
1796 {
1797         return cmd->sense_buffer;
1798 }
1799
1800 /* Returns cmd's sense buffer length */
1801 static inline int scst_cmd_get_sense_buffer_len(struct scst_cmd *cmd)
1802 {
1803         return sizeof(cmd->sense_buffer);
1804 }
1805
1806 /*
1807  * Get/Set functions for cmd's target SN
1808  */
1809 static inline uint32_t scst_cmd_get_tag(struct scst_cmd *cmd)
1810 {
1811         return cmd->tag;
1812 }
1813
1814 static inline void scst_cmd_set_tag(struct scst_cmd *cmd, uint32_t tag)
1815 {
1816         cmd->tag = tag;
1817 }
1818
1819 /*
1820  * Get/Set functions for cmd's target private data.
1821  * Variant with *_lock must be used if target driver uses
1822  * scst_find_cmd() to avoid race with it, except inside scst_find_cmd()'s
1823  * callback, where lock is already taken.
1824  */
1825 static inline void *scst_cmd_get_tgt_priv(struct scst_cmd *cmd)
1826 {
1827         return cmd->tgt_priv;
1828 }
1829
1830 static inline void scst_cmd_set_tgt_priv(struct scst_cmd *cmd, void *val)
1831 {
1832         cmd->tgt_priv = val;
1833 }
1834
1835 void *scst_cmd_get_tgt_priv_lock(struct scst_cmd *cmd);
1836 void scst_cmd_set_tgt_priv_lock(struct scst_cmd *cmd, void *val);
1837
1838 /*
1839  * Get/Set functions for data_buf_tgt_alloc flag
1840  */
1841 static inline int scst_cmd_get_data_buf_tgt_alloc(struct scst_cmd *cmd)
1842 {
1843         return cmd->data_buf_tgt_alloc;
1844 }
1845
1846 static inline void scst_cmd_set_data_buf_tgt_alloc(struct scst_cmd *cmd)
1847 {
1848         cmd->data_buf_tgt_alloc = 1;
1849 }
1850
1851 /*
1852  * Get/Set functions for data_buf_alloced flag
1853  */
1854 static inline int scst_cmd_get_data_buff_alloced(struct scst_cmd *cmd)
1855 {
1856         return cmd->data_buf_alloced;
1857 }
1858
1859 static inline void scst_cmd_set_data_buff_alloced(struct scst_cmd *cmd)
1860 {
1861         cmd->data_buf_alloced = 1;
1862 }
1863
1864 /*
1865  * Returns 1 if the cmd was aborted, so its status is invalid and no
1866  * reply shall be sent to the remote initiator. A target driver should
1867  * only clear internal resources, associated with cmd.
1868  */
1869 static inline int scst_cmd_aborted(struct scst_cmd *cmd)
1870 {
1871         return test_bit(SCST_CMD_ABORTED, &cmd->cmd_flags) &&
1872                 !test_bit(SCST_CMD_ABORTED_OTHER, &cmd->cmd_flags);
1873 }
1874
1875 /*
1876  * Get/Set functions for expected data direction, transfer length
1877  * and its validity flag
1878  */
1879 static inline int scst_cmd_is_expected_set(struct scst_cmd *cmd)
1880 {
1881         return cmd->expected_values_set;
1882 }
1883  
1884 static inline scst_data_direction scst_cmd_get_expected_data_direction(
1885         struct scst_cmd *cmd)
1886 {
1887         return cmd->expected_data_direction;
1888 }
1889
1890 static inline unsigned int scst_cmd_get_expected_transfer_len(
1891         struct scst_cmd *cmd)
1892 {
1893         return cmd->expected_transfer_len;
1894 }
1895
1896 static inline void scst_cmd_set_expected(struct scst_cmd *cmd,
1897         scst_data_direction expected_data_direction,
1898         unsigned int expected_transfer_len)
1899 {
1900         cmd->expected_data_direction = expected_data_direction;
1901         cmd->expected_transfer_len = expected_transfer_len;
1902         cmd->expected_values_set = 1;
1903 }
1904
1905 /*
1906  * Get/clear functions for cmd's may_need_dma_sync
1907  */
1908 static inline int scst_get_may_need_dma_sync(struct scst_cmd *cmd)
1909 {
1910         return cmd->may_need_dma_sync;
1911 }
1912
1913 static inline void scst_clear_may_need_dma_sync(struct scst_cmd *cmd)
1914 {
1915         cmd->may_need_dma_sync = 0;
1916 }
1917
1918 /*
1919  * Get/Set function for mgmt cmd's target private data
1920  */
1921 static inline void *scst_mgmt_cmd_get_tgt_priv(struct scst_mgmt_cmd *mcmd)
1922 {
1923         return mcmd->tgt_priv;
1924 }
1925
1926 static inline void scst_mgmt_cmd_set_tgt_priv(struct scst_mgmt_cmd *mcmd,
1927         void *val)
1928 {
1929         mcmd->tgt_priv = val;
1930 }
1931
1932 /*
1933  * Returns mgmt cmd's completition status (SCST_MGMT_STATUS_* constants)
1934  */
1935 static inline int scst_mgmt_cmd_get_status(struct scst_mgmt_cmd *mcmd)
1936 {
1937         return mcmd->status;
1938 }
1939
1940 /*
1941  * Functions for access to the commands data (SG) buffer,
1942  * including HIGHMEM environment. Should be used instead of direct
1943  * access. Returns the mapped buffer length for success, 0 for EOD,
1944  * negative error code otherwise. 
1945  *
1946  * "Buf" argument returns the mapped buffer
1947  *
1948  * The "put" function unmaps the buffer.
1949  */
1950 int __scst_get_buf(struct scst_cmd *cmd, uint8_t **buf);
1951 static inline int scst_get_buf_first(struct scst_cmd *cmd, uint8_t **buf)
1952 {
1953         cmd->get_sg_buf_entry_num = 0;
1954         cmd->may_need_dma_sync = 1;
1955         return __scst_get_buf(cmd, buf);
1956 }
1957
1958 static inline int scst_get_buf_next(struct scst_cmd *cmd, uint8_t **buf)
1959 {
1960         return __scst_get_buf(cmd, buf);
1961 }
1962
1963 static inline void scst_put_buf(struct scst_cmd *cmd, void *buf)
1964 {
1965 #ifdef SCST_HIGHMEM
1966         if (cmd->sg_cnt) {
1967                 if (scst_cmd_atomic(cmd)) {
1968                         enum km_type km;
1969                         BUG_ON(in_irq());
1970                         if (in_softirq())
1971                                 km = KM_SOFTIRQ0;
1972                         else
1973                                 km = KM_USER0;
1974                         kunmap_atomic(buf, km);
1975                 } else
1976                         kunmap(buf);
1977         }
1978 #endif
1979 }
1980
1981 /*
1982  * Returns approximate higher rounded buffers count that 
1983  * scst_get_buf_[first|next]() return.
1984  */
1985 static inline int scst_get_buf_count(struct scst_cmd *cmd)
1986 {
1987         int res;
1988 #ifdef SCST_HIGHMEM
1989         res = (cmd->bufflen >> PAGE_SHIFT) + 1;
1990 #else
1991         res = (cmd->sg_cnt == 0) ? 1 : cmd->sg_cnt;
1992 #endif
1993         return res;
1994 }
1995
1996 /* 
1997  * Suspends and resumes any activity. 
1998  * scst_suspend_activity() doesn't return until there are any
1999  * active commands (state after SCST_CMD_STATE_INIT). New arriving
2000  * commands stay in that state until scst_resume_activity() is called.
2001  */
2002 void scst_suspend_activity(void);
2003 void scst_resume_activity(void);
2004
2005 /* 
2006  * Returns target driver's root entry in SCST's /proc hierarchy.
2007  * The driver can create own files/directoryes here, which should
2008  * be deleted in the driver's release().
2009  */
2010 static inline struct proc_dir_entry *scst_proc_get_tgt_root(
2011         struct scst_tgt_template *vtt)
2012 {
2013         return vtt->proc_tgt_root;
2014 }
2015
2016 /* 
2017  * Returns device handler's root entry in SCST's /proc hierarchy.
2018  * The driver can create own files/directoryes here, which should
2019  * be deleted in the driver's detach()/release().
2020  */
2021 static inline struct proc_dir_entry *scst_proc_get_dev_type_root(
2022         struct scst_dev_type *dtt)
2023 {
2024         return dtt->proc_dev_type_root;
2025 }
2026
2027 /**
2028  ** Two library functions and the structure to help the drivers 
2029  ** that use scst_debug.* facilities manage "trace_level" /proc entry.
2030  ** The functions service "standard" log levels and allow to work
2031  ** with driver specific levels, which should be passed inside as
2032  ** NULL-terminated array of struct scst_proc_log's, where:
2033  **   - val - the level's numeric value
2034  **   - token - its string representation
2035  **/
2036
2037 struct scst_proc_log {
2038         unsigned int val;
2039         const char *token;
2040 };
2041
2042 int scst_proc_log_entry_read(char *buffer, char **start,
2043         off_t offset, int length, int *eof, void *data,
2044         unsigned long log_level, const struct scst_proc_log *tbl);
2045
2046 int scst_proc_log_entry_write(struct file *file, const char *buf,
2047         unsigned long length, void *data, unsigned long *log_level,
2048         unsigned long default_level, const struct scst_proc_log *tbl);
2049
2050 /*
2051  * Adds and deletes (stops) num SCST's threads. Returns 0 on success,
2052  * error code otherwise.
2053  */
2054 int scst_add_threads(int num);
2055 void scst_del_threads(int num);
2056
2057 void scst_set_cmd_error_sense(struct scst_cmd *cmd, uint8_t *sense, 
2058         unsigned int len);
2059
2060 /*
2061  * Returnes a pseudo-random number for debugging purposes. Available only with
2062  * DEBUG on
2063  */
2064 unsigned long scst_random(void);
2065
2066 /*
2067  * Sets response data length for cmd and truncates its SG vector accordingly.
2068  * The cmd->resp_data_len must not be set directly, it must be set only
2069  * using this function. Value of resp_data_len must be <= cmd->bufflen.
2070  */
2071 void scst_set_resp_data_len(struct scst_cmd *cmd, int resp_data_len);
2072
2073 /*
2074  * Checks if total memory allocated by commands is less, than defined
2075  * limit (scst_cur_max_cmd_mem) and returns 0, if it is so. Otherwise,
2076  * returnes 1 and sets on cmd QUEUE FULL or BUSY status as well as
2077  * SCST_CMD_STATE_XMIT_RESP state. Target drivers and dev handlers are
2078  * required to call this function if they allocate data buffers on their
2079  * own.
2080  */
2081 int scst_check_mem(struct scst_cmd *cmd);
2082
2083 /* 
2084  * Get/put global ref counter that prevents from entering into suspended
2085  * activities stage, so protects from any global management operations.
2086  */
2087 void scst_get(void);
2088 void scst_put(void);
2089
2090 #endif /* __SCST_H */