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 kmem_cache_t *scst_mgmt_cachep;
 114 extern mempool_t *scst_mgmt_mempool;
 115
 116 #define SCST_UA_CACHE_STRING "scst_ua"
 117 extern kmem_cache_t *scst_ua_cachep;
 118 extern mempool_t *scst_ua_mempool;
 119
 120 #define SCST_CMD_CACHE_STRING "scst_cmd"
 121 extern kmem_cache_t *scst_cmd_cachep;
 122
 123 #define SCST_SESSION_CACHE_STRING "scst_session"
 124 extern kmem_cache_t *scst_sess_cachep;
 125
 126 #define SCST_TGT_DEV_CACHE_STRING "scst_tgt_dev"
 127 extern kmem_cache_t *scst_tgtd_cachep;
 128
 129 #define SCST_ACG_DEV_CACHE_STRING "scst_acg_dev"
 130 extern kmem_cache_t *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 extern struct work_struct scst_cmd_mem_work;
 155
 156 /* The following lists protected by scst_list_lock as well */
 157 extern struct list_head scst_mgmt_cmd_list;
 158 extern struct list_head scst_active_mgmt_cmd_list;
 159 extern struct list_head scst_delayed_mgmt_cmd_list;
 160
 161 extern struct tasklet_struct scst_tasklets[NR_CPUS];
 162 extern wait_queue_head_t scst_list_waitQ;
 163
 164 extern wait_queue_head_t scst_mgmt_cmd_list_waitQ;
 165
 166 extern wait_queue_head_t scst_mgmt_waitQ;
 167 extern spinlock_t scst_mgmt_lock;
 168 extern struct list_head scst_sess_mgmt_list;
 169
 170 struct scst_cmd_thread_t {
 171         struct task_struct *cmd_thread;
 172         struct list_head thread_list_entry;
 173 };
 174
 175 struct scst_threads_info_t {
 176         struct semaphore cmd_threads_mutex;
 177         u32 nr_cmd_threads;
 178         struct list_head cmd_threads_list;
 179         struct task_struct *mgmt_thread;
 180         struct task_struct *mgmt_cmd_thread;
 181 };
 182
 183 extern struct scst_threads_info_t scst_threads_info;
 184 extern int scst_cmd_threads_count(void);
 185 extern int __scst_add_cmd_threads(int num);
 186 extern void __scst_del_cmd_threads(int num);
 187
 188 extern spinlock_t scst_temp_UA_lock;
 189 extern uint8_t scst_temp_UA[SCSI_SENSE_BUFFERSIZE];
 190
 191 extern struct scst_cmd *__scst_check_deferred_commands(
 192         struct scst_tgt_dev *tgt_dev, int expected_sn);
 193
 194 /* Used to save the function call on th fast path */
 195 static inline struct scst_cmd *scst_check_deferred_commands(
 196         struct scst_tgt_dev *tgt_dev, int expected_sn)
 197 {
 198         if (tgt_dev->def_cmd_count == 0)
 199                 return NULL;
 200         else
 201                 return __scst_check_deferred_commands(tgt_dev, expected_sn);
 202 }
 203
 204 static inline int __scst_inc_expected_sn(struct scst_tgt_dev *tgt_dev)
 205 {
 206         /*
 207          * No locks is needed, because only one thread at time can
 208          * call it (serialized by sn). Also it is supposed that there
 209          * could not be half-incremented halves.
 210          */
 211
 212         typeof(tgt_dev->expected_sn) e;
 213
 214         tgt_dev->expected_sn++;
 215         e = tgt_dev->expected_sn;
 216         smp_mb(); /* write must be before def_cmd_count read */
 217         TRACE(TRACE_DEBUG/*TRACE_SCSI_SERIALIZING*/, "Next expected_sn: %d", e);
 218         return e;
 219 }
 220
 221 void scst_inc_expected_sn_unblock(struct scst_tgt_dev *tgt_dev,
 222         struct scst_cmd *cmd_sn, int locked);
 223
 224 int scst_cmd_thread(void *arg);
 225 void scst_cmd_tasklet(long p);
 226 int scst_mgmt_cmd_thread(void *arg);
 227 int scst_mgmt_thread(void *arg);
 228 void scst_cmd_mem_work_fn(void *p);
 229
 230 struct scst_device *scst_alloc_device(int gfp_mask);
 231 void scst_free_device(struct scst_device *tgt_dev);
 232
 233 struct scst_acg *scst_alloc_add_acg(const char *acg_name);
 234 int scst_destroy_acg(struct scst_acg *acg);
 235
 236 int scst_sess_alloc_tgt_devs(struct scst_session *sess);
 237 void scst_sess_free_tgt_devs(struct scst_session *sess);
 238 void scst_reset_tgt_dev(struct scst_tgt_dev *tgt_dev, int nexus_loss);
 239
 240 int scst_acg_add_dev(struct scst_acg *acg, struct scst_device *dev, lun_t lun,
 241         int read_only);
 242 int scst_acg_remove_dev(struct scst_acg *acg, struct scst_device *dev);
 243
 244 int scst_acg_add_name(struct scst_acg *acg, const char *name);
 245 int scst_acg_remove_name(struct scst_acg *acg, const char *name);
 246
 247 struct scst_cmd *scst_create_prepare_internal_cmd(
 248         struct scst_cmd *orig_cmd, int bufsize);
 249 void scst_free_internal_cmd(struct scst_cmd *cmd);
 250 int scst_prepare_request_sense(struct scst_cmd *orig_cmd);
 251 struct scst_cmd *scst_complete_request_sense(struct scst_cmd *cmd);
 252
 253 int scst_assign_dev_handler(struct scst_device *dev,
 254         struct scst_dev_type *handler);
 255
 256 struct scst_session *scst_alloc_session(struct scst_tgt *tgt, int gfp_mask,
 257         const char *initiator_name);
 258 void scst_free_session(struct scst_session *sess);
 259 void scst_free_session_callback(struct scst_session *sess);
 260
 261 struct scst_cmd *scst_alloc_cmd(int gfp_mask);
 262 void scst_free_cmd(struct scst_cmd *cmd);
 263 static inline void scst_destroy_cmd(struct scst_cmd *cmd)
 264 {
 265         kmem_cache_free(scst_cmd_cachep, cmd);
 266         return;
 267 }
 268
 269 void scst_proccess_redirect_cmd(struct scst_cmd *cmd, int context,
 270         int check_retries);
 271 void scst_check_retries(struct scst_tgt *tgt, int processible_env);
 272 void scst_tgt_retry_timer_fn(unsigned long arg);
 273
 274 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
 275 int scst_alloc_request(struct scst_cmd *cmd);
 276 void scst_release_request(struct scst_cmd *cmd);
 277
 278 static inline void scst_do_req(struct scsi_request *sreq,
 279         const void *cmnd, void *buffer, unsigned bufflen,
 280         void (*done)(struct scsi_cmnd *), int timeout, int retries)
 281 {
 282     #ifdef STRICT_SERIALIZING
 283         scsi_do_req(sreq, cmnd, buffer, bufflen, done, timeout, retries);
 284     #elif defined(FILEIO_ONLY)
 285         sBUG();
 286     #else
 287         scsi_do_req_fifo(sreq, cmnd, buffer, bufflen, done, timeout, retries);
 288     #endif
 289 }
 290 #else
 291 static inline int scst_exec_req(struct scsi_device *sdev,
 292         const unsigned char *cmd, int cmd_len, int data_direction,
 293         void *buffer, unsigned bufflen, int use_sg, int timeout, int retries,
 294         void *privdata, void (*done)(void *, char *, int, int), gfp_t gfp)
 295 {
 296     #ifdef STRICT_SERIALIZING
 297         return scsi_execute_async(sdev, cmd, cmd_len, data_direction, buffer,
 298                 bufflen, use_sg, timeout, retries, privdata, done, gfp);
 299     #elif defined(FILEIO_ONLY)
 300         sBUG();
 301         return -1;
 302     #else
 303         return scsi_execute_async_fifo(sdev, cmd, cmd_len, data_direction,
 304                 buffer, bufflen, use_sg, timeout, retries, privdata, done, gfp);
 305     #endif
 306 }
 307 #endif
 308
 309 int scst_alloc_space(struct scst_cmd *cmd);
 310 void scst_release_space(struct scst_cmd *cmd);
 311 void scst_scsi_op_list_init(void);
 312
 313 lun_t scst_unpack_lun(const uint8_t *lun, int len);
 314
 315 struct scst_cmd *__scst_find_cmd_by_tag(struct scst_session *sess,
 316         uint32_t tag);
 317
 318 struct scst_mgmt_cmd *scst_alloc_mgmt_cmd(int gfp_mask);
 319 void scst_free_mgmt_cmd(struct scst_mgmt_cmd *mcmd, int del);
 320
 321 /* /proc support */
 322 int scst_proc_init_module(void);
 323 void scst_proc_cleanup_module(void);
 324 int scst_build_proc_target_dir_entries(struct scst_tgt_template *vtt);
 325 void scst_cleanup_proc_target_dir_entries(struct scst_tgt_template *vtt);
 326 int scst_build_proc_target_entries(struct scst_tgt *vtt);
 327 void scst_cleanup_proc_target_entries(struct scst_tgt *vtt);
 328 int scst_build_proc_dev_handler_dir_entries(struct scst_dev_type *dev_type);
 329 void scst_cleanup_proc_dev_handler_dir_entries(struct scst_dev_type *dev_type);
 330
 331 int scst_get_cdb_len(const uint8_t *cdb);
 332
 333 void __scst_process_UA(struct scst_device *dev, struct scst_cmd *exclude,
 334         const uint8_t *sense, int sense_len, int internal);
 335 static inline void scst_process_UA(struct scst_device *dev,
 336         struct scst_cmd *exclude, const uint8_t *sense, int sense_len,
 337         int internal)
 338 {
 339         spin_lock_bh(&dev->dev_lock);
 340         __scst_process_UA(dev, exclude, sense, sense_len, internal);
 341         spin_unlock_bh(&dev->dev_lock);
 342         return;
 343 }
 344 void scst_alloc_set_UA(struct scst_tgt_dev *tgt_dev, const uint8_t *sense,
 345         int sense_len);
 346 void scst_check_set_UA(struct scst_tgt_dev *tgt_dev,
 347         const uint8_t *sense, int sense_len);
 348 int scst_set_pending_UA(struct scst_cmd *cmd);
 349 void scst_free_all_UA(struct scst_tgt_dev *tgt_dev);
 350
 351 void scst_abort_cmd(struct scst_cmd *cmd, struct scst_mgmt_cmd *mcmd,
 352         int other_ini, int call_dev_task_mgmt_fn);
 353 void scst_process_reset(struct scst_device *dev,
 354         struct scst_session *originator, struct scst_cmd *exclude_cmd,
 355         struct scst_mgmt_cmd *mcmd);
 356
 357 static inline int scst_is_ua_command(struct scst_cmd *cmd)
 358 {
 359         return ((cmd->cdb[0] != INQUIRY) &&
 360                 (cmd->cdb[0] != REQUEST_SENSE) &&
 361                 (cmd->cdb[0] != REPORT_LUNS));
 362 }
 363
 364 /*
 365  * Returns 1, if cmd's CDB is locally handled by SCST and 0 otherwise.
 366  * Dev handlers parse() and dev_done() not called for such commands.
 367  */
 368 static inline int scst_is_cmd_local(struct scst_cmd *cmd)
 369 {
 370         int res = 0;
 371         switch (cmd->cdb[0]) {
 372         case REPORT_LUNS:
 373                 res = 1;
 374         }
 375         return res;
 376 }
 377
 378 /*
 379  * Some notes on devices "blocking". Blocking means that no
 380  * commands will go from SCST to underlying SCSI device until it
 381  * is unblocked. But we don't care about all commands that
 382  * already on the device.
 383  */
 384
 385 extern int scst_inc_on_dev_cmd(struct scst_cmd *cmd);
 386 extern void scst_unblock_cmds(struct scst_device *dev);
 387
 388 static inline void __scst_block_dev(struct scst_device *dev)
 389 {
 390         dev->block_count++;
 391         smp_mb();
 392         TRACE_MGMT_DBG("Device BLOCK(%d), dev %p", dev->block_count, dev);
 393 }
 394
 395 static inline void scst_block_dev(struct scst_device *dev,
 396         unsigned int outstanding)
 397 {
 398         spin_lock_bh(&dev->dev_lock);
 399         __scst_block_dev(dev);
 400         spin_unlock_bh(&dev->dev_lock);
 401
 402         TRACE_MGMT_DBG("Waiting during blocking outstanding %d (on_dev_count "
 403                 "%d)", outstanding, atomic_read(&dev->on_dev_count));
 404         wait_event(dev->on_dev_waitQ,
 405                 atomic_read(&dev->on_dev_count) <= outstanding);
 406         TRACE_MGMT_DBG("%s", "wait_event() returned");
 407 }
 408
 409 static inline void scst_unblock_dev(struct scst_device *dev)
 410 {
 411         spin_lock_bh(&dev->dev_lock);
 412         TRACE_MGMT_DBG("Device UNBLOCK(%d), dev %p",
 413                 dev->block_count-1, dev);
 414         if (--dev->block_count == 0)
 415                 scst_unblock_cmds(dev);
 416         spin_unlock_bh(&dev->dev_lock);
 417 }
 418
 419 static inline void scst_dec_on_dev_cmd(struct scst_cmd *cmd)
 420 {
 421         if (cmd->blocking) {
 422                 TRACE_MGMT_DBG("cmd %p (tag %d): unblocking dev %p", cmd,
 423                         cmd->tag, cmd->dev);
 424                 cmd->blocking = 0;
 425                 scst_unblock_dev(cmd->dev);
 426         }
 427         atomic_dec(&cmd->dev->on_dev_count);
 428         smp_mb__after_atomic_dec();
 429         if (unlikely(cmd->dev->block_count != 0))
 430                 wake_up_all(&cmd->dev->on_dev_waitQ);
 431 }
 432
 433 static inline void scst_inc_cmd_count(void)
 434 {
 435         atomic_inc(&scst_cmd_count);
 436         /* It's needed to be before test_bit(SCST_FLAG_SUSPENDED) */
 437         smp_mb__after_atomic_inc();
 438         TRACE_DBG("Incrementing scst_cmd_count(%d)",
 439               atomic_read(&scst_cmd_count));
 440 }
 441
 442 static inline void scst_dec_cmd_count(void)
 443 {
 444         int f;
 445         f = atomic_dec_and_test(&scst_cmd_count);
 446         if (f && unlikely(test_bit(SCST_FLAG_SUSPENDED, &scst_flags)))
 447                 wake_up_all(&scst_dev_cmd_waitQ);
 448         TRACE_DBG("Decrementing scst_cmd_count(%d)",
 449               atomic_read(&scst_cmd_count));
 450 }
 451
 452 void scst_sched_session_free(struct scst_session *sess);
 453
 454 static inline void scst_sess_get(struct scst_session *sess)
 455 {
 456         atomic_inc(&sess->refcnt);
 457 }
 458
 459 static inline void scst_sess_put(struct scst_session *sess)
 460 {
 461         if (atomic_dec_and_test(&sess->refcnt))
 462                 scst_sched_session_free(sess);
 463 }
 464
 465 void __scst_suspend_activity(void);
 466 void __scst_resume_activity(void);
 467
 468 extern void scst_throttle_cmd(struct scst_cmd *cmd);
 469 extern void scst_unthrottle_cmd(struct scst_cmd *cmd);
 470
 471 static inline void scst_set_sense(uint8_t *buffer, int len, int key,
 472         int asc, int ascq)
 473 {
 474         memset(buffer, 0, len);
 475         buffer[0] = 0x70;       /* Error Code                   */
 476         buffer[2] = key;        /* Sense Key                    */
 477         buffer[7] = 0x0a;       /* Additional Sense Length      */
 478         buffer[12] = asc;       /* ASC                          */
 479         buffer[13] = ascq;      /* ASCQ                         */
 480         TRACE_BUFFER("Sense set", buffer, len);
 481         return;
 482 }
 483
 484 static inline void scst_check_restore_sg_buff(struct scst_cmd *cmd)
 485 {
 486         if (cmd->sg_buff_modified) {
 487                 cmd->sg[cmd->orig_sg_entry].length = cmd->orig_entry_len;
 488                 cmd->sg_cnt = cmd->orig_sg_cnt;
 489         }
 490 }
 491
 492 #ifdef DEBUG_TM
 493 extern void tm_dbg_init_tgt_dev(struct scst_tgt_dev *tgt_dev,
 494         struct scst_acg_dev *acg_dev);
 495 extern void tm_dbg_deinit_tgt_dev(struct scst_tgt_dev *tgt_dev);
 496 extern void tm_dbg_check_released_cmds(void);
 497 extern int tm_dbg_check_cmd(struct scst_cmd *cmd);
 498 extern void tm_dbg_release_cmd(struct scst_cmd *cmd);
 499 extern void tm_dbg_task_mgmt(const char *fn);
 500 extern int tm_dbg_is_release(void);
 501 #else
 502 static inline void tm_dbg_init_tgt_dev(struct scst_tgt_dev *tgt_dev,
 503         struct scst_acg_dev *acg_dev) {}
 504 static inline void tm_dbg_deinit_tgt_dev(struct scst_tgt_dev *tgt_dev) {}
 505 static inline void tm_dbg_check_released_cmds(void) {}
 506 static inline int tm_dbg_check_cmd(struct scst_cmd *cmd)
 507 {
 508         return 0;
 509 }
 510 static inline void tm_dbg_release_cmd(struct scst_cmd *cmd) {}
 511 static inline void tm_dbg_task_mgmt(const char *fn) {}
 512 static inline int tm_dbg_is_release(void)
 513 {
 514         return 0;
 515 }
 516 #endif /* DEBUG_TM */
 517
 518 #endif /* __SCST_PRIV_H */