Added possibility to coexist if both target driver and dev handler need custom memory...
[mirror/scst/.git] / scst / src / scst_priv.h
1 /*
2  *  scst_priv.h
3  *
4  *  Copyright (C) 2004 - 2008 Vladislav Bolkhovitin <vst@vlnb.net>
5  *  Copyright (C) 2004 - 2005 Leonid Stoljar
6  *  Copyright (C) 2007 - 2008 CMS Distribution Limited
7  *
8  *  This program is free software; you can redistribute it and/or
9  *  modify it under the terms of the GNU General Public License
10  *  as published by the Free Software Foundation, version 2
11  *  of the License.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  *  GNU General Public License for more details.
17  */
18
19 #ifndef __SCST_PRIV_H
20 #define __SCST_PRIV_H
21
22 #include <linux/types.h>
23
24 #include <scsi/scsi.h>
25 #include <scsi/scsi_cmnd.h>
26 #include <scsi/scsi_driver.h>
27 #include <scsi/scsi_device.h>
28 #include <scsi/scsi_host.h>
29
30 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
31 #include <scsi/scsi_request.h>
32 #endif
33
34 #define LOG_PREFIX "scst"
35
36 #include "scst_debug.h"
37
38 #define SCST_MAJOR              177
39
40 #define TRACE_RTRY              0x80000000
41 #define TRACE_SCSI_SERIALIZING  0x40000000
42 /** top being the edge away from the interupt */
43 #define TRACE_SND_TOP           0x20000000
44 #define TRACE_RCV_TOP           0x01000000
45 /** bottom being the edge toward the interupt */
46 #define TRACE_SND_BOT           0x08000000
47 #define TRACE_RCV_BOT           0x04000000
48
49 #if defined(CONFIG_SCST_DEBUG) || defined(CONFIG_SCST_TRACING)
50 #define trace_flag scst_trace_flag
51 extern unsigned long scst_trace_flag;
52 #endif
53
54 #ifdef CONFIG_SCST_DEBUG
55 /*#define SCST_DEFAULT_LOG_FLAGS (TRACE_ALL & ~TRACE_MEMORY & ~TRACE_BUFF \
56          & ~TRACE_FUNCTION)
57 #define SCST_DEFAULT_LOG_FLAGS (TRACE_ALL & ~TRACE_MEMORY & ~TRACE_BUFF & \
58         ~TRACE_SCSI & ~TRACE_SCSI_SERIALIZING & ~TRACE_DEBUG)
59 */
60 #define SCST_DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MINOR | TRACE_PID | \
61         TRACE_LINE | TRACE_FUNCTION | TRACE_SPECIAL | TRACE_MGMT | \
62         TRACE_MGMT_MINOR | TRACE_MGMT_DEBUG | TRACE_RTRY)
63
64 #define TRACE_RETRY(args...)            __TRACE(TRACE_RTRY, args)
65 #define TRACE_SN(args...)               __TRACE(TRACE_SCSI_SERIALIZING, args)
66 #define TRACE_SEND_TOP(args...)         __TRACE(TRACE_SND_TOP, args)
67 #define TRACE_RECV_TOP(args...)         __TRACE(TRACE_RCV_TOP, args)
68 #define TRACE_SEND_BOT(args...)         __TRACE(TRACE_SND_BOT, args)
69 #define TRACE_RECV_BOT(args...)         __TRACE(TRACE_RCV_BOT, args)
70
71 #else /* CONFIG_SCST_DEBUG */
72
73 # ifdef CONFIG_SCST_TRACING
74 #define SCST_DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MINOR | TRACE_SPECIAL)
75 # else
76 #define SCST_DEFAULT_LOG_FLAGS 0
77 # endif
78
79 #define TRACE_RETRY(args...)
80 #define TRACE_SN(args...)
81 #define TRACE_SEND_TOP(args...)
82 #define TRACE_RECV_TOP(args...)
83 #define TRACE_SEND_BOT(args...)
84 #define TRACE_RECV_BOT(args...)
85
86 #endif
87
88 /**
89  ** Bits for scst_flags
90  **/
91
92 /*
93  * Set if new commands initialization is being suspended for a while.
94  * Used to let TM commands execute while preparing the suspend, since
95  * RESET or ABORT could be necessary to free SCSI commands.
96  */
97 #define SCST_FLAG_SUSPENDING                 0
98
99 /* Set if new commands initialization is suspended for a while */
100 #define SCST_FLAG_SUSPENDED                  1
101
102 /**
103  ** Return codes for cmd state process functions. Codes are the same as
104  ** for SCST_EXEC_* to avoid translation to them and, hence, have better code.
105  **/
106 #define SCST_CMD_STATE_RES_CONT_NEXT         SCST_EXEC_COMPLETED
107 #define SCST_CMD_STATE_RES_CONT_SAME         SCST_EXEC_NOT_COMPLETED
108 #define SCST_CMD_STATE_RES_NEED_THREAD       SCST_EXEC_NEED_THREAD
109
110 /** Name of the "default" security group **/
111 #define SCST_DEFAULT_ACG_NAME                "Default"
112
113 /**
114  ** Maximum count of uncompleted commands that an initiator could
115  ** queue on any device. Then it will start getting TASK QUEUE FULL status.
116  **/
117 #define SCST_MAX_TGT_DEV_COMMANDS            48
118
119 /**
120  ** Maximum count of uncompleted commands that could be queued on any device.
121  ** Then initiators sending commands to this device will start getting
122  ** TASK QUEUE FULL status.
123  **/
124 #define SCST_MAX_DEV_COMMANDS                256
125
126 #define SCST_TGT_RETRY_TIMEOUT               (3/2*HZ)
127
128 extern unsigned int scst_max_cmd_mem;
129 extern unsigned int scst_max_dev_cmd_mem;
130
131 extern mempool_t *scst_mgmt_mempool;
132 extern mempool_t *scst_mgmt_stub_mempool;
133 extern mempool_t *scst_ua_mempool;
134 extern mempool_t *scst_sense_mempool;
135
136 extern struct kmem_cache *scst_cmd_cachep;
137 extern struct kmem_cache *scst_sess_cachep;
138 extern struct kmem_cache *scst_tgtd_cachep;
139 extern struct kmem_cache *scst_acgd_cachep;
140
141 extern spinlock_t scst_main_lock;
142
143 extern struct scst_sgv_pools scst_sgv;
144
145 extern unsigned long scst_flags;
146 extern struct mutex scst_mutex;
147 extern atomic_t scst_cmd_count;
148 extern struct list_head scst_template_list; /* protected by scst_mutex */
149 extern struct list_head scst_dev_list; /* protected by scst_mutex */
150 extern struct list_head scst_dev_type_list; /* protected by scst_mutex */
151 extern wait_queue_head_t scst_dev_cmd_waitQ;
152
153 extern struct mutex scst_suspend_mutex;
154 /* protected by scst_suspend_mutex */
155 extern struct list_head scst_cmd_lists_list;
156
157 extern struct list_head scst_acg_list;
158 extern struct scst_acg *scst_default_acg;
159
160 extern spinlock_t scst_init_lock;
161 extern struct list_head scst_init_cmd_list;
162 extern wait_queue_head_t scst_init_cmd_list_waitQ;
163 extern unsigned int scst_init_poll_cnt;
164
165 extern struct scst_cmd_lists scst_main_cmd_lists;
166
167 extern spinlock_t scst_mcmd_lock;
168 /* The following lists protected by scst_mcmd_lock */
169 extern struct list_head scst_active_mgmt_cmd_list;
170 extern struct list_head scst_delayed_mgmt_cmd_list;
171 extern wait_queue_head_t scst_mgmt_cmd_list_waitQ;
172
173 struct scst_tasklet {
174         spinlock_t tasklet_lock;
175         struct list_head tasklet_cmd_list;
176         struct tasklet_struct tasklet;
177 };
178 extern struct scst_tasklet scst_tasklets[NR_CPUS];
179
180 extern wait_queue_head_t scst_mgmt_waitQ;
181 extern spinlock_t scst_mgmt_lock;
182 extern struct list_head scst_sess_init_list;
183 extern struct list_head scst_sess_shut_list;
184
185 struct scst_cmd_thread_t {
186         struct task_struct *cmd_thread;
187         struct list_head thread_list_entry;
188 };
189
190 struct scst_threads_info_t {
191         struct mutex cmd_threads_mutex;
192         u32 nr_cmd_threads;
193         struct list_head cmd_threads_list;
194         struct task_struct *init_cmd_thread;
195         struct task_struct *mgmt_thread;
196         struct task_struct *mgmt_cmd_thread;
197 };
198
199 extern struct scst_threads_info_t scst_threads_info;
200 extern int scst_cmd_threads_count(void);
201 extern int __scst_add_cmd_threads(int num);
202 extern void __scst_del_cmd_threads(int num);
203
204 extern spinlock_t scst_temp_UA_lock;
205 extern uint8_t scst_temp_UA[SCST_SENSE_BUFFERSIZE];
206
207 extern struct scst_dev_type scst_null_devtype;
208
209 extern struct scst_cmd *__scst_check_deferred_commands(
210         struct scst_tgt_dev *tgt_dev);
211
212 /* Used to save the function call on the fast path */
213 static inline struct scst_cmd *scst_check_deferred_commands(
214         struct scst_tgt_dev *tgt_dev)
215 {
216         if (tgt_dev->def_cmd_count == 0)
217                 return NULL;
218         else
219                 return __scst_check_deferred_commands(tgt_dev);
220 }
221
222 static inline void scst_make_deferred_commands_active(
223         struct scst_tgt_dev *tgt_dev)
224 {
225         struct scst_cmd *c;
226
227         c = __scst_check_deferred_commands(tgt_dev);
228         if (c != NULL) {
229                 TRACE_SN("Adding cmd %p to active cmd list", c);
230                 spin_lock_irq(&c->cmd_lists->cmd_list_lock);
231                 list_add_tail(&c->cmd_list_entry,
232                         &c->cmd_lists->active_cmd_list);
233                 wake_up(&c->cmd_lists->cmd_list_waitQ);
234                 spin_unlock_irq(&c->cmd_lists->cmd_list_lock);
235         }
236
237         return;
238 }
239
240 void scst_inc_expected_sn(struct scst_tgt_dev *tgt_dev, atomic_t *slot);
241 int scst_check_hq_cmd(struct scst_cmd *cmd);
242
243 void scst_unblock_deferred(struct scst_tgt_dev *tgt_dev,
244         struct scst_cmd *cmd_sn);
245
246 void scst_on_hq_cmd_response(struct scst_cmd *cmd);
247 void scst_xmit_process_aborted_cmd(struct scst_cmd *cmd);
248
249 int scst_cmd_thread(void *arg);
250 void scst_cmd_tasklet(long p);
251 int scst_init_cmd_thread(void *arg);
252 int scst_mgmt_cmd_thread(void *arg);
253 int scst_mgmt_thread(void *arg);
254
255 int scst_add_dev_threads(struct scst_device *dev, int num);
256 void scst_del_dev_threads(struct scst_device *dev, int num);
257
258 int scst_alloc_device(gfp_t gfp_mask, struct scst_device **out_dev);
259 void scst_free_device(struct scst_device *dev);
260
261 struct scst_acg *scst_alloc_add_acg(const char *acg_name);
262 int scst_destroy_acg(struct scst_acg *acg);
263 int scst_proc_group_add_tree(struct scst_acg *acg, const char *name);
264 void scst_proc_del_acg_tree(struct proc_dir_entry *acg_proc_root,
265         const char *name);
266
267 int scst_sess_alloc_tgt_devs(struct scst_session *sess);
268 void scst_sess_free_tgt_devs(struct scst_session *sess);
269 void scst_nexus_loss(struct scst_tgt_dev *tgt_dev);
270
271 int scst_acg_add_dev(struct scst_acg *acg, struct scst_device *dev,
272                      uint64_t lun, int read_only);
273 int scst_acg_remove_dev(struct scst_acg *acg, struct scst_device *dev);
274
275 int scst_acg_add_name(struct scst_acg *acg, const char *name);
276 int scst_acg_remove_name(struct scst_acg *acg, const char *name);
277
278 struct scst_cmd *scst_create_prepare_internal_cmd(
279         struct scst_cmd *orig_cmd, int bufsize);
280 void scst_free_internal_cmd(struct scst_cmd *cmd);
281 int scst_prepare_request_sense(struct scst_cmd *orig_cmd);
282 struct scst_cmd *scst_complete_request_sense(struct scst_cmd *cmd);
283
284 int scst_assign_dev_handler(struct scst_device *dev,
285         struct scst_dev_type *handler);
286
287 struct scst_session *scst_alloc_session(struct scst_tgt *tgt, gfp_t gfp_mask,
288         const char *initiator_name);
289 void scst_free_session(struct scst_session *sess);
290 void scst_free_session_callback(struct scst_session *sess);
291
292 struct scst_cmd *scst_alloc_cmd(gfp_t gfp_mask);
293 void scst_free_cmd(struct scst_cmd *cmd);
294 static inline void scst_destroy_cmd(struct scst_cmd *cmd)
295 {
296         kmem_cache_free(scst_cmd_cachep, cmd);
297         return;
298 }
299
300 void scst_proccess_redirect_cmd(struct scst_cmd *cmd,
301         enum scst_exec_context context, int check_retries);
302 void scst_check_retries(struct scst_tgt *tgt);
303 void scst_tgt_retry_timer_fn(unsigned long arg);
304
305 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
306 int scst_alloc_request(struct scst_cmd *cmd);
307 void scst_release_request(struct scst_cmd *cmd);
308
309 static inline void scst_do_req(struct scsi_request *sreq,
310         const void *cmnd, void *buffer, unsigned bufflen,
311         void (*done)(struct scsi_cmnd *), int timeout, int retries)
312 {
313 #ifdef CONFIG_SCST_STRICT_SERIALIZING
314         scsi_do_req(sreq, cmnd, buffer, bufflen, done, timeout, retries);
315 #elif !defined(SCSI_EXEC_REQ_FIFO_DEFINED)
316         sBUG();
317 #else
318         scsi_do_req_fifo(sreq, cmnd, buffer, bufflen, done, timeout, retries);
319 #endif
320 }
321 #else
322 static inline int scst_exec_req(struct scsi_device *sdev,
323         const unsigned char *cmd, int cmd_len, int data_direction,
324         void *buffer, unsigned bufflen, int use_sg, int timeout, int retries,
325         void *privdata, void (*done)(void *, char *, int, int), gfp_t gfp)
326 {
327 #ifdef CONFIG_SCST_STRICT_SERIALIZING
328         return scsi_execute_async(sdev, cmd, cmd_len, data_direction, buffer,
329                     bufflen, use_sg, timeout, retries, privdata, done, gfp);
330 #elif !defined(SCSI_EXEC_REQ_FIFO_DEFINED)
331         sBUG();
332         return -1;
333 #else
334         return scsi_execute_async_fifo(sdev, cmd, cmd_len, data_direction,
335             buffer, bufflen, use_sg, timeout, retries, privdata, done, gfp);
336 #endif
337 }
338 #endif
339
340 int scst_alloc_space(struct scst_cmd *cmd);
341 void scst_release_space(struct scst_cmd *cmd);
342 void scst_scsi_op_list_init(void);
343
344 enum scst_sg_copy_dir {
345         SCST_SG_COPY_FROM_TARGET,
346         SCST_SG_COPY_TO_TARGET
347 };
348 void scst_copy_sg(struct scst_cmd *cmd, enum scst_sg_copy_dir);
349
350 uint64_t scst_unpack_lun(const uint8_t *lun, int len);
351
352 struct scst_cmd *__scst_find_cmd_by_tag(struct scst_session *sess,
353         uint64_t tag);
354
355 struct scst_mgmt_cmd *scst_alloc_mgmt_cmd(gfp_t gfp_mask);
356 void scst_free_mgmt_cmd(struct scst_mgmt_cmd *mcmd);
357 void scst_done_cmd_mgmt(struct scst_cmd *cmd);
358
359 /* /proc support */
360 int scst_proc_init_module(void);
361 void scst_proc_cleanup_module(void);
362 int scst_build_proc_target_dir_entries(struct scst_tgt_template *vtt);
363 void scst_cleanup_proc_target_dir_entries(struct scst_tgt_template *vtt);
364 int scst_build_proc_target_entries(struct scst_tgt *vtt);
365 void scst_cleanup_proc_target_entries(struct scst_tgt *vtt);
366 int scst_build_proc_dev_handler_dir_entries(struct scst_dev_type *dev_type);
367 void scst_cleanup_proc_dev_handler_dir_entries(struct scst_dev_type *dev_type);
368
369 int scst_get_cdb_len(const uint8_t *cdb);
370
371 void __scst_dev_check_set_UA(struct scst_device *dev, struct scst_cmd *exclude,
372         const uint8_t *sense, int sense_len);
373 static inline void scst_dev_check_set_UA(struct scst_device *dev,
374         struct scst_cmd *exclude, const uint8_t *sense, int sense_len)
375 {
376         spin_lock_bh(&dev->dev_lock);
377         __scst_dev_check_set_UA(dev, exclude, sense, sense_len);
378         spin_unlock_bh(&dev->dev_lock);
379         return;
380 }
381 void scst_dev_check_set_local_UA(struct scst_device *dev,
382         struct scst_cmd *exclude, const uint8_t *sense, int sense_len);
383
384 void scst_check_set_UA(struct scst_tgt_dev *tgt_dev,
385         const uint8_t *sense, int sense_len, int head);
386 void scst_alloc_set_UA(struct scst_tgt_dev *tgt_dev, const uint8_t *sense,
387         int sense_len, int head);
388 void scst_free_all_UA(struct scst_tgt_dev *tgt_dev);
389 int scst_set_pending_UA(struct scst_cmd *cmd);
390
391 void scst_abort_cmd(struct scst_cmd *cmd, struct scst_mgmt_cmd *mcmd,
392         int other_ini, int call_dev_task_mgmt_fn);
393 void scst_process_reset(struct scst_device *dev,
394         struct scst_session *originator, struct scst_cmd *exclude_cmd,
395         struct scst_mgmt_cmd *mcmd, bool setUA);
396
397 static inline int scst_is_ua_command(struct scst_cmd *cmd)
398 {
399         return cmd->cdb[0] != INQUIRY
400                && cmd->cdb[0] != REQUEST_SENSE
401                && cmd->cdb[0] != REPORT_LUNS;
402 }
403
404 static inline int scst_is_implicit_hq(struct scst_cmd *cmd)
405 {
406         return cmd->cdb[0] == INQUIRY
407                || cmd->cdb[0] == REPORT_LUNS
408                || (cmd->dev->type == TYPE_DISK
409                    && (cmd->cdb[0] == READ_CAPACITY
410                        || (cmd->cdb[0] == SERVICE_ACTION_IN
411                            && (cmd->cdb[1] & 0x1f) == SAI_READ_CAPACITY_16)));
412 }
413
414 /*
415  * Some notes on devices "blocking". Blocking means that no
416  * commands will go from SCST to underlying SCSI device until it
417  * is unblocked. But we don't care about all commands that
418  * already on the device.
419  */
420
421 extern int scst_inc_on_dev_cmd(struct scst_cmd *cmd);
422 extern void scst_unblock_cmds(struct scst_device *dev);
423
424 extern void __scst_block_dev(struct scst_device *dev);
425 extern void scst_block_dev(struct scst_device *dev, int outstanding);
426 extern void scst_block_dev_cmd(struct scst_cmd *cmd, int outstanding);
427 extern void scst_unblock_dev(struct scst_device *dev);
428 extern void scst_unblock_dev_cmd(struct scst_cmd *cmd);
429
430 /* No locks */
431 static inline void scst_dec_on_dev_cmd(struct scst_cmd *cmd)
432 {
433         struct scst_device *dev = cmd->dev;
434         bool unblock_dev = cmd->inc_blocking;
435
436         if (cmd->inc_blocking) {
437                 TRACE_MGMT_DBG("cmd %p (tag %llu): unblocking dev %p", cmd,
438                                (long long unsigned int)cmd->tag, cmd->dev);
439                 cmd->inc_blocking = 0;
440         }
441         cmd->dec_on_dev_needed = 0;
442
443         if (unblock_dev)
444                 scst_unblock_dev(dev);
445
446         atomic_dec(&dev->on_dev_count);
447         smp_mb__after_atomic_dec();
448
449         TRACE_DBG("New on_dev_count %d", atomic_read(&dev->on_dev_count));
450
451         sBUG_ON(atomic_read(&dev->on_dev_count) < 0);
452
453         if (unlikely(dev->block_count != 0))
454                 wake_up_all(&dev->on_dev_waitQ);
455
456         return;
457 }
458
459 static inline void __scst_get(int barrier)
460 {
461         atomic_inc(&scst_cmd_count);
462         TRACE_DBG("Incrementing scst_cmd_count(%d)",
463                 atomic_read(&scst_cmd_count));
464
465         if (barrier)
466                 smp_mb__after_atomic_inc();
467 }
468
469 static inline void __scst_put(void)
470 {
471         int f;
472         f = atomic_dec_and_test(&scst_cmd_count);
473         if (f && unlikely(test_bit(SCST_FLAG_SUSPENDED, &scst_flags))) {
474                 TRACE_MGMT_DBG("%s", "Waking up scst_dev_cmd_waitQ");
475                 wake_up_all(&scst_dev_cmd_waitQ);
476         }
477         TRACE_DBG("Decrementing scst_cmd_count(%d)",
478               atomic_read(&scst_cmd_count));
479 }
480
481 void scst_sched_session_free(struct scst_session *sess);
482
483 static inline void scst_sess_get(struct scst_session *sess)
484 {
485         atomic_inc(&sess->refcnt);
486 }
487
488 static inline void scst_sess_put(struct scst_session *sess)
489 {
490         if (atomic_dec_and_test(&sess->refcnt))
491                 scst_sched_session_free(sess);
492 }
493
494 static inline void __scst_cmd_get(struct scst_cmd *cmd)
495 {
496         atomic_inc(&cmd->cmd_ref);
497 }
498
499 static inline void __scst_cmd_put(struct scst_cmd *cmd)
500 {
501         if (atomic_dec_and_test(&cmd->cmd_ref))
502                 scst_free_cmd(cmd);
503 }
504
505 extern void scst_throttle_cmd(struct scst_cmd *cmd);
506 extern void scst_unthrottle_cmd(struct scst_cmd *cmd);
507
508 static inline void scst_check_restore_sg_buff(struct scst_cmd *cmd)
509 {
510         if (cmd->sg_buff_modified) {
511                 TRACE_MEM("cmd %p, sg %p, orig_sg_entry %d, "
512                         "orig_entry_len %d, orig_sg_cnt %d", cmd, cmd->sg,
513                         cmd->orig_sg_entry, cmd->orig_entry_len,
514                         cmd->orig_sg_cnt);
515                 cmd->sg[cmd->orig_sg_entry].length = cmd->orig_entry_len;
516                 cmd->sg_cnt = cmd->orig_sg_cnt;
517                 cmd->sg_buff_modified = 0;
518         }
519 }
520
521 #ifdef CONFIG_SCST_DEBUG_TM
522 extern void tm_dbg_init_tgt_dev(struct scst_tgt_dev *tgt_dev,
523         struct scst_acg_dev *acg_dev);
524 extern void tm_dbg_deinit_tgt_dev(struct scst_tgt_dev *tgt_dev);
525 extern void tm_dbg_check_released_cmds(void);
526 extern int tm_dbg_check_cmd(struct scst_cmd *cmd);
527 extern void tm_dbg_release_cmd(struct scst_cmd *cmd);
528 extern void tm_dbg_task_mgmt(struct scst_device *dev, const char *fn,
529         int force);
530 extern int tm_dbg_is_release(void);
531 #else
532 static inline void tm_dbg_init_tgt_dev(struct scst_tgt_dev *tgt_dev,
533         struct scst_acg_dev *acg_dev) {}
534 static inline void tm_dbg_deinit_tgt_dev(struct scst_tgt_dev *tgt_dev) {}
535 static inline void tm_dbg_check_released_cmds(void) {}
536 static inline int tm_dbg_check_cmd(struct scst_cmd *cmd)
537 {
538         return 0;
539 }
540 static inline void tm_dbg_release_cmd(struct scst_cmd *cmd) {}
541 static inline void tm_dbg_task_mgmt(struct scst_device *dev, const char *fn,
542         int force) {}
543 static inline int tm_dbg_is_release(void)
544 {
545         return 0;
546 }
547 #endif /* CONFIG_SCST_DEBUG_TM */
548
549 #ifdef CONFIG_SCST_DEBUG_SN
550 void scst_check_debug_sn(struct scst_cmd *cmd);
551 #else
552 static inline void scst_check_debug_sn(struct scst_cmd *cmd) {}
553 #endif
554
555 /*
556  * It deals with comparing 32 bit unsigned ints and worry about wraparound
557  * (automatic with unsigned arithmetic). Borrowed from net/tcp.h.
558  */
559 static inline int scst_sn_before(__u32 seq1, __u32 seq2)
560 {
561         return (__s32)(seq1-seq2) < 0;
562 }
563
564 #endif /* __SCST_PRIV_H */