← Back to branch summary

~ubuntu-branches/ubuntu/hardy/open-iscsi/hardy-updates

« back to all changes in this revision

Viewing changes to kernel/scsi_transport_iscsi.h

  • Committer: Bazaar Package Importer
  • Author(s): Martin Zobel-Helas
  • Date: 2006-12-03 16:54:21 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20061203165421-xhttz5j4l9sowg8u
Tags: 2.0.730-0.2
upload to unstable, as no new bugs arised.

Show diffs side-by-side

added added

removed removed

Lines of Context:
kernel/scsi_transport_iscsi.h
2
2
 * iSCSI transport class definitions
3
3
 *
4
4
 * Copyright (C) IBM Corporation, 2004
5
 
 * Copyright (C) Mike Christie, 2004 - 2005
 
5
 * Copyright (C) Mike Christie, 2004 - 2006
6
6
 * Copyright (C) Dmitry Yusupov, 2004 - 2005
7
7
 * Copyright (C) Alex Aizman, 2004 - 2005
8
8
 *
27
27
#include <iscsi_if.h>
28
28
 
29
29
struct scsi_transport_template;
 
30
struct iscsi_transport;
30
31
struct Scsi_Host;
31
 
struct mempool_zone;
32
32
struct iscsi_cls_conn;
 
33
struct iscsi_conn;
 
34
struct iscsi_cmd_task;
 
35
struct iscsi_mgmt_task;
 
36
struct sockaddr;
33
37
 
34
38
/**
35
39
 * struct iscsi_transport - iSCSI Transport template
42
46
 * @bind_conn:          associate this connection with existing iSCSI session
43
47
 *                      and specified transport descriptor
44
48
 * @destroy_conn:       destroy inactive iSCSI connection
45
 
 * @set_param:          set iSCSI Data-Path operational parameter
 
49
 * @set_param:          set iSCSI parameter. Return 0 on success, -ENODATA
 
50
 *                      when param is not supported, and a -Exx value on other
 
51
 *                      error.
 
52
 * @get_param           get iSCSI parameter. Must return number of bytes
 
53
 *                      copied to buffer on success, -ENODATA when param
 
54
 *                      is not supported, and a -Exx value on other error
46
55
 * @start_conn:         set connection to be operational
47
56
 * @stop_conn:          suspend/recover/terminate connection
48
57
 * @send_pdu:           send iSCSI PDU, Login, Logout, NOP-Out, Reject, Text.
 
58
 * @session_recovery_timedout: notify LLD a block during recovery timed out
 
59
 * @init_cmd_task:      Initialize a iscsi_cmd_task and any internal structs.
 
60
 *                      Called from queuecommand with session lock held.
 
61
 * @init_mgmt_task:     Initialize a iscsi_mgmt_task and any internal structs.
 
62
 *                      Called from iscsi_conn_send_generic with xmitmutex.
 
63
 * @xmit_cmd_task:      Requests LLD to transfer cmd task. Returns 0 or the
 
64
 *                      the number of bytes transferred on success, and -Exyz
 
65
 *                      value on error.
 
66
 * @xmit_mgmt_task:     Requests LLD to transfer mgmt task. Returns 0 or the
 
67
 *                      the number of bytes transferred on success, and -Exyz
 
68
 *                      value on error.
 
69
 * @cleanup_cmd_task:   requests LLD to fail cmd task. Called with xmitmutex
 
70
 *                      and session->lock after the connection has been
 
71
 *                      suspended and terminated during recovery. If called
 
72
 *                      from abort task then connection is not suspended
 
73
 *                      or terminated but sk_callback_lock is held
49
74
 *
50
75
 * Template API provided by iSCSI Transport
51
76
 */
53
78
        struct module *owner;
54
79
        char *name;
55
80
        unsigned int caps;
 
81
        /* LLD sets this to indicate what values it can export to sysfs */
 
82
        unsigned int param_mask;
56
83
        struct scsi_host_template *host_template;
57
 
        /* LLD session/scsi_host data size */
58
 
        int hostdata_size;
59
 
        /* LLD iscsi_host data size */
60
 
        int ihostdata_size;
61
84
        /* LLD connection data size */
62
85
        int conndata_size;
 
86
        /* LLD session data size */
 
87
        int sessiondata_size;
63
88
        int max_lun;
64
89
        unsigned int max_conn;
65
90
        unsigned int max_cmd_len;
66
 
        struct iscsi_cls_session *(*create_session)
67
 
                (struct scsi_transport_template *t, uint32_t sn, uint32_t *sid);
 
91
        struct iscsi_cls_session *(*create_session) (struct iscsi_transport *it,
 
92
                struct scsi_transport_template *t, uint32_t sn, uint32_t *hn);
68
93
        void (*destroy_session) (struct iscsi_cls_session *session);
69
94
        struct iscsi_cls_conn *(*create_conn) (struct iscsi_cls_session *sess,
70
95
                                uint32_t cid);
71
96
        int (*bind_conn) (struct iscsi_cls_session *session,
72
97
                          struct iscsi_cls_conn *cls_conn,
73
 
                          uint32_t transport_fd, int is_leading);
 
98
                          uint64_t transport_eph, int is_leading);
74
99
        int (*start_conn) (struct iscsi_cls_conn *conn);
75
100
        void (*stop_conn) (struct iscsi_cls_conn *conn, int flag);
76
101
        void (*destroy_conn) (struct iscsi_cls_conn *conn);
77
102
        int (*set_param) (struct iscsi_cls_conn *conn, enum iscsi_param param,
78
 
                          uint32_t value);
 
103
                          char *buf, int buflen);
79
104
        int (*get_conn_param) (struct iscsi_cls_conn *conn,
80
 
                               enum iscsi_param param,
81
 
                               uint32_t *value);
 
105
                               enum iscsi_param param, char *buf);
82
106
        int (*get_session_param) (struct iscsi_cls_session *session,
83
 
                                  enum iscsi_param param, uint32_t *value);
 
107
                                  enum iscsi_param param, char *buf);
84
108
        int (*send_pdu) (struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
85
109
                         char *data, uint32_t data_size);
86
110
        void (*get_stats) (struct iscsi_cls_conn *conn,
87
111
                           struct iscsi_stats *stats);
 
112
        void (*init_cmd_task) (struct iscsi_cmd_task *ctask);
 
113
        void (*init_mgmt_task) (struct iscsi_conn *conn,
 
114
                                struct iscsi_mgmt_task *mtask,
 
115
                                char *data, uint32_t data_size);
 
116
        int (*xmit_cmd_task) (struct iscsi_conn *conn,
 
117
                              struct iscsi_cmd_task *ctask);
 
118
        void (*cleanup_cmd_task) (struct iscsi_conn *conn,
 
119
                                  struct iscsi_cmd_task *ctask);
 
120
        int (*xmit_mgmt_task) (struct iscsi_conn *conn,
 
121
                               struct iscsi_mgmt_task *mtask);
 
122
        void (*session_recovery_timedout) (struct iscsi_cls_session *session);
 
123
        int (*ep_connect) (struct sockaddr *dst_addr, int non_blocking,
 
124
                           uint64_t *ep_handle);
 
125
        int (*ep_poll) (uint64_t ep_handle, int timeout_ms);
 
126
        void (*ep_disconnect) (uint64_t ep_handle);
 
127
        int (*tgt_dscvr) (enum iscsi_tgt_dscvr type, uint32_t host_no,
 
128
                          uint32_t enable, struct sockaddr *dst_addr);
88
129
};
89
130
 
90
131
/*
100
141
extern int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
101
142
                          char *data, uint32_t data_size);
102
143
 
 
144
 
 
145
/* Connection's states */
 
146
#define ISCSI_CONN_INITIAL_STAGE        0
 
147
#define ISCSI_CONN_STARTED              1
 
148
#define ISCSI_CONN_STOPPED              2
 
149
#define ISCSI_CONN_CLEANUP_WAIT         3
 
150
 
103
151
struct iscsi_cls_conn {
104
152
        struct list_head conn_list;     /* item in connlist */
105
153
        void *dd_data;                  /* LLD private data */
106
154
        struct iscsi_transport *transport;
 
155
        uint32_t cid;                   /* connection id */
 
156
 
107
157
        int active;                     /* must be accessed with the connlock */
108
158
        struct device dev;              /* sysfs transport/container device */
109
 
        struct mempool_zone *z_error;
110
 
        struct mempool_zone *z_pdu;
111
 
        struct list_head freequeue;
112
159
};
113
160
 
114
161
#define iscsi_dev_to_conn(_dev) \
115
162
        container_of(_dev, struct iscsi_cls_conn, dev)
116
163
 
 
164
/* Session's states */
 
165
#define ISCSI_STATE_FREE                1
 
166
#define ISCSI_STATE_LOGGED_IN           2
 
167
#define ISCSI_STATE_FAILED              3
 
168
#define ISCSI_STATE_TERMINATE           4
 
169
#define ISCSI_STATE_IN_RECOVERY         5
 
170
#define ISCSI_STATE_RECOVERY_FAILED     6
 
171
 
117
172
struct iscsi_cls_session {
118
173
        struct list_head sess_list;             /* item in session_list */
 
174
        struct list_head host_list;
119
175
        struct iscsi_transport *transport;
 
176
 
 
177
        /* recovery fields */
 
178
        int recovery_tmo;
 
179
        struct work_struct recovery_work;
 
180
 
 
181
        int target_id;
 
182
 
 
183
        int sid;                                /* session id */
 
184
        void *dd_data;                          /* LLD private data */
120
185
        struct device dev;      /* sysfs transport/container device */
121
186
};
122
187
 
126
191
#define iscsi_session_to_shost(_session) \
127
192
        dev_to_shost(_session->dev.parent)
128
193
 
 
194
#define starget_to_session(_stgt) \
 
195
        iscsi_dev_to_session(_stgt->dev.parent)
 
196
 
 
197
struct iscsi_host {
 
198
        struct list_head sessions;
 
199
        struct mutex mutex;
 
200
};
 
201
 
129
202
/*
130
203
 * session and connection functions that can be used by HW iSCSI LLDs
131
204
 */
 
205
extern struct iscsi_cls_session *iscsi_alloc_session(struct Scsi_Host *shost,
 
206
                                        struct iscsi_transport *transport);
 
207
extern int iscsi_add_session(struct iscsi_cls_session *session,
 
208
                             unsigned int target_id);
 
209
extern int iscsi_if_create_session_done(struct iscsi_cls_conn *conn);
 
210
extern int iscsi_if_destroy_session_done(struct iscsi_cls_conn *conn);
132
211
extern struct iscsi_cls_session *iscsi_create_session(struct Scsi_Host *shost,
133
 
                                struct iscsi_transport *t);
 
212
                                                struct iscsi_transport *t,
 
213
                                                unsigned int target_id);
 
214
extern void iscsi_remove_session(struct iscsi_cls_session *session);
 
215
extern void iscsi_free_session(struct iscsi_cls_session *session);
134
216
extern int iscsi_destroy_session(struct iscsi_cls_session *session);
135
217
extern struct iscsi_cls_conn *iscsi_create_conn(struct iscsi_cls_session *sess,
136
218
                                            uint32_t cid);
137
219
extern int iscsi_destroy_conn(struct iscsi_cls_conn *conn);
 
220
extern void iscsi_unblock_session(struct iscsi_cls_session *session);
 
221
extern void iscsi_block_session(struct iscsi_cls_session *session);
138
222
 
139
 
/*
140
 
 * session functions used by software iscsi
141
 
 */
142
 
extern struct Scsi_Host *
143
 
iscsi_transport_create_session(struct scsi_transport_template *scsit,
144
 
                               struct iscsi_transport *transport);
145
 
extern int iscsi_transport_destroy_session(struct Scsi_Host *shost);
146
223
 
147
224
#endif