- Possibility to operate with single size entries as well as control of the reclamat...
[mirror/scst/.git] / scst / src / scst_priv.h
1 /*
2  *  scst_priv.h
3  *
4  *  Copyright (C) 2004 - 2009 Vladislav Bolkhovitin <vst@vlnb.net>
5  *  Copyright (C) 2004 - 2005 Leonid Stoljar
6  *  Copyright (C) 2007 - 2009 ID7 Ltd.
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
56 /* TRACE_MGMT_MINOR disabled to not confuse regular users */
57 #define SCST_DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MINOR | TRACE_PID | \
58         TRACE_LINE | TRACE_FUNCTION | TRACE_SPECIAL | TRACE_MGMT | \
59         /*TRACE_MGMT_MINOR |*/ TRACE_MGMT_DEBUG | TRACE_RTRY)
60
61 #define TRACE_RETRY(args...)    TRACE_DBG_FLAG(TRACE_RTRY, args)
62 #define TRACE_SN(args...)       TRACE_DBG_FLAG(TRACE_SCSI_SERIALIZING, args)
63 #define TRACE_SEND_TOP(args...) TRACE_DBG_FLAG(TRACE_SND_TOP, args)
64 #define TRACE_RECV_TOP(args...) TRACE_DBG_FLAG(TRACE_RCV_TOP, args)
65 #define TRACE_SEND_BOT(args...) TRACE_DBG_FLAG(TRACE_SND_BOT, args)
66 #define TRACE_RECV_BOT(args...) TRACE_DBG_FLAG(TRACE_RCV_BOT, args)
67
68 #else /* CONFIG_SCST_DEBUG */
69
70 # ifdef CONFIG_SCST_TRACING
71 #define SCST_DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MINOR | TRACE_MGMT | \
72         TRACE_SPECIAL)
73 # else
74 #define SCST_DEFAULT_LOG_FLAGS 0
75 # endif
76
77 #define TRACE_RETRY(args...)
78 #define TRACE_SN(args...)
79 #define TRACE_SEND_TOP(args...)
80 #define TRACE_RECV_TOP(args...)
81 #define TRACE_SEND_BOT(args...)
82 #define TRACE_RECV_BOT(args...)
83
84 #endif
85
86 /**
87  ** Bits for scst_flags
88  **/
89
90 /*
91  * Set if new commands initialization is being suspended for a while.
92  * Used to let TM commands execute while preparing the suspend, since
93  * RESET or ABORT could be necessary to free SCSI commands.
94  */
95 #define SCST_FLAG_SUSPENDING                 0
96
97 /* Set if new commands initialization is suspended for a while */
98 #define SCST_FLAG_SUSPENDED                  1
99
100 /**
101  ** Return codes for cmd state process functions. Codes are the same as
102  ** for SCST_EXEC_* to avoid translation to them and, hence, have better code.
103  **/
104 #define SCST_CMD_STATE_RES_CONT_NEXT         SCST_EXEC_COMPLETED
105 #define SCST_CMD_STATE_RES_CONT_SAME         SCST_EXEC_NOT_COMPLETED
106 #define SCST_CMD_STATE_RES_NEED_THREAD       SCST_EXEC_NEED_THREAD
107
108 /**
109  ** Maximum count of uncompleted commands that an initiator could
110  ** queue on any device. Then it will start getting TASK QUEUE FULL status.
111  **/
112 #define SCST_MAX_TGT_DEV_COMMANDS            48
113
114 /**
115  ** Maximum count of uncompleted commands that could be queued on any device.
116  ** Then initiators sending commands to this device will start getting
117  ** TASK QUEUE FULL status.
118  **/
119 #define SCST_MAX_DEV_COMMANDS                256
120
121 #define SCST_TGT_RETRY_TIMEOUT               (3/2*HZ)
122
123 extern unsigned int scst_max_dev_cmd_mem;
124
125 extern mempool_t *scst_mgmt_mempool;
126 extern mempool_t *scst_mgmt_stub_mempool;
127 extern mempool_t *scst_ua_mempool;
128 extern mempool_t *scst_sense_mempool;
129 extern mempool_t *scst_aen_mempool;
130
131 extern struct kmem_cache *scst_cmd_cachep;
132 extern struct kmem_cache *scst_sess_cachep;
133 extern struct kmem_cache *scst_tgtd_cachep;
134 extern struct kmem_cache *scst_acgd_cachep;
135
136 extern spinlock_t scst_main_lock;
137
138 extern struct scst_sgv_pools scst_sgv;
139
140 extern unsigned long scst_flags;
141 extern struct mutex scst_mutex;
142 extern atomic_t scst_cmd_count;
143 extern struct list_head scst_dev_list;
144 extern struct list_head scst_dev_type_list;
145 extern wait_queue_head_t scst_dev_cmd_waitQ;
146
147 extern struct list_head scst_acg_list;
148 extern struct scst_acg *scst_default_acg;
149
150 extern spinlock_t scst_init_lock;
151 extern struct list_head scst_init_cmd_list;
152 extern wait_queue_head_t scst_init_cmd_list_waitQ;
153 extern unsigned int scst_init_poll_cnt;
154
155 extern struct scst_cmd_lists scst_main_cmd_lists;
156
157 extern spinlock_t scst_mcmd_lock;
158 /* The following lists protected by scst_mcmd_lock */
159 extern struct list_head scst_active_mgmt_cmd_list;
160 extern struct list_head scst_delayed_mgmt_cmd_list;
161 extern wait_queue_head_t scst_mgmt_cmd_list_waitQ;
162
163 struct scst_tasklet {
164         spinlock_t tasklet_lock;
165         struct list_head tasklet_cmd_list;
166         struct tasklet_struct tasklet;
167 };
168 extern struct scst_tasklet scst_tasklets[NR_CPUS];
169
170 extern wait_queue_head_t scst_mgmt_waitQ;
171 extern spinlock_t scst_mgmt_lock;
172 extern struct list_head scst_sess_init_list;
173 extern struct list_head scst_sess_shut_list;
174
175 struct scst_cmd_thread_t {
176         struct task_struct *cmd_thread;
177         struct list_head thread_list_entry;
178 };
179
180 #if defined(SCST_IO_CONTEXT)
181
182 static inline bool scst_set_io_context(struct scst_cmd *cmd,
183         struct io_context **old)
184 {
185         bool res;
186
187         if (cmd->cmd_lists == &scst_main_cmd_lists) {
188                 EXTRACHECKS_BUG_ON(in_interrupt());
189                 /*
190                  * No need to call ioc_task_link(), because io_context
191                  * supposed to be cleared in the end of the caller function.
192                  */
193                 current->io_context = cmd->tgt_dev->tgt_dev_io_ctx;
194                 res = true;
195                 TRACE_DBG("io_context %p", cmd->tgt_dev->tgt_dev_io_ctx);
196         } else
197                 res = false;
198
199         return res;
200 }
201
202 static inline void scst_reset_io_context(struct scst_tgt_dev *tgt_dev,
203         struct io_context *old)
204 {
205         current->io_context = old;
206         TRACE_DBG("io_context %p reset", current->io_context);
207         return;
208 }
209
210 #else
211
212 static inline bool scst_set_io_context(struct scst_cmd *cmd,
213         struct io_context **old)
214 {
215         return false;
216 }
217 static inline void scst_reset_io_context(struct scst_tgt_dev *tgt_dev,
218         struct io_context *old) {}
219 static inline void __exit_io_context(struct io_context *ioc) {}
220 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 25)
221 static inline struct io_context *ioc_task_link(struct io_context *ioc)
222 {
223         return NULL;
224 }
225 #endif
226
227 #endif
228
229 extern struct mutex scst_global_threads_mutex;
230 extern u32 scst_nr_global_threads;
231
232 extern int scst_global_threads_count(void);
233 extern int __scst_add_global_threads(int num);
234 extern void __scst_del_global_threads(int num);
235
236 extern struct scst_dev_type scst_null_devtype;
237
238 extern struct scst_cmd *__scst_check_deferred_commands(
239         struct scst_tgt_dev *tgt_dev);
240
241 /* Used to save the function call on the fast path */
242 static inline struct scst_cmd *scst_check_deferred_commands(
243         struct scst_tgt_dev *tgt_dev)
244 {
245         if (tgt_dev->def_cmd_count == 0)
246                 return NULL;
247         else
248                 return __scst_check_deferred_commands(tgt_dev);
249 }
250
251 static inline void scst_make_deferred_commands_active(
252         struct scst_tgt_dev *tgt_dev)
253 {
254         struct scst_cmd *c;
255
256         c = __scst_check_deferred_commands(tgt_dev);
257         if (c != NULL) {
258                 TRACE_SN("Adding cmd %p to active cmd list", c);
259                 spin_lock_irq(&c->cmd_lists->cmd_list_lock);
260                 list_add_tail(&c->cmd_list_entry,
261                         &c->cmd_lists->active_cmd_list);
262                 wake_up(&c->cmd_lists->cmd_list_waitQ);
263                 spin_unlock_irq(&c->cmd_lists->cmd_list_lock);
264         }
265
266         return;
267 }
268
269 void scst_inc_expected_sn(struct scst_tgt_dev *tgt_dev, atomic_t *slot);
270 int scst_check_hq_cmd(struct scst_cmd *cmd);
271
272 void scst_unblock_deferred(struct scst_tgt_dev *tgt_dev,
273         struct scst_cmd *cmd_sn);
274
275 void scst_on_hq_cmd_response(struct scst_cmd *cmd);
276 void scst_xmit_process_aborted_cmd(struct scst_cmd *cmd);
277
278 int scst_cmd_thread(void *arg);
279 void scst_cmd_tasklet(long p);
280 int scst_init_thread(void *arg);
281 int scst_tm_thread(void *arg);
282 int scst_global_mgmt_thread(void *arg);
283
284 int scst_add_dev_threads(struct scst_device *dev, int num);
285 void scst_del_dev_threads(struct scst_device *dev, int num);
286
287 int scst_queue_retry_cmd(struct scst_cmd *cmd, int finished_cmds);
288
289 int scst_alloc_device(gfp_t gfp_mask, struct scst_device **out_dev);
290 void scst_free_device(struct scst_device *dev);
291
292 struct scst_acg *scst_alloc_add_acg(const char *acg_name);
293 int scst_destroy_acg(struct scst_acg *acg);
294
295 int scst_sess_alloc_tgt_devs(struct scst_session *sess);
296 void scst_nexus_loss(struct scst_tgt_dev *tgt_dev, bool queue_UA);
297
298 int scst_acg_add_dev(struct scst_acg *acg, struct scst_device *dev,
299                      uint64_t lun, int read_only);
300 int scst_acg_remove_dev(struct scst_acg *acg, struct scst_device *dev);
301
302 int scst_acg_add_name(struct scst_acg *acg, const char *name);
303 int scst_acg_remove_name(struct scst_acg *acg, const char *name);
304
305 int scst_prepare_request_sense(struct scst_cmd *orig_cmd);
306 int scst_finish_internal_cmd(struct scst_cmd *cmd);
307
308 void scst_store_sense(struct scst_cmd *cmd);
309
310 int scst_assign_dev_handler(struct scst_device *dev,
311         struct scst_dev_type *handler);
312
313 struct scst_session *scst_alloc_session(struct scst_tgt *tgt, gfp_t gfp_mask,
314         const char *initiator_name);
315 void scst_free_session(struct scst_session *sess);
316 void scst_free_session_callback(struct scst_session *sess);
317
318 struct scst_cmd *scst_alloc_cmd(gfp_t gfp_mask);
319 void scst_free_cmd(struct scst_cmd *cmd);
320 static inline void scst_destroy_cmd(struct scst_cmd *cmd)
321 {
322         kmem_cache_free(scst_cmd_cachep, cmd);
323         return;
324 }
325
326 void scst_check_retries(struct scst_tgt *tgt);
327 void scst_tgt_retry_timer_fn(unsigned long arg);
328
329 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
330 int scst_alloc_request(struct scst_cmd *cmd);
331 void scst_release_request(struct scst_cmd *cmd);
332
333 static inline void scst_do_req(struct scsi_request *sreq,
334         const void *cmnd, void *buffer, unsigned bufflen,
335         void (*done)(struct scsi_cmnd *), int timeout, int retries)
336 {
337 #ifdef CONFIG_SCST_STRICT_SERIALIZING
338         scsi_do_req(sreq, cmnd, buffer, bufflen, done, timeout, retries);
339 #elif !defined(SCSI_EXEC_REQ_FIFO_DEFINED)
340         sBUG();
341 #else
342         scsi_do_req_fifo(sreq, cmnd, buffer, bufflen, done, timeout, retries);
343 #endif
344 }
345 #elif LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 30)
346 static inline int scst_exec_req(struct scsi_device *sdev,
347         const unsigned char *cmd, int cmd_len, int data_direction,
348         struct scatterlist *sgl, unsigned bufflen, unsigned nents,
349         int timeout, int retries, void *privdata,
350         void (*done)(void *, char *, int, int), gfp_t gfp)
351 {
352 #if defined(CONFIG_SCST_STRICT_SERIALIZING)
353         return scsi_execute_async(sdev, cmd, cmd_len, data_direction, (void*)sgl,
354                     bufflen, nents, timeout, retries, privdata, done, gfp);
355 #elif !defined(SCSI_EXEC_REQ_FIFO_DEFINED)
356         WARN_ON(1);
357         return -1;
358 #else
359         return scsi_execute_async_fifo(sdev, cmd, cmd_len, data_direction,
360             (void*)sgl, bufflen, nents, timeout, retries, privdata, done, gfp);
361 #endif
362 }
363 #else /* i.e. LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30) */
364 #if !defined(SCSI_EXEC_REQ_FIFO_DEFINED)
365 #define SCSI_ASYNC_EXEC_FLAG_AT_HEAD                    1
366 #define SCSI_ASYNC_EXEC_FLAG_HAS_TAIL_SPACE_FOR_PADDING 2
367 int scsi_execute_async(struct scsi_device *sdev,
368         const unsigned char *cmd, int cmd_len, int data_direction,
369         struct scatterlist *sgl, int nents, int timeout, int retries,
370         void *privdata, void (*done)(void *, char *, int, int),
371         gfp_t gfp, int flags);
372 #endif
373 #endif
374
375 int scst_alloc_space(struct scst_cmd *cmd);
376 void scst_scsi_op_list_init(void);
377
378 enum scst_sg_copy_dir {
379         SCST_SG_COPY_FROM_TARGET,
380         SCST_SG_COPY_TO_TARGET
381 };
382 void scst_copy_sg(struct scst_cmd *cmd, enum scst_sg_copy_dir);
383
384 uint64_t scst_pack_lun(const uint64_t lun);
385 uint64_t scst_unpack_lun(const uint8_t *lun, int len);
386
387 struct scst_mgmt_cmd *scst_alloc_mgmt_cmd(gfp_t gfp_mask);
388 void scst_free_mgmt_cmd(struct scst_mgmt_cmd *mcmd);
389 void scst_done_cmd_mgmt(struct scst_cmd *cmd);
390
391 /* /proc support */
392 int scst_proc_init_module(void);
393 void scst_proc_cleanup_module(void);
394 int scst_build_proc_target_dir_entries(struct scst_tgt_template *vtt);
395 void scst_cleanup_proc_target_dir_entries(struct scst_tgt_template *vtt);
396 int scst_build_proc_target_entries(struct scst_tgt *vtt);
397 void scst_cleanup_proc_target_entries(struct scst_tgt *vtt);
398 int scst_build_proc_dev_handler_dir_entries(struct scst_dev_type *dev_type);
399 void scst_cleanup_proc_dev_handler_dir_entries(struct scst_dev_type *dev_type);
400
401 int scst_get_cdb_len(const uint8_t *cdb);
402
403 void __scst_dev_check_set_UA(struct scst_device *dev, struct scst_cmd *exclude,
404         const uint8_t *sense, int sense_len);
405 static inline void scst_dev_check_set_UA(struct scst_device *dev,
406         struct scst_cmd *exclude, const uint8_t *sense, int sense_len)
407 {
408         spin_lock_bh(&dev->dev_lock);
409         __scst_dev_check_set_UA(dev, exclude, sense, sense_len);
410         spin_unlock_bh(&dev->dev_lock);
411         return;
412 }
413 void scst_dev_check_set_local_UA(struct scst_device *dev,
414         struct scst_cmd *exclude, const uint8_t *sense, int sense_len);
415
416 #define SCST_SET_UA_FLAG_AT_HEAD        1
417 #define SCST_SET_UA_FLAG_GLOBAL         2
418
419 void scst_check_set_UA(struct scst_tgt_dev *tgt_dev,
420         const uint8_t *sense, int sense_len, int flags);
421 int scst_set_pending_UA(struct scst_cmd *cmd);
422
423 void scst_report_luns_changed(struct scst_acg *acg);
424
425 void scst_abort_cmd(struct scst_cmd *cmd, struct scst_mgmt_cmd *mcmd,
426         int other_ini, int call_dev_task_mgmt_fn);
427 void scst_process_reset(struct scst_device *dev,
428         struct scst_session *originator, struct scst_cmd *exclude_cmd,
429         struct scst_mgmt_cmd *mcmd, bool setUA);
430
431 static inline bool scst_is_ua_command(struct scst_cmd *cmd)
432 {
433         return (cmd->op_flags & SCST_SKIP_UA) == 0;
434 }
435
436 static inline bool scst_is_implicit_hq(struct scst_cmd *cmd)
437 {
438         return (cmd->op_flags & SCST_IMPLICIT_HQ) != 0;
439 }
440
441 /*
442  * Some notes on devices "blocking". Blocking means that no
443  * commands will go from SCST to underlying SCSI device until it
444  * is unblocked. But we don't care about all commands that
445  * already on the device.
446  */
447
448 extern int scst_inc_on_dev_cmd(struct scst_cmd *cmd);
449
450 extern void __scst_block_dev(struct scst_device *dev);
451 extern void scst_block_dev_cmd(struct scst_cmd *cmd, int outstanding);
452 extern void scst_unblock_dev(struct scst_device *dev);
453 extern void scst_unblock_dev_cmd(struct scst_cmd *cmd);
454
455 /* No locks */
456 static inline void scst_dec_on_dev_cmd(struct scst_cmd *cmd)
457 {
458         struct scst_device *dev = cmd->dev;
459         bool unblock_dev = cmd->inc_blocking;
460
461         if (cmd->inc_blocking) {
462                 TRACE_MGMT_DBG("cmd %p (tag %llu): unblocking dev %p", cmd,
463                                (long long unsigned int)cmd->tag, cmd->dev);
464                 cmd->inc_blocking = 0;
465         }
466         cmd->dec_on_dev_needed = 0;
467
468         if (unblock_dev)
469                 scst_unblock_dev(dev);
470
471         atomic_dec(&dev->on_dev_count);
472         /* See comment in scst_block_dev() */
473         smp_mb__after_atomic_dec();
474
475         TRACE_DBG("New on_dev_count %d", atomic_read(&dev->on_dev_count));
476
477         sBUG_ON(atomic_read(&dev->on_dev_count) < 0);
478
479         if (unlikely(dev->block_count != 0))
480                 wake_up_all(&dev->on_dev_waitQ);
481
482         return;
483 }
484
485 static inline void __scst_get(int barrier)
486 {
487         atomic_inc(&scst_cmd_count);
488         TRACE_DBG("Incrementing scst_cmd_count(new value %d)",
489                 atomic_read(&scst_cmd_count));
490
491         /* See comment about smp_mb() in scst_suspend_activity() */
492         if (barrier)
493                 smp_mb__after_atomic_inc();
494 }
495
496 static inline void __scst_put(void)
497 {
498         int f;
499         f = atomic_dec_and_test(&scst_cmd_count);
500         /* See comment about smp_mb() in scst_suspend_activity() */
501         if (f && unlikely(test_bit(SCST_FLAG_SUSPENDED, &scst_flags))) {
502                 TRACE_MGMT_DBG("%s", "Waking up scst_dev_cmd_waitQ");
503                 wake_up_all(&scst_dev_cmd_waitQ);
504         }
505         TRACE_DBG("Decrementing scst_cmd_count(new value %d)",
506               atomic_read(&scst_cmd_count));
507 }
508
509 void scst_sched_session_free(struct scst_session *sess);
510
511 static inline void scst_sess_get(struct scst_session *sess)
512 {
513         atomic_inc(&sess->refcnt);
514         TRACE_DBG("Incrementing sess %p refcnt (new value %d)",
515                 sess, atomic_read(&sess->refcnt));
516 }
517
518 static inline void scst_sess_put(struct scst_session *sess)
519 {
520         TRACE_DBG("Decrementing sess %p refcnt (new value %d)",
521                 sess, atomic_read(&sess->refcnt)-1);
522         if (atomic_dec_and_test(&sess->refcnt))
523                 scst_sched_session_free(sess);
524 }
525
526 static inline void __scst_cmd_get(struct scst_cmd *cmd)
527 {
528         atomic_inc(&cmd->cmd_ref);
529         TRACE_DBG("Incrementing cmd %p ref (new value %d)",
530                 cmd, atomic_read(&cmd->cmd_ref));
531 }
532
533 static inline void __scst_cmd_put(struct scst_cmd *cmd)
534 {
535         TRACE_DBG("Decrementing cmd %p ref (new value %d)",
536                 cmd, atomic_read(&cmd->cmd_ref)-1);
537         if (atomic_dec_and_test(&cmd->cmd_ref))
538                 scst_free_cmd(cmd);
539 }
540
541 extern void scst_throttle_cmd(struct scst_cmd *cmd);
542 extern void scst_unthrottle_cmd(struct scst_cmd *cmd);
543
544 static inline void scst_check_restore_sg_buff(struct scst_cmd *cmd)
545 {
546         if (cmd->sg_buff_modified) {
547                 TRACE_MEM("cmd %p, sg %p, orig_sg_entry %d, "
548                         "orig_entry_len %d, orig_sg_cnt %d", cmd, cmd->sg,
549                         cmd->orig_sg_entry, cmd->orig_entry_len,
550                         cmd->orig_sg_cnt);
551                 cmd->sg[cmd->orig_sg_entry].length = cmd->orig_entry_len;
552                 cmd->sg_cnt = cmd->orig_sg_cnt;
553                 cmd->sg_buff_modified = 0;
554         }
555 }
556
557 #ifdef CONFIG_SCST_DEBUG_TM
558 extern void tm_dbg_check_released_cmds(void);
559 extern int tm_dbg_check_cmd(struct scst_cmd *cmd);
560 extern void tm_dbg_release_cmd(struct scst_cmd *cmd);
561 extern void tm_dbg_task_mgmt(struct scst_device *dev, const char *fn,
562         int force);
563 extern int tm_dbg_is_release(void);
564 #else
565 static inline void tm_dbg_check_released_cmds(void) {}
566 static inline int tm_dbg_check_cmd(struct scst_cmd *cmd)
567 {
568         return 0;
569 }
570 static inline void tm_dbg_release_cmd(struct scst_cmd *cmd) {}
571 static inline void tm_dbg_task_mgmt(struct scst_device *dev, const char *fn,
572         int force) {}
573 static inline int tm_dbg_is_release(void)
574 {
575         return 0;
576 }
577 #endif /* CONFIG_SCST_DEBUG_TM */
578
579 #ifdef CONFIG_SCST_DEBUG_SN
580 void scst_check_debug_sn(struct scst_cmd *cmd);
581 #else
582 static inline void scst_check_debug_sn(struct scst_cmd *cmd) {}
583 #endif
584
585 /*
586  * It deals with comparing 32 bit unsigned ints and worry about wraparound
587  * (automatic with unsigned arithmetic). Borrowed from net/tcp.h.
588  */
589 static inline int scst_sn_before(__u32 seq1, __u32 seq2)
590 {
591         return (__s32)(seq1-seq2) < 0;
592 }
593
594 #endif /* __SCST_PRIV_H */