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