Various sysfs related fixes
[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, 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__ */