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