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