← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to include/scsi/scsi_transport_iscsi.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/scsi/scsi_transport_iscsi.h
 
1
/*
 
2
 * iSCSI transport class definitions
 
3
 *
 
4
 * Copyright (C) IBM Corporation, 2004
 
5
 * Copyright (C) Mike Christie, 2004 - 2006
 
6
 * Copyright (C) Dmitry Yusupov, 2004 - 2005
 
7
 * Copyright (C) Alex Aizman, 2004 - 2005
 
8
 *
 
9
 * This program is free software; you can redistribute it and/or modify
 
10
 * it under the terms of the GNU General Public License as published by
 
11
 * the Free Software Foundation; either version 2 of the License, or
 
12
 * (at your option) any later version.
 
13
 *
 
14
 * This program is distributed in the hope that it will be useful,
 
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
 * GNU General Public License for more details.
 
18
 *
 
19
 * You should have received a copy of the GNU General Public License
 
20
 * along with this program; if not, write to the Free Software
 
21
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
22
 */
 
23
#ifndef SCSI_TRANSPORT_ISCSI_H
 
24
#define SCSI_TRANSPORT_ISCSI_H
 
25
 
 
26
#include <linux/device.h>
 
27
#include <linux/list.h>
 
28
#include <linux/mutex.h>
 
29
#include <scsi/iscsi_if.h>
 
30
 
 
31
struct scsi_transport_template;
 
32
struct iscsi_transport;
 
33
struct iscsi_endpoint;
 
34
struct Scsi_Host;
 
35
struct scsi_cmnd;
 
36
struct iscsi_cls_conn;
 
37
struct iscsi_conn;
 
38
struct iscsi_task;
 
39
struct sockaddr;
 
40
struct iscsi_iface;
 
41
struct bsg_job;
 
42
 
 
43
/**
 
44
 * struct iscsi_transport - iSCSI Transport template
 
45
 *
 
46
 * @name:               transport name
 
47
 * @caps:               iSCSI Data-Path capabilities
 
48
 * @create_session:     create new iSCSI session object
 
49
 * @destroy_session:    destroy existing iSCSI session object
 
50
 * @create_conn:        create new iSCSI connection
 
51
 * @bind_conn:          associate this connection with existing iSCSI session
 
52
 *                      and specified transport descriptor
 
53
 * @destroy_conn:       destroy inactive iSCSI connection
 
54
 * @set_param:          set iSCSI parameter. Return 0 on success, -ENODATA
 
55
 *                      when param is not supported, and a -Exx value on other
 
56
 *                      error.
 
57
 * @get_param           get iSCSI parameter. Must return number of bytes
 
58
 *                      copied to buffer on success, -ENODATA when param
 
59
 *                      is not supported, and a -Exx value on other error
 
60
 * @start_conn:         set connection to be operational
 
61
 * @stop_conn:          suspend/recover/terminate connection
 
62
 * @send_pdu:           send iSCSI PDU, Login, Logout, NOP-Out, Reject, Text.
 
63
 * @session_recovery_timedout: notify LLD a block during recovery timed out
 
64
 * @init_task:          Initialize a iscsi_task and any internal structs.
 
65
 *                      When offloading the data path, this is called from
 
66
 *                      queuecommand with the session lock, or from the
 
67
 *                      iscsi_conn_send_pdu context with the session lock.
 
68
 *                      When not offloading the data path, this is called
 
69
 *                      from the scsi work queue without the session lock.
 
70
 * @xmit_task           Requests LLD to transfer cmd task. Returns 0 or the
 
71
 *                      the number of bytes transferred on success, and -Exyz
 
72
 *                      value on error. When offloading the data path, this
 
73
 *                      is called from queuecommand with the session lock, or
 
74
 *                      from the iscsi_conn_send_pdu context with the session
 
75
 *                      lock. When not offloading the data path, this is called
 
76
 *                      from the scsi work queue without the session lock.
 
77
 * @cleanup_task:       requests LLD to fail task. Called with session lock
 
78
 *                      and after the connection has been suspended and
 
79
 *                      terminated during recovery. If called
 
80
 *                      from abort task then connection is not suspended
 
81
 *                      or terminated but sk_callback_lock is held
 
82
 *
 
83
 * Template API provided by iSCSI Transport
 
84
 */
 
85
struct iscsi_transport {
 
86
        struct module *owner;
 
87
        char *name;
 
88
        unsigned int caps;
 
89
 
 
90
        struct iscsi_cls_session *(*create_session) (struct iscsi_endpoint *ep,
 
91
                                        uint16_t cmds_max, uint16_t qdepth,
 
92
                                        uint32_t sn);
 
93
        void (*destroy_session) (struct iscsi_cls_session *session);
 
94
        struct iscsi_cls_conn *(*create_conn) (struct iscsi_cls_session *sess,
 
95
                                uint32_t cid);
 
96
        int (*bind_conn) (struct iscsi_cls_session *session,
 
97
                          struct iscsi_cls_conn *cls_conn,
 
98
                          uint64_t transport_eph, int is_leading);
 
99
        int (*start_conn) (struct iscsi_cls_conn *conn);
 
100
        void (*stop_conn) (struct iscsi_cls_conn *conn, int flag);
 
101
        void (*destroy_conn) (struct iscsi_cls_conn *conn);
 
102
        int (*set_param) (struct iscsi_cls_conn *conn, enum iscsi_param param,
 
103
                          char *buf, int buflen);
 
104
        int (*get_ep_param) (struct iscsi_endpoint *ep, enum iscsi_param param,
 
105
                             char *buf);
 
106
        int (*get_conn_param) (struct iscsi_cls_conn *conn,
 
107
                               enum iscsi_param param, char *buf);
 
108
        int (*get_session_param) (struct iscsi_cls_session *session,
 
109
                                  enum iscsi_param param, char *buf);
 
110
        int (*get_host_param) (struct Scsi_Host *shost,
 
111
                                enum iscsi_host_param param, char *buf);
 
112
        int (*set_host_param) (struct Scsi_Host *shost,
 
113
                               enum iscsi_host_param param, char *buf,
 
114
                               int buflen);
 
115
        int (*send_pdu) (struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
 
116
                         char *data, uint32_t data_size);
 
117
        void (*get_stats) (struct iscsi_cls_conn *conn,
 
118
                           struct iscsi_stats *stats);
 
119
 
 
120
        int (*init_task) (struct iscsi_task *task);
 
121
        int (*xmit_task) (struct iscsi_task *task);
 
122
        void (*cleanup_task) (struct iscsi_task *task);
 
123
 
 
124
        int (*alloc_pdu) (struct iscsi_task *task, uint8_t opcode);
 
125
        int (*xmit_pdu) (struct iscsi_task *task);
 
126
        int (*init_pdu) (struct iscsi_task *task, unsigned int offset,
 
127
                         unsigned int count);
 
128
        void (*parse_pdu_itt) (struct iscsi_conn *conn, itt_t itt,
 
129
                               int *index, int *age);
 
130
 
 
131
        void (*session_recovery_timedout) (struct iscsi_cls_session *session);
 
132
        struct iscsi_endpoint *(*ep_connect) (struct Scsi_Host *shost,
 
133
                                              struct sockaddr *dst_addr,
 
134
                                              int non_blocking);
 
135
        int (*ep_poll) (struct iscsi_endpoint *ep, int timeout_ms);
 
136
        void (*ep_disconnect) (struct iscsi_endpoint *ep);
 
137
        int (*tgt_dscvr) (struct Scsi_Host *shost, enum iscsi_tgt_dscvr type,
 
138
                          uint32_t enable, struct sockaddr *dst_addr);
 
139
        int (*set_path) (struct Scsi_Host *shost, struct iscsi_path *params);
 
140
        int (*set_iface_param) (struct Scsi_Host *shost, void *data,
 
141
                                uint32_t len);
 
142
        int (*get_iface_param) (struct iscsi_iface *iface,
 
143
                                enum iscsi_param_type param_type,
 
144
                                int param, char *buf);
 
145
        mode_t (*attr_is_visible)(int param_type, int param);
 
146
        int (*bsg_request)(struct bsg_job *job);
 
147
};
 
148
 
 
149
/*
 
150
 * transport registration upcalls
 
151
 */
 
152
extern struct scsi_transport_template *iscsi_register_transport(struct iscsi_transport *tt);
 
153
extern int iscsi_unregister_transport(struct iscsi_transport *tt);
 
154
 
 
155
/*
 
156
 * control plane upcalls
 
157
 */
 
158
extern void iscsi_conn_error_event(struct iscsi_cls_conn *conn,
 
159
                                   enum iscsi_err error);
 
160
extern void iscsi_conn_login_event(struct iscsi_cls_conn *conn,
 
161
                                   enum iscsi_conn_state state);
 
162
extern int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
 
163
                          char *data, uint32_t data_size);
 
164
 
 
165
extern int iscsi_offload_mesg(struct Scsi_Host *shost,
 
166
                              struct iscsi_transport *transport, uint32_t type,
 
167
                              char *data, uint16_t data_size);
 
168
 
 
169
struct iscsi_cls_conn {
 
170
        struct list_head conn_list;     /* item in connlist */
 
171
        void *dd_data;                  /* LLD private data */
 
172
        struct iscsi_transport *transport;
 
173
        uint32_t cid;                   /* connection id */
 
174
        struct mutex ep_mutex;
 
175
        struct iscsi_endpoint *ep;
 
176
 
 
177
        struct device dev;              /* sysfs transport/container device */
 
178
};
 
179
 
 
180
#define iscsi_dev_to_conn(_dev) \
 
181
        container_of(_dev, struct iscsi_cls_conn, dev)
 
182
 
 
183
#define transport_class_to_conn(_cdev) \
 
184
        iscsi_dev_to_conn(_cdev->parent)
 
185
 
 
186
#define iscsi_conn_to_session(_conn) \
 
187
        iscsi_dev_to_session(_conn->dev.parent)
 
188
 
 
189
/* iscsi class session state */
 
190
enum {
 
191
        ISCSI_SESSION_LOGGED_IN,
 
192
        ISCSI_SESSION_FAILED,
 
193
        ISCSI_SESSION_FREE,
 
194
};
 
195
 
 
196
#define ISCSI_MAX_TARGET -1
 
197
 
 
198
struct iscsi_cls_session {
 
199
        struct list_head sess_list;             /* item in session_list */
 
200
        struct iscsi_transport *transport;
 
201
        spinlock_t lock;
 
202
        struct work_struct block_work;
 
203
        struct work_struct unblock_work;
 
204
        struct work_struct scan_work;
 
205
        struct work_struct unbind_work;
 
206
 
 
207
        /* recovery fields */
 
208
        int recovery_tmo;
 
209
        struct delayed_work recovery_work;
 
210
 
 
211
        unsigned int target_id;
 
212
        bool ida_used;
 
213
 
 
214
        int state;
 
215
        int sid;                                /* session id */
 
216
        void *dd_data;                          /* LLD private data */
 
217
        struct device dev;      /* sysfs transport/container device */
 
218
};
 
219
 
 
220
#define iscsi_dev_to_session(_dev) \
 
221
        container_of(_dev, struct iscsi_cls_session, dev)
 
222
 
 
223
#define transport_class_to_session(_cdev) \
 
224
        iscsi_dev_to_session(_cdev->parent)
 
225
 
 
226
#define iscsi_session_to_shost(_session) \
 
227
        dev_to_shost(_session->dev.parent)
 
228
 
 
229
#define starget_to_session(_stgt) \
 
230
        iscsi_dev_to_session(_stgt->dev.parent)
 
231
 
 
232
struct iscsi_cls_host {
 
233
        atomic_t nr_scans;
 
234
        struct mutex mutex;
 
235
        struct request_queue *bsg_q;
 
236
};
 
237
 
 
238
#define iscsi_job_to_shost(_job) \
 
239
        dev_to_shost(_job->dev)
 
240
 
 
241
extern void iscsi_host_for_each_session(struct Scsi_Host *shost,
 
242
                                void (*fn)(struct iscsi_cls_session *));
 
243
 
 
244
struct iscsi_endpoint {
 
245
        void *dd_data;                  /* LLD private data */
 
246
        struct device dev;
 
247
        uint64_t id;
 
248
        struct iscsi_cls_conn *conn;
 
249
};
 
250
 
 
251
struct iscsi_iface {
 
252
        struct device dev;
 
253
        struct iscsi_transport *transport;
 
254
        uint32_t iface_type;    /* IPv4 or IPv6 */
 
255
        uint32_t iface_num;     /* iface number, 0 - n */
 
256
        void *dd_data;          /* LLD private data */
 
257
};
 
258
 
 
259
#define iscsi_dev_to_iface(_dev) \
 
260
        container_of(_dev, struct iscsi_iface, dev)
 
261
 
 
262
#define iscsi_iface_to_shost(_iface) \
 
263
        dev_to_shost(_iface->dev.parent)
 
264
 
 
265
/*
 
266
 * session and connection functions that can be used by HW iSCSI LLDs
 
267
 */
 
268
#define iscsi_cls_session_printk(prefix, _cls_session, fmt, a...) \
 
269
        dev_printk(prefix, &(_cls_session)->dev, fmt, ##a)
 
270
 
 
271
#define iscsi_cls_conn_printk(prefix, _cls_conn, fmt, a...) \
 
272
        dev_printk(prefix, &(_cls_conn)->dev, fmt, ##a)
 
273
 
 
274
extern int iscsi_session_chkready(struct iscsi_cls_session *session);
 
275
extern int iscsi_is_session_online(struct iscsi_cls_session *session);
 
276
extern struct iscsi_cls_session *iscsi_alloc_session(struct Scsi_Host *shost,
 
277
                                struct iscsi_transport *transport, int dd_size);
 
278
extern int iscsi_add_session(struct iscsi_cls_session *session,
 
279
                             unsigned int target_id);
 
280
extern int iscsi_session_event(struct iscsi_cls_session *session,
 
281
                               enum iscsi_uevent_e event);
 
282
extern struct iscsi_cls_session *iscsi_create_session(struct Scsi_Host *shost,
 
283
                                                struct iscsi_transport *t,
 
284
                                                int dd_size,
 
285
                                                unsigned int target_id);
 
286
extern void iscsi_remove_session(struct iscsi_cls_session *session);
 
287
extern void iscsi_free_session(struct iscsi_cls_session *session);
 
288
extern int iscsi_destroy_session(struct iscsi_cls_session *session);
 
289
extern struct iscsi_cls_conn *iscsi_create_conn(struct iscsi_cls_session *sess,
 
290
                                                int dd_size, uint32_t cid);
 
291
extern int iscsi_destroy_conn(struct iscsi_cls_conn *conn);
 
292
extern void iscsi_unblock_session(struct iscsi_cls_session *session);
 
293
extern void iscsi_block_session(struct iscsi_cls_session *session);
 
294
extern int iscsi_scan_finished(struct Scsi_Host *shost, unsigned long time);
 
295
extern struct iscsi_endpoint *iscsi_create_endpoint(int dd_size);
 
296
extern void iscsi_destroy_endpoint(struct iscsi_endpoint *ep);
 
297
extern struct iscsi_endpoint *iscsi_lookup_endpoint(u64 handle);
 
298
extern int iscsi_block_scsi_eh(struct scsi_cmnd *cmd);
 
299
extern struct iscsi_iface *iscsi_create_iface(struct Scsi_Host *shost,
 
300
                                              struct iscsi_transport *t,
 
301
                                              uint32_t iface_type,
 
302
                                              uint32_t iface_num, int dd_size);
 
303
extern void iscsi_destroy_iface(struct iscsi_iface *iface);
 
304
extern struct iscsi_iface *iscsi_lookup_iface(int handle);
 
305
 
 
306
#endif