Update to work on 2.6.20 + minor fix
[mirror/scst/.git] / scst / src / scst_priv.h
1 /*
2  *  scst_priv.h
3  *  
4  *  Copyright (C) 2004-2006 Vladislav Bolkhovitin <vst@vlnb.net>
5  *                 and Leonid Stoljar
6  *  
7  *  This program is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU General Public License
9  *  as published by the Free Software Foundation, version 2
10  *  of the License.
11  * 
12  *  This program is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  *  GNU General Public License for more details.
16  */
17
18 #ifndef __SCST_PRIV_H
19 #define __SCST_PRIV_H
20
21 #include <linux/types.h>
22
23 #include <scsi/scsi.h>
24 #include <scsi/scsi_cmnd.h>
25 #include <scsi/scsi_driver.h>
26 #include <scsi/scsi_device.h>
27 #include <scsi/scsi_host.h>
28
29 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
30 #include <scsi/scsi_request.h>
31 #endif
32
33 #include "scst_debug.h"
34
35 #define SCST_MAJOR              177
36
37 #define TRACE_RETRY             0x80000000
38 #define TRACE_SCSI_SERIALIZING  0x40000000
39 #define TRACE_SEND_TOP          0x20000000 /** top being the edge away from the interupt */
40 #define TRACE_RECV_TOP          0x01000000 
41 #define TRACE_SEND_BOT          0x08000000 /** bottom being the edge toward the interupt */
42 #define TRACE_RECV_BOT          0x04000000
43
44 #define LOG_PREFIX "scst"
45
46 #if defined(DEBUG) || defined(TRACING)
47 #define trace_flag scst_trace_flag
48 extern unsigned long scst_trace_flag;
49 #endif
50
51 #ifdef DEBUG
52 /*#define SCST_DEFAULT_LOG_FLAGS (TRACE_ALL & ~TRACE_MEMORY & ~TRACE_BUFF \
53          & ~TRACE_FUNCTION)
54 #define SCST_DEFAULT_LOG_FLAGS (TRACE_ALL & ~TRACE_MEMORY & ~TRACE_BUFF & \
55         ~TRACE_SCSI & ~TRACE_SCSI_SERIALIZING & ~TRACE_DEBUG)
56 */
57 #define SCST_DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MINOR | TRACE_PID | \
58         TRACE_FUNCTION | TRACE_SPECIAL | TRACE_MGMT | TRACE_MGMT_DEBUG | \
59         TRACE_RETRY)
60 #else
61 # ifdef TRACING
62 #define SCST_DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MINOR | TRACE_PID | \
63         TRACE_SPECIAL)
64 # else
65 #define SCST_DEFAULT_LOG_FLAGS 0
66 # endif
67 #endif
68
69 /**
70  ** Bits for scst_flags 
71  **/
72
73 /* Set if new commands initialization should be suspended for a while */
74 #define SCST_FLAG_SUSPENDED                  0
75
76 /* Set if a TM command is being performed */
77 #define SCST_FLAG_TM_ACTIVE                  2
78
79 /* Set if scst_cmd_mem_work is scheduled */
80 #define SCST_FLAG_CMD_MEM_WORK_SCHEDULED     3
81
82 /** 
83  ** Return codes for cmd state process functions 
84  **/
85 #define SCST_CMD_STATE_RES_CONT_SAME         0
86 #define SCST_CMD_STATE_RES_CONT_NEXT         1
87 #define SCST_CMD_STATE_RES_NEED_THREAD       2
88 #define SCST_CMD_STATE_RES_RESTART           3
89
90 /** Name of the "default" security group **/
91 #define SCST_DEFAULT_ACG_NAME                "Default"
92
93 /**
94  ** Maximum count of uncompleted commands that an initiator could 
95  ** queue on any device. Then it will take TASK QUEUE FULL status.
96  **/
97 #define SCST_MAX_DEVICE_COMMANDS           128
98
99 #define SCST_TGT_RETRY_TIMEOUT             (3/2*HZ)
100 #define SCST_CMD_MEM_TIMEOUT               (120*HZ)
101
102 static inline int scst_get_context(void) {
103         if (in_irq())
104                 return SCST_CONTEXT_TASKLET;
105         if (irqs_disabled())
106                 return SCST_CONTEXT_THREAD;
107         if (in_softirq() || in_atomic())
108                 return SCST_CONTEXT_DIRECT_ATOMIC;
109         return SCST_CONTEXT_DIRECT;
110 }
111
112 #define SCST_MGMT_CMD_CACHE_STRING "scst_mgmt_cmd"
113 extern struct kmem_cache *scst_mgmt_cachep;
114 extern mempool_t *scst_mgmt_mempool;
115
116 #define SCST_UA_CACHE_STRING "scst_ua"
117 extern struct kmem_cache *scst_ua_cachep;
118 extern mempool_t *scst_ua_mempool;
119
120 #define SCST_CMD_CACHE_STRING "scst_cmd"
121 extern struct kmem_cache *scst_cmd_cachep;
122
123 #define SCST_SESSION_CACHE_STRING "scst_session"
124 extern struct kmem_cache *scst_sess_cachep;
125
126 #define SCST_TGT_DEV_CACHE_STRING "scst_tgt_dev"
127 extern struct kmem_cache *scst_tgtd_cachep;
128
129 #define SCST_ACG_DEV_CACHE_STRING "scst_acg_dev"
130 extern struct kmem_cache *scst_acgd_cachep;
131
132 extern struct scst_sgv_pools scst_sgv;
133
134 extern unsigned long scst_flags;
135 extern struct semaphore scst_mutex;
136 extern atomic_t scst_cmd_count;
137 extern spinlock_t scst_list_lock;
138 extern struct list_head scst_dev_wait_sess_list; /* protected by scst_list_lock */
139 extern struct list_head scst_template_list; /* protected by scst_mutex */
140 extern struct list_head scst_dev_list; /* protected by scst_mutex */
141 extern struct list_head scst_dev_type_list; /* protected by scst_mutex */
142 extern wait_queue_head_t scst_dev_cmd_waitQ;
143
144 extern struct list_head scst_acg_list;
145 extern struct scst_acg *scst_default_acg;
146
147 /* The following lists protected by scst_list_lock */
148 extern struct list_head scst_active_cmd_list;
149 extern struct list_head scst_init_cmd_list;
150 extern struct list_head scst_cmd_list;
151
152 extern spinlock_t scst_cmd_mem_lock;
153 extern unsigned long scst_max_cmd_mem, scst_cur_max_cmd_mem, scst_cur_cmd_mem;
154 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
155 extern struct work_struct scst_cmd_mem_work;
156 #else
157 extern struct delayed_work scst_cmd_mem_work;
158 #endif
159
160 /* The following lists protected by scst_list_lock as well */
161 extern struct list_head scst_mgmt_cmd_list;
162 extern struct list_head scst_active_mgmt_cmd_list;
163 extern struct list_head scst_delayed_mgmt_cmd_list;
164
165 extern struct tasklet_struct scst_tasklets[NR_CPUS];
166 extern wait_queue_head_t scst_list_waitQ;
167
168 extern wait_queue_head_t scst_mgmt_cmd_list_waitQ;
169
170 extern wait_queue_head_t scst_mgmt_waitQ;
171 extern spinlock_t scst_mgmt_lock;
172 extern struct list_head scst_sess_mgmt_list;
173
174 struct scst_cmd_thread_t {
175         struct task_struct *cmd_thread;
176         struct list_head thread_list_entry;
177 };
178
179 struct scst_threads_info_t {
180         struct semaphore cmd_threads_mutex;
181         u32 nr_cmd_threads;
182         struct list_head cmd_threads_list;
183         struct task_struct *mgmt_thread;
184         struct task_struct *mgmt_cmd_thread;
185 };
186
187 extern struct scst_threads_info_t scst_threads_info;
188 extern int scst_cmd_threads_count(void);
189 extern int __scst_add_cmd_threads(int num);
190 extern void __scst_del_cmd_threads(int num);
191
192 extern spinlock_t scst_temp_UA_lock;
193 extern uint8_t scst_temp_UA[SCSI_SENSE_BUFFERSIZE];
194
195 extern struct scst_cmd *__scst_check_deferred_commands(
196         struct scst_tgt_dev *tgt_dev, int expected_sn);
197
198 /* Used to save the function call on th fast path */
199 static inline struct scst_cmd *scst_check_deferred_commands(
200         struct scst_tgt_dev *tgt_dev, int expected_sn)
201 {
202         if (tgt_dev->def_cmd_count == 0)
203                 return NULL;
204         else
205                 return __scst_check_deferred_commands(tgt_dev, expected_sn);
206 }
207
208 static inline int __scst_inc_expected_sn(struct scst_tgt_dev *tgt_dev)
209 {
210         /*
211          * No locks is needed, because only one thread at time can 
212          * call it (serialized by sn). Also it is supposed that there
213          * could not be half-incremented halves.
214          */
215
216         typeof(tgt_dev->expected_sn) e;
217
218         tgt_dev->expected_sn++;
219         e = tgt_dev->expected_sn;
220         smp_mb(); /* write must be before def_cmd_count read */
221         TRACE(TRACE_DEBUG/*TRACE_SCSI_SERIALIZING*/, "Next expected_sn: %d", e);
222         return e;
223 }
224
225 void scst_inc_expected_sn_unblock(struct scst_tgt_dev *tgt_dev,
226         struct scst_cmd *cmd_sn, int locked);
227
228 int scst_cmd_thread(void *arg);
229 void scst_cmd_tasklet(long p);
230 int scst_mgmt_cmd_thread(void *arg);
231 int scst_mgmt_thread(void *arg);
232 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
233 void scst_cmd_mem_work_fn(void *p);
234 #else
235 void scst_cmd_mem_work_fn(struct work_struct *work);
236 #endif
237
238 struct scst_device *scst_alloc_device(int gfp_mask);
239 void scst_free_device(struct scst_device *tgt_dev);
240
241 struct scst_acg *scst_alloc_add_acg(const char *acg_name);
242 int scst_destroy_acg(struct scst_acg *acg);
243
244 int scst_sess_alloc_tgt_devs(struct scst_session *sess);
245 void scst_sess_free_tgt_devs(struct scst_session *sess);
246 void scst_reset_tgt_dev(struct scst_tgt_dev *tgt_dev, int nexus_loss);
247
248 int scst_acg_add_dev(struct scst_acg *acg, struct scst_device *dev, lun_t lun,
249         int read_only);
250 int scst_acg_remove_dev(struct scst_acg *acg, struct scst_device *dev);
251
252 int scst_acg_add_name(struct scst_acg *acg, const char *name);
253 int scst_acg_remove_name(struct scst_acg *acg, const char *name);
254
255 struct scst_cmd *scst_create_prepare_internal_cmd(
256         struct scst_cmd *orig_cmd, int bufsize);
257 void scst_free_internal_cmd(struct scst_cmd *cmd);
258 int scst_prepare_request_sense(struct scst_cmd *orig_cmd);
259 struct scst_cmd *scst_complete_request_sense(struct scst_cmd *cmd);
260
261 int scst_assign_dev_handler(struct scst_device *dev, 
262         struct scst_dev_type *handler);
263
264 struct scst_session *scst_alloc_session(struct scst_tgt *tgt, int gfp_mask,
265         const char *initiator_name);
266 void scst_free_session(struct scst_session *sess);
267 void scst_free_session_callback(struct scst_session *sess);
268
269 struct scst_cmd *scst_alloc_cmd(int gfp_mask);
270 void scst_free_cmd(struct scst_cmd *cmd);
271 static inline void scst_destroy_cmd(struct scst_cmd *cmd)
272 {
273         kmem_cache_free(scst_cmd_cachep, cmd);
274         return;
275 }
276
277 void scst_proccess_redirect_cmd(struct scst_cmd *cmd, int context,
278         int check_retries);
279 void scst_check_retries(struct scst_tgt *tgt, int processible_env);
280 void scst_tgt_retry_timer_fn(unsigned long arg);
281
282 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
283 int scst_alloc_request(struct scst_cmd *cmd);
284 void scst_release_request(struct scst_cmd *cmd);
285
286 static inline void scst_do_req(struct scsi_request *sreq, 
287         const void *cmnd, void *buffer, unsigned bufflen, 
288         void (*done)(struct scsi_cmnd *), int timeout, int retries)
289 {
290     #ifdef STRICT_SERIALIZING
291         scsi_do_req(sreq, cmnd, buffer, bufflen, done, timeout, retries);
292     #elif defined(FILEIO_ONLY)
293         sBUG();
294     #else
295         scsi_do_req_fifo(sreq, cmnd, buffer, bufflen, done, timeout, retries);
296     #endif
297 }
298 #else
299 static inline int scst_exec_req(struct scsi_device *sdev,
300         const unsigned char *cmd, int cmd_len, int data_direction,
301         void *buffer, unsigned bufflen, int use_sg, int timeout, int retries,
302         void *privdata, void (*done)(void *, char *, int, int), gfp_t gfp)
303 {
304     #ifdef STRICT_SERIALIZING
305         return scsi_execute_async(sdev, cmd, cmd_len, data_direction, buffer,
306                 bufflen, use_sg, timeout, retries, privdata, done, gfp);
307     #elif defined(FILEIO_ONLY)
308         sBUG();
309         return -1;
310     #else
311         return scsi_execute_async_fifo(sdev, cmd, cmd_len, data_direction,
312                 buffer, bufflen, use_sg, timeout, retries, privdata, done, gfp);
313     #endif
314 }
315 #endif
316
317 int scst_alloc_space(struct scst_cmd *cmd);
318 void scst_release_space(struct scst_cmd *cmd);
319 void scst_scsi_op_list_init(void);
320
321 lun_t scst_unpack_lun(const uint8_t *lun, int len);
322
323 struct scst_cmd *__scst_find_cmd_by_tag(struct scst_session *sess, 
324         uint32_t tag);
325
326 struct scst_mgmt_cmd *scst_alloc_mgmt_cmd(int gfp_mask);
327 void scst_free_mgmt_cmd(struct scst_mgmt_cmd *mcmd, int del);
328
329 /* /proc support */
330 int scst_proc_init_module(void);
331 void scst_proc_cleanup_module(void);
332 int scst_build_proc_target_dir_entries(struct scst_tgt_template *vtt);
333 void scst_cleanup_proc_target_dir_entries(struct scst_tgt_template *vtt);
334 int scst_build_proc_target_entries(struct scst_tgt *vtt);
335 void scst_cleanup_proc_target_entries(struct scst_tgt *vtt);
336 int scst_build_proc_dev_handler_dir_entries(struct scst_dev_type *dev_type);
337 void scst_cleanup_proc_dev_handler_dir_entries(struct scst_dev_type *dev_type);
338
339 int scst_get_cdb_len(const uint8_t *cdb);
340
341 void __scst_process_UA(struct scst_device *dev, struct scst_cmd *exclude,
342         const uint8_t *sense, int sense_len, int internal);
343 static inline void scst_process_UA(struct scst_device *dev,
344         struct scst_cmd *exclude, const uint8_t *sense, int sense_len,
345         int internal)
346 {
347         spin_lock_bh(&dev->dev_lock);
348         __scst_process_UA(dev, exclude, sense, sense_len, internal);
349         spin_unlock_bh(&dev->dev_lock);
350         return;
351 }
352 void scst_alloc_set_UA(struct scst_tgt_dev *tgt_dev, const uint8_t *sense,
353         int sense_len);
354 void scst_check_set_UA(struct scst_tgt_dev *tgt_dev,
355         const uint8_t *sense, int sense_len);
356 int scst_set_pending_UA(struct scst_cmd *cmd);
357 void scst_free_all_UA(struct scst_tgt_dev *tgt_dev);
358
359 void scst_abort_cmd(struct scst_cmd *cmd, struct scst_mgmt_cmd *mcmd,
360         int other_ini, int call_dev_task_mgmt_fn);
361 void scst_process_reset(struct scst_device *dev,
362         struct scst_session *originator, struct scst_cmd *exclude_cmd,
363         struct scst_mgmt_cmd *mcmd);
364
365 static inline int scst_is_ua_command(struct scst_cmd *cmd)
366 {
367         return ((cmd->cdb[0] != INQUIRY) && 
368                 (cmd->cdb[0] != REQUEST_SENSE) &&
369                 (cmd->cdb[0] != REPORT_LUNS));
370 }
371
372 /*
373  * Returns 1, if cmd's CDB is locally handled by SCST and 0 otherwise.
374  * Dev handlers parse() and dev_done() not called for such commands.
375  */
376 static inline int scst_is_cmd_local(struct scst_cmd *cmd)
377 {
378         int res = 0;
379         switch (cmd->cdb[0]) {
380         case REPORT_LUNS:
381                 res = 1;
382         }
383         return res;
384 }
385
386 /*
387  * Some notes on devices "blocking". Blocking means that no
388  * commands will go from SCST to underlying SCSI device until it 
389  * is unblocked. But we don't care about all commands that 
390  * already on the device.
391  */
392
393 extern int scst_inc_on_dev_cmd(struct scst_cmd *cmd);
394 extern void scst_unblock_cmds(struct scst_device *dev);
395
396 static inline void __scst_block_dev(struct scst_device *dev)
397 {
398         dev->block_count++;
399         smp_mb();
400         TRACE_MGMT_DBG("Device BLOCK(%d), dev %p", dev->block_count, dev);
401 }
402
403 static inline void scst_block_dev(struct scst_device *dev, 
404         unsigned int outstanding)
405 {
406         spin_lock_bh(&dev->dev_lock);
407         __scst_block_dev(dev);
408         spin_unlock_bh(&dev->dev_lock);
409
410         TRACE_MGMT_DBG("Waiting during blocking outstanding %d (on_dev_count "
411                 "%d)", outstanding, atomic_read(&dev->on_dev_count));
412         wait_event(dev->on_dev_waitQ, 
413                 atomic_read(&dev->on_dev_count) <= outstanding);
414         TRACE_MGMT_DBG("%s", "wait_event() returned");
415 }
416
417 static inline void scst_unblock_dev(struct scst_device *dev)
418 {
419         spin_lock_bh(&dev->dev_lock);
420         TRACE_MGMT_DBG("Device UNBLOCK(%d), dev %p",
421                 dev->block_count-1, dev);
422         if (--dev->block_count == 0)
423                 scst_unblock_cmds(dev);
424         spin_unlock_bh(&dev->dev_lock);
425 }
426
427 static inline void scst_dec_on_dev_cmd(struct scst_cmd *cmd)
428 {
429         if (cmd->blocking) {
430                 TRACE_MGMT_DBG("cmd %p (tag %d): unblocking dev %p", cmd,
431                         cmd->tag, cmd->dev);
432                 cmd->blocking = 0;
433                 scst_unblock_dev(cmd->dev);
434         }
435         atomic_dec(&cmd->dev->on_dev_count);
436         smp_mb__after_atomic_dec();
437         if (unlikely(cmd->dev->block_count != 0))
438                 wake_up_all(&cmd->dev->on_dev_waitQ);
439 }
440
441 static inline void scst_inc_cmd_count(void)
442 {
443         atomic_inc(&scst_cmd_count);
444         /* It's needed to be before test_bit(SCST_FLAG_SUSPENDED) */
445         smp_mb__after_atomic_inc();
446         TRACE_DBG("Incrementing scst_cmd_count(%d)",
447               atomic_read(&scst_cmd_count));
448 }
449
450 static inline void scst_dec_cmd_count(void)
451 {
452         int f;
453         f = atomic_dec_and_test(&scst_cmd_count);
454         if (f && unlikely(test_bit(SCST_FLAG_SUSPENDED, &scst_flags)))
455                 wake_up_all(&scst_dev_cmd_waitQ);
456         TRACE_DBG("Decrementing scst_cmd_count(%d)",
457               atomic_read(&scst_cmd_count));
458 }
459
460 void scst_sched_session_free(struct scst_session *sess);
461
462 static inline void scst_sess_get(struct scst_session *sess)
463 {
464         atomic_inc(&sess->refcnt);
465 }
466
467 static inline void scst_sess_put(struct scst_session *sess)
468 {
469         if (atomic_dec_and_test(&sess->refcnt))
470                 scst_sched_session_free(sess);
471 }
472
473 void __scst_suspend_activity(void);
474 void __scst_resume_activity(void);
475
476 extern void scst_throttle_cmd(struct scst_cmd *cmd);
477 extern void scst_unthrottle_cmd(struct scst_cmd *cmd);
478
479 static inline void scst_set_sense(uint8_t *buffer, int len, int key,
480         int asc, int ascq)
481 {
482         memset(buffer, 0, len);
483         buffer[0] = 0x70;       /* Error Code                   */
484         buffer[2] = key;        /* Sense Key                    */
485         buffer[7] = 0x0a;       /* Additional Sense Length      */
486         buffer[12] = asc;       /* ASC                          */
487         buffer[13] = ascq;      /* ASCQ                         */
488         TRACE_BUFFER("Sense set", buffer, len);
489         return;
490 }
491
492 static inline void scst_check_restore_sg_buff(struct scst_cmd *cmd)
493 {
494         if (cmd->sg_buff_modified) {
495                 cmd->sg[cmd->orig_sg_entry].length = cmd->orig_entry_len;
496                 cmd->sg_cnt = cmd->orig_sg_cnt;
497         }
498 }
499
500 #ifdef DEBUG_TM
501 extern void tm_dbg_init_tgt_dev(struct scst_tgt_dev *tgt_dev,
502         struct scst_acg_dev *acg_dev);
503 extern void tm_dbg_deinit_tgt_dev(struct scst_tgt_dev *tgt_dev);
504 extern void tm_dbg_check_released_cmds(void);
505 extern int tm_dbg_check_cmd(struct scst_cmd *cmd);
506 extern void tm_dbg_release_cmd(struct scst_cmd *cmd);
507 extern void tm_dbg_task_mgmt(const char *fn);
508 extern int tm_dbg_is_release(void);
509 #else
510 static inline void tm_dbg_init_tgt_dev(struct scst_tgt_dev *tgt_dev,
511         struct scst_acg_dev *acg_dev) {}
512 static inline void tm_dbg_deinit_tgt_dev(struct scst_tgt_dev *tgt_dev) {}
513 static inline void tm_dbg_check_released_cmds(void) {}
514 static inline int tm_dbg_check_cmd(struct scst_cmd *cmd)
515 {
516         return 0;
517 }
518 static inline void tm_dbg_release_cmd(struct scst_cmd *cmd) {}
519 static inline void tm_dbg_task_mgmt(const char *fn) {}
520 static inline int tm_dbg_is_release(void)
521 {
522         return 0;
523 }
524 #endif /* DEBUG_TM */
525
526 #endif /* __SCST_PRIV_H */