iscsi-scst/kernel/iscsi.h

   1 /*
   2  *  Copyright (C) 2002 - 2003 Ardis Technolgies <roman@ardistech.com>
   3  *  Copyright (C) 2007 - 2009 Vladislav Bolkhovitin
   4  *  Copyright (C) 2007 - 2009 ID7 Ltd.
   5  *
   6  *  This program is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU General Public License
   8  *  as published by the Free Software Foundation, version 2
   9  *  of the License.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  *  GNU General Public License for more details.
  15  */
  16
  17 #ifndef __ISCSI_H__
  18 #define __ISCSI_H__
  19
  20 #include <linux/pagemap.h>
  21 #include <linux/mm.h>
  22 #include <linux/net.h>
  23 #include <net/sock.h>
  24
  25 #include <scst.h>
  26
  27 #include "iscsi_hdr.h"
  28 #include "iscsi_scst.h"
  29
  30 #include "iscsi_dbg.h"
  31
  32 #define iscsi_sense_crc_error                   ABORTED_COMMAND, 0x47, 0x5
  33 #define iscsi_sense_unexpected_unsolicited_data ABORTED_COMMAND, 0xC, 0xC
  34
  35 struct iscsi_sess_param {
  36         int initial_r2t;
  37         int immediate_data;
  38         int max_connections;
  39         unsigned int max_recv_data_length;
  40         unsigned int max_xmit_data_length;
  41         unsigned int max_burst_length;
  42         unsigned int first_burst_length;
  43         int default_wait_time;
  44         int default_retain_time;
  45         unsigned int max_outstanding_r2t;
  46         int data_pdu_inorder;
  47         int data_sequence_inorder;
  48         int error_recovery_level;
  49         int header_digest;
  50         int data_digest;
  51         int ofmarker;
  52         int ifmarker;
  53         int ofmarkint;
  54         int ifmarkint;
  55 };
  56
  57 struct iscsi_trgt_param {
  58         int queued_cmnds;
  59 };
  60
  61 struct network_thread_info {
  62         struct task_struct *task;
  63         unsigned int ready;
  64 };
  65
  66 struct iscsi_cmnd;
  67
  68 struct iscsi_target {
  69         struct scst_tgt *scst_tgt;
  70
  71         struct mutex target_mutex;
  72
  73         struct list_head session_list; /* protected by target_mutex */
  74
  75         /* Both protected by target_mgmt_mutex */
  76         struct iscsi_trgt_param trgt_param;
  77         /*
  78          * Put here to have uniform parameters checking and assigning
  79          * from various places, including iscsi-scst-adm.
  80          */
  81         struct iscsi_sess_param trgt_sess_param;
  82
  83         struct list_head target_list_entry;
  84         u32 tid;
  85         char name[ISCSI_NAME_LEN];
  86 };
  87
  88 #define ISCSI_HASH_ORDER        8
  89 #define cmnd_hashfn(itt)        hash_long((itt), ISCSI_HASH_ORDER)
  90
  91 struct iscsi_session {
  92         struct iscsi_target *target;
  93         struct scst_session *scst_sess;
  94
  95         struct list_head pending_list; /* protected by sn_lock */
  96
  97         /* Unprotected, since accessed only from a single read thread */
  98         u32 next_ttt;
  99
 100         u32 max_queued_cmnds; /* unprotected, since read-only */
 101         atomic_t active_cmds;
 102
 103         spinlock_t sn_lock;
 104         u32 exp_cmd_sn; /* protected by sn_lock */
 105
 106         /* All 3 protected by sn_lock */
 107         int tm_active;
 108         u32 tm_sn;
 109         struct iscsi_cmnd *tm_rsp;
 110
 111         /* Read only, if there are connection(s) */
 112         struct iscsi_sess_param sess_param;
 113
 114         spinlock_t cmnd_hash_lock;
 115         struct list_head cmnd_hash[1 << ISCSI_HASH_ORDER];
 116
 117         struct list_head conn_list; /* protected by target_mutex */
 118
 119         struct list_head session_list_entry;
 120
 121         /* All protected by target_mutex, where necessary */
 122         struct iscsi_session *sess_reinst_successor;
 123         unsigned int sess_reinstating:1;
 124         unsigned int sess_shutting_down:1;
 125
 126         /* All don't need any protection */
 127         char *initiator_name;
 128         u64 sid;
 129 };
 130
 131 #define ISCSI_CONN_IOV_MAX                      (PAGE_SIZE/sizeof(struct iovec))
 132
 133 #define ISCSI_CONN_RD_STATE_IDLE                0
 134 #define ISCSI_CONN_RD_STATE_IN_LIST             1
 135 #define ISCSI_CONN_RD_STATE_PROCESSING          2
 136
 137 #define ISCSI_CONN_WR_STATE_IDLE                0
 138 #define ISCSI_CONN_WR_STATE_IN_LIST             1
 139 #define ISCSI_CONN_WR_STATE_SPACE_WAIT          2
 140 #define ISCSI_CONN_WR_STATE_PROCESSING          3
 141
 142 struct iscsi_conn {
 143         struct iscsi_session *session; /* owning session */
 144
 145         /* Both protected by session->sn_lock */
 146         u32 stat_sn;
 147         u32 exp_stat_sn;
 148
 149 #define ISCSI_CONN_REINSTATING  1
 150 #define ISCSI_CONN_SHUTTINGDOWN 2
 151         unsigned long conn_aflags;
 152
 153         spinlock_t cmd_list_lock; /* BH lock */
 154
 155         /* Protected by cmd_list_lock */
 156         struct list_head cmd_list; /* in/outcoming pdus */
 157
 158         atomic_t conn_ref_cnt;
 159
 160         spinlock_t write_list_lock;
 161         /* List of data pdus to be sent, protected by write_list_lock */
 162         struct list_head write_list;
 163         /* List of data pdus being sent, protected by write_list_lock */
 164         struct list_head written_list;
 165
 166         struct timer_list rsp_timer;
 167
 168         /* All 2 protected by iscsi_wr_lock */
 169         unsigned short wr_state;
 170         unsigned short wr_space_ready:1;
 171
 172         struct list_head wr_list_entry;
 173
 174 #ifdef CONFIG_SCST_EXTRACHECKS
 175         struct task_struct *wr_task;
 176 #endif
 177
 178         /*
 179          * All are unprotected, since accessed only from a single write
 180          * thread.
 181          */
 182         struct iscsi_cmnd *write_cmnd;
 183         struct iovec *write_iop;
 184         int write_iop_used;
 185         struct iovec write_iov[2];
 186         u32 write_size;
 187         u32 write_offset;
 188         int write_state;
 189
 190         /* Both don't need any protection */
 191         struct file *file;
 192         struct socket *sock;
 193
 194         void (*old_state_change)(struct sock *);
 195         void (*old_data_ready)(struct sock *, int);
 196         void (*old_write_space)(struct sock *);
 197
 198         /* Both read only. Stay here for better CPU cache locality. */
 199         int hdigest_type;
 200         int ddigest_type;
 201
 202         /* All 5 protected by iscsi_rd_lock */
 203         unsigned short rd_state;
 204         unsigned short rd_data_ready:1;
 205         /* Let's save some cache footprint by putting them here */
 206         unsigned short closing:1;
 207         unsigned short active_close:1;
 208         unsigned short deleting:1;
 209
 210         struct list_head rd_list_entry;
 211
 212 #ifdef CONFIG_SCST_EXTRACHECKS
 213         struct task_struct *rd_task;
 214 #endif
 215
 216         /*
 217          * All are unprotected, since accessed only from a single read
 218          * thread.
 219          */
 220         struct iscsi_cmnd *read_cmnd;
 221         struct msghdr read_msg;
 222         u32 read_size;
 223         int read_state;
 224         struct iovec *read_iov;
 225         struct task_struct *rx_task;
 226         uint32_t rpadding;
 227
 228         struct iscsi_target *target;
 229
 230         struct list_head conn_list_entry; /* list entry in session conn_list */
 231
 232         /* All protected by target_mutex, where necessary */
 233         struct iscsi_conn *conn_reinst_successor;
 234         struct list_head reinst_pending_cmd_list;
 235
 236         wait_queue_head_t read_state_waitQ;
 237         struct completion ready_to_free;
 238
 239         /* Doesn't need any protection */
 240         u16 cid;
 241
 242 #ifndef CONFIG_SCST_PROC
 243         /* Doesn't need any protection */
 244         struct kobject iscsi_conn_kobj;
 245 #endif /* CONFIG_SCST_PROC */
 246 };
 247
 248 struct iscsi_pdu {
 249         struct iscsi_hdr bhs;
 250         void *ahs;
 251         unsigned int ahssize;
 252         unsigned int datasize;
 253 };
 254
 255 typedef void (iscsi_show_info_t)(struct seq_file *seq,
 256                                  struct iscsi_target *target);
 257
 258 /** Command's states **/
 259
 260 /* New command and SCST processes it */
 261 #define ISCSI_CMD_STATE_NEW               0
 262
 263 /* SCST processes cmd after scst_rx_cmd() */
 264 #define ISCSI_CMD_STATE_RX_CMD            1
 265
 266 /* The command returned from preprocessing_done() */
 267 #define ISCSI_CMD_STATE_AFTER_PREPROC     2
 268
 269 /* The command is waiting for session or connection reinstatement finished */
 270 #define ISCSI_CMD_STATE_REINST_PENDING    3
 271
 272 /* scst_restart_cmd() called and SCST processing it */
 273 #define ISCSI_CMD_STATE_RESTARTED         4
 274
 275 /* SCST done processing */
 276 #define ISCSI_CMD_STATE_PROCESSED         5
 277
 278 /* AEN processing */
 279 #define ISCSI_CMD_STATE_AEN               6
 280
 281 /** Command's reject reasons **/
 282 #define ISCSI_REJECT_SCSI_CMD             1
 283 #define ISCSI_REJECT_CMD                  2
 284 #define ISCSI_REJECT_DATA                 3
 285
 286 /*
 287  * Most of the fields don't need any protection, since accessed from only a
 288  * single thread, except where noted.
 289  */
 290 struct iscsi_cmnd {
 291         struct iscsi_conn *conn;
 292
 293         /*
 294          * Some flags protected by conn->write_list_lock, but all modified only
 295          * from single read thread or when there are no references to cmd.
 296          */
 297         unsigned int hashed:1;
 298         unsigned int should_close_conn:1;
 299         unsigned int should_close_all_conn:1;
 300         unsigned int pending:1;
 301         unsigned int own_sg:1;
 302         unsigned int on_write_list:1;
 303         unsigned int write_processing_started:1;
 304         unsigned int data_waiting:1;
 305         unsigned int force_cleanup_done:1;
 306         unsigned int dec_active_cmnds:1;
 307         unsigned int ddigest_checked:1;
 308         unsigned int rejected:1;
 309         unsigned int reject_reason:2;
 310 #ifdef CONFIG_SCST_EXTRACHECKS
 311         unsigned int on_rx_digest_list:1;
 312         unsigned int release_called:1;
 313 #endif
 314
 315         /* It's async. with the above flags */
 316         volatile unsigned int tm_aborted;
 317
 318         struct list_head hash_list_entry;
 319
 320         spinlock_t rsp_cmd_lock; /* BH lock */
 321
 322         /*
 323          * Unions are for readability and grepability and to save some
 324          * cache footprint.
 325          */
 326
 327         union {
 328                 /* Protected by rsp_cmd_lock */
 329                 struct list_head rsp_cmd_list;
 330                 struct list_head rsp_cmd_list_entry;
 331         };
 332
 333         union {
 334                 struct list_head pending_list_entry;
 335                 struct list_head reinst_pending_cmd_list_entry;
 336         };
 337
 338         union {
 339                 struct list_head write_list_entry;
 340                 struct list_head written_list_entry;
 341         };
 342
 343         /* Both modified only from single write thread */
 344         unsigned int on_written_list:1;
 345         unsigned long write_timeout;
 346
 347         /*
 348          * All unprotected, since could be accessed from only a single
 349          * thread at time
 350          */
 351         struct iscsi_cmnd *parent_req;
 352         struct iscsi_cmnd *cmd_req;
 353
 354         /*
 355          * All unprotected, since could be accessed from only a single
 356          * thread at time
 357          */
 358         union {
 359                 /* Request only fields */
 360                 struct {
 361                         struct list_head rx_ddigest_cmd_list;
 362                         struct list_head rx_ddigest_cmd_list_entry;
 363
 364                         int scst_state;
 365                         union {
 366                                 struct scst_cmd *scst_cmd;
 367                                 struct scst_aen *scst_aen;
 368                         };
 369                         int read_size;
 370                 };
 371
 372                 /* Response only fields */
 373                 struct {
 374                         struct scatterlist rsp_sg[2];
 375                         struct iscsi_sense_data sense_hdr;
 376                 };
 377         };
 378
 379         atomic_t ref_cnt;
 380 #if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION)
 381         atomic_t net_ref_cnt;
 382 #endif
 383
 384         struct iscsi_pdu pdu;
 385
 386         struct scatterlist *sg;
 387         int sg_cnt;
 388         unsigned int bufflen;
 389         u32 r2t_sn;
 390         u32 r2t_length;
 391         u32 is_unsolicited_data;
 392         u32 target_task_tag;
 393         u32 outstanding_r2t;
 394
 395         u32 hdigest;
 396         u32 ddigest;
 397
 398         struct list_head cmd_list_entry;
 399 };
 400
 401 /* Flags for req_cmnd_release_force() */
 402 #define ISCSI_FORCE_RELEASE_WRITE       1
 403
 404 #define ISCSI_RSP_TIMEOUT               (30 * HZ)
 405
 406 extern struct mutex target_mgmt_mutex;
 407
 408 extern const struct file_operations ctr_fops;
 409
 410 extern spinlock_t iscsi_rd_lock;
 411 extern struct list_head iscsi_rd_list;
 412 extern wait_queue_head_t iscsi_rd_waitQ;
 413
 414 extern spinlock_t iscsi_wr_lock;
 415 extern struct list_head iscsi_wr_list;
 416 extern wait_queue_head_t iscsi_wr_waitQ;
 417
 418 /* iscsi.c */
 419 extern struct iscsi_cmnd *cmnd_alloc(struct iscsi_conn *,
 420         struct iscsi_cmnd *parent);
 421 extern int cmnd_rx_start(struct iscsi_cmnd *);
 422 extern int cmnd_rx_continue(struct iscsi_cmnd *req);
 423 extern void cmnd_rx_end(struct iscsi_cmnd *);
 424 extern void cmnd_tx_start(struct iscsi_cmnd *);
 425 extern void cmnd_tx_end(struct iscsi_cmnd *);
 426 extern void req_cmnd_release_force(struct iscsi_cmnd *req, int flags);
 427 extern void rsp_cmnd_release(struct iscsi_cmnd *);
 428 extern void cmnd_done(struct iscsi_cmnd *cmnd);
 429 extern void conn_abort(struct iscsi_conn *conn);
 430 extern void iscsi_restart_cmnd(struct iscsi_cmnd *cmnd);
 431
 432 /* conn.c */
 433 extern struct iscsi_conn *conn_lookup(struct iscsi_session *, u16);
 434 extern void conn_reinst_finished(struct iscsi_conn *);
 435 extern int conn_add(struct iscsi_session *, struct iscsi_kern_conn_info *);
 436 extern int conn_del(struct iscsi_session *, struct iscsi_kern_conn_info *);
 437 #ifdef CONFIG_SCST_PROC
 438 extern int conn_free(struct iscsi_conn *);
 439 #endif
 440 extern void iscsi_make_conn_rd_active(struct iscsi_conn *conn);
 441
 442 #define ISCSI_CONN_ACTIVE_CLOSE         1
 443 #define ISCSI_CONN_DELETING             2
 444 extern void __mark_conn_closed(struct iscsi_conn *, int);
 445
 446 extern void mark_conn_closed(struct iscsi_conn *);
 447 extern void iscsi_make_conn_wr_active(struct iscsi_conn *);
 448
 449 #ifdef CONFIG_SCST_PROC
 450 extern void conn_info_show(struct seq_file *, struct iscsi_session *);
 451 #endif
 452
 453 /* nthread.c */
 454 extern int iscsi_send(struct iscsi_conn *conn);
 455 #if defined(CONFIG_TCP_ZERO_COPY_TRANSFER_COMPLETION_NOTIFICATION)
 456 extern void iscsi_get_page_callback(struct page *page);
 457 extern void iscsi_put_page_callback(struct page *page);
 458 #endif
 459 extern int istrd(void *arg);
 460 extern int istwr(void *arg);
 461 extern void iscsi_task_mgmt_affected_cmds_done(struct scst_mgmt_cmd *scst_mcmd);
 462
 463 /* target.c */
 464 #ifndef CONFIG_SCST_PROC
 465 extern const struct attribute *iscsi_tgt_attrs[];
 466 #endif
 467 struct iscsi_target *target_lookup_by_id(u32);
 468 extern int target_add(struct iscsi_kern_target_info *);
 469 extern int target_del(u32 id);
 470 extern void target_del_session(struct iscsi_target *target,
 471         struct iscsi_session *session, int flags);
 472 extern void target_del_all_sess(struct iscsi_target *target, int flags);
 473 extern void target_del_all(void);
 474
 475 extern const struct seq_operations iscsi_seq_op;
 476
 477 /* config.c */
 478 #ifdef CONFIG_SCST_PROC
 479 extern int iscsi_procfs_init(void);
 480 extern void iscsi_procfs_exit(void);
 481 #else
 482 extern const struct attribute *iscsi_attrs[];
 483 #endif
 484
 485 /* session.c */
 486 #ifdef CONFIG_SCST_PROC
 487 int print_digest_state(char *p, size_t size, unsigned long flags);
 488 #else
 489 extern const struct attribute *iscsi_sess_attrs[];
 490 #endif
 491 extern const struct file_operations session_seq_fops;
 492 extern struct iscsi_session *session_lookup(struct iscsi_target *, u64);
 493 extern void sess_reinst_finished(struct iscsi_session *);
 494 extern int session_add(struct iscsi_target *, struct iscsi_kern_session_info *);
 495 extern int session_del(struct iscsi_target *, u64);
 496 extern int session_free(struct iscsi_session *session, bool del);
 497
 498 /* params.c */
 499 extern int iscsi_param_set(struct iscsi_target *,
 500         struct iscsi_kern_param_info *, int);
 501
 502 /* event.c */
 503 extern int event_send(u32, u64, u32, u32, int);
 504 extern int event_init(void);
 505 extern void event_exit(void);
 506
 507 #define get_pgcnt(size, offset) \
 508         ((((size) + ((offset) & ~PAGE_MASK)) + PAGE_SIZE - 1) >> PAGE_SHIFT)
 509
 510 static inline void iscsi_cmnd_get_length(struct iscsi_pdu *pdu)
 511 {
 512 #if defined(__BIG_ENDIAN)
 513         pdu->ahssize = pdu->bhs.length.ahslength * 4;
 514         pdu->datasize = pdu->bhs.length.datalength;
 515 #elif defined(__LITTLE_ENDIAN)
 516         pdu->ahssize = (pdu->bhs.length & 0xff) * 4;
 517         pdu->datasize = be32_to_cpu(pdu->bhs.length & ~0xff);
 518 #else
 519 #error
 520 #endif
 521 }
 522
 523 static inline void iscsi_cmnd_set_length(struct iscsi_pdu *pdu)
 524 {
 525 #if defined(__BIG_ENDIAN)
 526         pdu->bhs.length.ahslength = pdu->ahssize / 4;
 527         pdu->bhs.length.datalength = pdu->datasize;
 528 #elif defined(__LITTLE_ENDIAN)
 529         pdu->bhs.length = cpu_to_be32(pdu->datasize) | (pdu->ahssize / 4);
 530 #else
 531 #error
 532 #endif
 533 }
 534
 535 extern struct scst_tgt_template iscsi_template;
 536
 537 /*
 538  * Skip this command if result is not 0. Must be called under
 539  * corresponding lock.
 540  */
 541 static inline bool cmnd_get_check(struct iscsi_cmnd *cmnd)
 542 {
 543         int r = atomic_inc_return(&cmnd->ref_cnt);
 544         int res;
 545         if (unlikely(r == 1)) {
 546                 TRACE_DBG("cmnd %p is being destroyed", cmnd);
 547                 atomic_dec(&cmnd->ref_cnt);
 548                 res = 1;
 549                 /* Necessary code is serialized by locks in cmnd_done() */
 550         } else {
 551                 TRACE_DBG("cmnd %p, new ref_cnt %d", cmnd,
 552                         atomic_read(&cmnd->ref_cnt));
 553                 res = 0;
 554         }
 555         return res;
 556 }
 557
 558 static inline void cmnd_get(struct iscsi_cmnd *cmnd)
 559 {
 560         atomic_inc(&cmnd->ref_cnt);
 561         TRACE_DBG("cmnd %p, new cmnd->ref_cnt %d", cmnd,
 562                 atomic_read(&cmnd->ref_cnt));
 563 }
 564
 565 static inline void cmnd_get_ordered(struct iscsi_cmnd *cmnd)
 566 {
 567         cmnd_get(cmnd);
 568         /* See comments for each cmnd_get_ordered() use */
 569         smp_mb__after_atomic_inc();
 570 }
 571
 572 static inline void cmnd_put(struct iscsi_cmnd *cmnd)
 573 {
 574         TRACE_DBG("cmnd %p, new ref_cnt %d", cmnd,
 575                 atomic_read(&cmnd->ref_cnt)-1);
 576
 577         EXTRACHECKS_BUG_ON(atomic_read(&cmnd->ref_cnt) == 0);
 578
 579         if (atomic_dec_and_test(&cmnd->ref_cnt))
 580                 cmnd_done(cmnd);
 581 }
 582
 583 /* conn->write_list_lock supposed to be locked and BHs off */
 584 static inline void cmd_add_on_write_list(struct iscsi_conn *conn,
 585         struct iscsi_cmnd *cmnd)
 586 {
 587         TRACE_DBG("%p", cmnd);
 588         list_add_tail(&cmnd->write_list_entry, &conn->write_list);
 589         cmnd->on_write_list = 1;
 590 }
 591
 592 /* conn->write_list_lock supposed to be locked and BHs off */
 593 static inline void cmd_del_from_write_list(struct iscsi_cmnd *cmnd)
 594 {
 595         TRACE_DBG("%p", cmnd);
 596         list_del(&cmnd->write_list_entry);
 597         cmnd->on_write_list = 0;
 598 }
 599
 600 static inline void cmd_add_on_rx_ddigest_list(struct iscsi_cmnd *req,
 601         struct iscsi_cmnd *cmnd)
 602 {
 603         TRACE_DBG("Adding RX ddigest cmd %p to digest list "
 604                         "of req %p", cmnd, req);
 605         list_add_tail(&cmnd->rx_ddigest_cmd_list_entry,
 606                         &req->rx_ddigest_cmd_list);
 607 #ifdef CONFIG_SCST_EXTRACHECKS
 608         cmnd->on_rx_digest_list = 1;
 609 #endif
 610 }
 611
 612 static inline void cmd_del_from_rx_ddigest_list(struct iscsi_cmnd *cmnd)
 613 {
 614         TRACE_DBG("Deleting RX digest cmd %p from digest list", cmnd);
 615         list_del(&cmnd->rx_ddigest_cmd_list_entry);
 616 #ifdef CONFIG_SCST_EXTRACHECKS
 617         cmnd->on_rx_digest_list = 0;
 618 #endif
 619 }
 620
 621 static inline int test_write_ready(struct iscsi_conn *conn)
 622 {
 623         /*
 624          * No need for write_list protection, in the worst case we will be
 625          * restarted again.
 626          */
 627         return !list_empty(&conn->write_list) || conn->write_cmnd;
 628 }
 629
 630 static inline void conn_get(struct iscsi_conn *conn)
 631 {
 632         atomic_inc(&conn->conn_ref_cnt);
 633         TRACE_DBG("conn %p, new conn_ref_cnt %d", conn,
 634                 atomic_read(&conn->conn_ref_cnt));
 635 }
 636
 637 static inline void conn_get_ordered(struct iscsi_conn *conn)
 638 {
 639         conn_get(conn);
 640         /* See comments for each conn_get_ordered() use */
 641         smp_mb__after_atomic_inc();
 642 }
 643
 644 static inline void conn_put(struct iscsi_conn *conn)
 645 {
 646         TRACE_DBG("conn %p, new conn_ref_cnt %d", conn,
 647                 atomic_read(&conn->conn_ref_cnt)-1);
 648         sBUG_ON(atomic_read(&conn->conn_ref_cnt) == 0);
 649
 650         /*
 651          * Make it always ordered to protect from undesired side effects like
 652          * accessing just destroyed by close_conn() conn caused by reordering
 653          * of this atomic_dec().
 654          */
 655         smp_mb__before_atomic_dec();
 656         atomic_dec(&conn->conn_ref_cnt);
 657 }
 658
 659 #ifdef CONFIG_SCST_EXTRACHECKS
 660 extern void iscsi_extracheck_is_rd_thread(struct iscsi_conn *conn);
 661 extern void iscsi_extracheck_is_wr_thread(struct iscsi_conn *conn);
 662 #else
 663 static inline void iscsi_extracheck_is_rd_thread(struct iscsi_conn *conn) {}
 664 static inline void iscsi_extracheck_is_wr_thread(struct iscsi_conn *conn) {}
 665 #endif
 666
 667 #endif  /* __ISCSI_H__ */