blob: ce0d14af33c86a2e6c51abfa8a6ebc8dd50417ba [file] [log] [blame]
Alex Aizman0896b752005-08-04 19:33:07 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * iSCSI transport class definitions
3 *
4 * Copyright (C) IBM Corporation, 2004
Alex Aizman0896b752005-08-04 19:33:07 -07005 * Copyright (C) Mike Christie, 2004 - 2005
6 * Copyright (C) Dmitry Yusupov, 2004 - 2005
7 * Copyright (C) Alex Aizman, 2004 - 2005
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
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#include <linux/module.h>
Arjan van de Ven0b950672006-01-11 13:16:10 +010024#include <linux/mutex.h>
Alex Aizman0896b752005-08-04 19:33:07 -070025#include <net/tcp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <scsi/scsi.h>
27#include <scsi/scsi_host.h>
28#include <scsi/scsi_device.h>
29#include <scsi/scsi_transport.h>
30#include <scsi/scsi_transport_iscsi.h>
Alex Aizman0896b752005-08-04 19:33:07 -070031#include <scsi/iscsi_if.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Mike Christie30a6c652006-04-06 21:13:39 -050033#define ISCSI_SESSION_ATTRS 11
Mike Christie8d2860b2006-05-02 19:46:47 -050034#define ISCSI_CONN_ATTRS 11
Mike Christie30a6c652006-04-06 21:13:39 -050035#define ISCSI_HOST_ATTRS 0
Mike Christie82a0d7b2006-11-08 15:58:34 -060036#define ISCSI_TRANSPORT_VERSION "2.0-724"
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38struct iscsi_internal {
Mike Christie790f39a2006-05-18 20:31:39 -050039 int daemon_pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 struct scsi_transport_template t;
Alex Aizman0896b752005-08-04 19:33:07 -070041 struct iscsi_transport *iscsi_transport;
42 struct list_head list;
Alex Aizman0896b752005-08-04 19:33:07 -070043 struct class_device cdev;
Mike Christie30a6c652006-04-06 21:13:39 -050044
45 struct class_device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
Alex Aizman0896b752005-08-04 19:33:07 -070046 struct transport_container conn_cont;
47 struct class_device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1];
48 struct transport_container session_cont;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 struct class_device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -070050};
51
Mike Christieb5c7a122006-04-06 21:13:33 -050052static int iscsi_session_nr; /* sysfs session id for next new session */
53
Alex Aizman0896b752005-08-04 19:33:07 -070054/*
55 * list of registered transports and lock that must
56 * be held while accessing list. The iscsi_transport_lock must
Arjan van de Ven0b950672006-01-11 13:16:10 +010057 * be acquired after the rx_queue_mutex.
Alex Aizman0896b752005-08-04 19:33:07 -070058 */
59static LIST_HEAD(iscsi_transports);
60static DEFINE_SPINLOCK(iscsi_transport_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
Alex Aizman0896b752005-08-04 19:33:07 -070062#define to_iscsi_internal(tmpl) \
63 container_of(tmpl, struct iscsi_internal, t)
64
65#define cdev_to_iscsi_internal(_cdev) \
66 container_of(_cdev, struct iscsi_internal, cdev)
67
68static void iscsi_transport_release(struct class_device *cdev)
69{
70 struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
71 kfree(priv);
72}
73
74/*
75 * iscsi_transport_class represents the iscsi_transports that are
76 * registered.
77 */
78static struct class iscsi_transport_class = {
79 .name = "iscsi_transport",
80 .release = iscsi_transport_release,
81};
82
83static ssize_t
84show_transport_handle(struct class_device *cdev, char *buf)
85{
86 struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
Mike Christie762e2bf2005-09-12 21:01:46 -050087 return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
Alex Aizman0896b752005-08-04 19:33:07 -070088}
89static CLASS_DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
90
91#define show_transport_attr(name, format) \
92static ssize_t \
93show_transport_##name(struct class_device *cdev, char *buf) \
94{ \
95 struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev); \
96 return sprintf(buf, format"\n", priv->iscsi_transport->name); \
97} \
98static CLASS_DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
99
100show_transport_attr(caps, "0x%x");
101show_transport_attr(max_lun, "%d");
102show_transport_attr(max_conn, "%d");
103show_transport_attr(max_cmd_len, "%d");
104
105static struct attribute *iscsi_transport_attrs[] = {
106 &class_device_attr_handle.attr,
107 &class_device_attr_caps.attr,
108 &class_device_attr_max_lun.attr,
109 &class_device_attr_max_conn.attr,
110 &class_device_attr_max_cmd_len.attr,
111 NULL,
112};
113
114static struct attribute_group iscsi_transport_group = {
115 .attrs = iscsi_transport_attrs,
116};
117
Mike Christie30a6c652006-04-06 21:13:39 -0500118static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
119 struct class_device *cdev)
120{
121 struct Scsi_Host *shost = dev_to_shost(dev);
122 struct iscsi_host *ihost = shost->shost_data;
123
124 memset(ihost, 0, sizeof(*ihost));
125 INIT_LIST_HEAD(&ihost->sessions);
126 mutex_init(&ihost->mutex);
127 return 0;
128}
129
130static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
131 "iscsi_host",
132 iscsi_setup_host,
133 NULL,
134 NULL);
135
Alex Aizman0896b752005-08-04 19:33:07 -0700136static DECLARE_TRANSPORT_CLASS(iscsi_session_class,
137 "iscsi_session",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 NULL,
139 NULL,
140 NULL);
141
Alex Aizman0896b752005-08-04 19:33:07 -0700142static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
143 "iscsi_connection",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 NULL,
145 NULL,
146 NULL);
Alex Aizman0896b752005-08-04 19:33:07 -0700147
148static struct sock *nls;
Arjan van de Ven0b950672006-01-11 13:16:10 +0100149static DEFINE_MUTEX(rx_queue_mutex);
Alex Aizman0896b752005-08-04 19:33:07 -0700150
Mike Christie7b7232f2006-02-01 21:06:49 -0600151static LIST_HEAD(sesslist);
152static DEFINE_SPINLOCK(sesslock);
Alex Aizman0896b752005-08-04 19:33:07 -0700153static LIST_HEAD(connlist);
154static DEFINE_SPINLOCK(connlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
Mike Christieb5c7a122006-04-06 21:13:33 -0500156static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn *conn)
157{
158 struct iscsi_cls_session *sess = iscsi_dev_to_session(conn->dev.parent);
159 return sess->sid;
160}
161
162/*
163 * Returns the matching session to a given sid
164 */
165static struct iscsi_cls_session *iscsi_session_lookup(uint32_t sid)
Mike Christie7b7232f2006-02-01 21:06:49 -0600166{
167 unsigned long flags;
168 struct iscsi_cls_session *sess;
169
170 spin_lock_irqsave(&sesslock, flags);
171 list_for_each_entry(sess, &sesslist, sess_list) {
Mike Christieb5c7a122006-04-06 21:13:33 -0500172 if (sess->sid == sid) {
Mike Christie7b7232f2006-02-01 21:06:49 -0600173 spin_unlock_irqrestore(&sesslock, flags);
174 return sess;
175 }
176 }
177 spin_unlock_irqrestore(&sesslock, flags);
178 return NULL;
179}
180
Mike Christieb5c7a122006-04-06 21:13:33 -0500181/*
182 * Returns the matching connection to a given sid / cid tuple
183 */
184static struct iscsi_cls_conn *iscsi_conn_lookup(uint32_t sid, uint32_t cid)
Mike Christie7b7232f2006-02-01 21:06:49 -0600185{
186 unsigned long flags;
187 struct iscsi_cls_conn *conn;
188
189 spin_lock_irqsave(&connlock, flags);
190 list_for_each_entry(conn, &connlist, conn_list) {
Mike Christieb5c7a122006-04-06 21:13:33 -0500191 if ((conn->cid == cid) && (iscsi_conn_get_sid(conn) == sid)) {
Mike Christie7b7232f2006-02-01 21:06:49 -0600192 spin_unlock_irqrestore(&connlock, flags);
193 return conn;
194 }
195 }
196 spin_unlock_irqrestore(&connlock, flags);
197 return NULL;
198}
199
Mike Christie7b8631b2006-01-13 18:05:50 -0600200/*
201 * The following functions can be used by LLDs that allocate
202 * their own scsi_hosts or by software iscsi LLDs
203 */
204static void iscsi_session_release(struct device *dev)
205{
206 struct iscsi_cls_session *session = iscsi_dev_to_session(dev);
Mike Christie7b8631b2006-01-13 18:05:50 -0600207 struct Scsi_Host *shost;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
Mike Christie7b8631b2006-01-13 18:05:50 -0600209 shost = iscsi_session_to_shost(session);
210 scsi_host_put(shost);
211 kfree(session);
Mike Christie7b8631b2006-01-13 18:05:50 -0600212}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Mike Christie7b8631b2006-01-13 18:05:50 -0600214static int iscsi_is_session_dev(const struct device *dev)
215{
216 return dev->release == iscsi_session_release;
217}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
Mike Christie30a6c652006-04-06 21:13:39 -0500219static int iscsi_user_scan(struct Scsi_Host *shost, uint channel,
220 uint id, uint lun)
221{
222 struct iscsi_host *ihost = shost->shost_data;
223 struct iscsi_cls_session *session;
224
225 mutex_lock(&ihost->mutex);
226 list_for_each_entry(session, &ihost->sessions, host_list) {
Mike Christiee6f3b632006-06-28 12:00:29 -0500227 if ((channel == SCAN_WILD_CARD || channel == 0) &&
Mike Christie30a6c652006-04-06 21:13:39 -0500228 (id == SCAN_WILD_CARD || id == session->target_id))
Mike Christiee6f3b632006-06-28 12:00:29 -0500229 scsi_scan_target(&session->dev, 0,
Mike Christie30a6c652006-04-06 21:13:39 -0500230 session->target_id, lun, 1);
231 }
232 mutex_unlock(&ihost->mutex);
233
234 return 0;
235}
236
David Howellsc4028952006-11-22 14:57:56 +0000237static void session_recovery_timedout(struct work_struct *work)
Mike Christie30a6c652006-04-06 21:13:39 -0500238{
David Howellsc4028952006-11-22 14:57:56 +0000239 struct iscsi_cls_session *session =
240 container_of(work, struct iscsi_cls_session,
241 recovery_work.work);
Mike Christie30a6c652006-04-06 21:13:39 -0500242
Or Gerlitzbe2df722006-05-02 19:46:43 -0500243 dev_printk(KERN_INFO, &session->dev, "iscsi: session recovery timed "
244 "out after %d secs\n", session->recovery_tmo);
Mike Christie30a6c652006-04-06 21:13:39 -0500245
246 if (session->transport->session_recovery_timedout)
247 session->transport->session_recovery_timedout(session);
248
249 scsi_target_unblock(&session->dev);
250}
251
252void iscsi_unblock_session(struct iscsi_cls_session *session)
253{
254 if (!cancel_delayed_work(&session->recovery_work))
255 flush_scheduled_work();
256 scsi_target_unblock(&session->dev);
257}
258EXPORT_SYMBOL_GPL(iscsi_unblock_session);
259
260void iscsi_block_session(struct iscsi_cls_session *session)
261{
262 scsi_target_block(&session->dev);
263 schedule_delayed_work(&session->recovery_work,
264 session->recovery_tmo * HZ);
265}
266EXPORT_SYMBOL_GPL(iscsi_block_session);
267
Mike Christie7b8631b2006-01-13 18:05:50 -0600268struct iscsi_cls_session *
Mike Christie8434aa82006-06-28 12:00:30 -0500269iscsi_alloc_session(struct Scsi_Host *shost,
270 struct iscsi_transport *transport)
Mike Christie7b8631b2006-01-13 18:05:50 -0600271{
272 struct iscsi_cls_session *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
Mike Christieb5c7a122006-04-06 21:13:33 -0500274 session = kzalloc(sizeof(*session) + transport->sessiondata_size,
275 GFP_KERNEL);
Mike Christie7b8631b2006-01-13 18:05:50 -0600276 if (!session)
Mike Christief53a88d2006-06-28 12:00:27 -0500277 return NULL;
278
Mike Christie7b8631b2006-01-13 18:05:50 -0600279 session->transport = transport;
Mike Christie30a6c652006-04-06 21:13:39 -0500280 session->recovery_tmo = 120;
David Howellsc4028952006-11-22 14:57:56 +0000281 INIT_DELAYED_WORK(&session->recovery_work, session_recovery_timedout);
Mike Christie30a6c652006-04-06 21:13:39 -0500282 INIT_LIST_HEAD(&session->host_list);
283 INIT_LIST_HEAD(&session->sess_list);
Mike Christie7b8631b2006-01-13 18:05:50 -0600284
Mike Christie6a8a0d32006-06-28 12:00:31 -0500285 /* this is released in the dev's release function */
286 scsi_host_get(shost);
Mike Christie8434aa82006-06-28 12:00:30 -0500287 session->dev.parent = &shost->shost_gendev;
288 session->dev.release = iscsi_session_release;
289 device_initialize(&session->dev);
Mike Christieb5c7a122006-04-06 21:13:33 -0500290 if (transport->sessiondata_size)
291 session->dd_data = &session[1];
Mike Christie8434aa82006-06-28 12:00:30 -0500292 return session;
293}
294EXPORT_SYMBOL_GPL(iscsi_alloc_session);
295
Mike Christie6a8a0d32006-06-28 12:00:31 -0500296int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id)
Mike Christie8434aa82006-06-28 12:00:30 -0500297{
298 struct Scsi_Host *shost = iscsi_session_to_shost(session);
299 struct iscsi_host *ihost;
300 int err;
Mike Christieb5c7a122006-04-06 21:13:33 -0500301
Mike Christie30a6c652006-04-06 21:13:39 -0500302 ihost = shost->shost_data;
Mike Christieb5c7a122006-04-06 21:13:33 -0500303 session->sid = iscsi_session_nr++;
Mike Christie6a8a0d32006-06-28 12:00:31 -0500304 session->target_id = target_id;
Mike Christie30a6c652006-04-06 21:13:39 -0500305
Mike Christieb5c7a122006-04-06 21:13:33 -0500306 snprintf(session->dev.bus_id, BUS_ID_SIZE, "session%u",
307 session->sid);
Mike Christie8434aa82006-06-28 12:00:30 -0500308 err = device_add(&session->dev);
Mike Christie7b8631b2006-01-13 18:05:50 -0600309 if (err) {
310 dev_printk(KERN_ERR, &session->dev, "iscsi: could not "
311 "register session's dev\n");
Mike Christie8434aa82006-06-28 12:00:30 -0500312 goto release_host;
Mike Christie7b8631b2006-01-13 18:05:50 -0600313 }
314 transport_register_device(&session->dev);
315
Mike Christie30a6c652006-04-06 21:13:39 -0500316 mutex_lock(&ihost->mutex);
317 list_add(&session->host_list, &ihost->sessions);
318 mutex_unlock(&ihost->mutex);
Mike Christie8434aa82006-06-28 12:00:30 -0500319 return 0;
Mike Christie30a6c652006-04-06 21:13:39 -0500320
Mike Christie8434aa82006-06-28 12:00:30 -0500321release_host:
322 scsi_host_put(shost);
323 return err;
Mike Christie7b8631b2006-01-13 18:05:50 -0600324}
Mike Christie8434aa82006-06-28 12:00:30 -0500325EXPORT_SYMBOL_GPL(iscsi_add_session);
Mike Christie7b8631b2006-01-13 18:05:50 -0600326
327/**
Mike Christie8434aa82006-06-28 12:00:30 -0500328 * iscsi_create_session - create iscsi class session
329 * @shost: scsi host
330 * @transport: iscsi transport
Mike Christie7b8631b2006-01-13 18:05:50 -0600331 *
Mike Christie8434aa82006-06-28 12:00:30 -0500332 * This can be called from a LLD or iscsi_transport.
Mike Christie7b8631b2006-01-13 18:05:50 -0600333 **/
Mike Christie8434aa82006-06-28 12:00:30 -0500334struct iscsi_cls_session *
335iscsi_create_session(struct Scsi_Host *shost,
Mike Christie6a8a0d32006-06-28 12:00:31 -0500336 struct iscsi_transport *transport,
337 unsigned int target_id)
Mike Christie8434aa82006-06-28 12:00:30 -0500338{
339 struct iscsi_cls_session *session;
340
341 session = iscsi_alloc_session(shost, transport);
342 if (!session)
343 return NULL;
344
Mike Christie6a8a0d32006-06-28 12:00:31 -0500345 if (iscsi_add_session(session, target_id)) {
Mike Christie8434aa82006-06-28 12:00:30 -0500346 iscsi_free_session(session);
347 return NULL;
348 }
349 return session;
350}
351EXPORT_SYMBOL_GPL(iscsi_create_session);
352
353void iscsi_remove_session(struct iscsi_cls_session *session)
Mike Christie7b8631b2006-01-13 18:05:50 -0600354{
Mike Christie30a6c652006-04-06 21:13:39 -0500355 struct Scsi_Host *shost = iscsi_session_to_shost(session);
356 struct iscsi_host *ihost = shost->shost_data;
357
358 if (!cancel_delayed_work(&session->recovery_work))
359 flush_scheduled_work();
360
361 mutex_lock(&ihost->mutex);
362 list_del(&session->host_list);
363 mutex_unlock(&ihost->mutex);
364
Mike Christie8434aa82006-06-28 12:00:30 -0500365 scsi_remove_target(&session->dev);
366
Mike Christie7b8631b2006-01-13 18:05:50 -0600367 transport_unregister_device(&session->dev);
Mike Christie8434aa82006-06-28 12:00:30 -0500368 device_del(&session->dev);
369}
370EXPORT_SYMBOL_GPL(iscsi_remove_session);
371
372void iscsi_free_session(struct iscsi_cls_session *session)
373{
374 put_device(&session->dev);
Mike Christie7b8631b2006-01-13 18:05:50 -0600375}
376
Mike Christie8434aa82006-06-28 12:00:30 -0500377EXPORT_SYMBOL_GPL(iscsi_free_session);
378
379/**
380 * iscsi_destroy_session - destroy iscsi session
381 * @session: iscsi_session
382 *
383 * Can be called by a LLD or iscsi_transport. There must not be
384 * any running connections.
385 **/
386int iscsi_destroy_session(struct iscsi_cls_session *session)
387{
388 iscsi_remove_session(session);
389 iscsi_free_session(session);
390 return 0;
391}
Mike Christie7b8631b2006-01-13 18:05:50 -0600392EXPORT_SYMBOL_GPL(iscsi_destroy_session);
393
394static void iscsi_conn_release(struct device *dev)
395{
396 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev);
397 struct device *parent = conn->dev.parent;
398
399 kfree(conn);
400 put_device(parent);
401}
402
403static int iscsi_is_conn_dev(const struct device *dev)
404{
405 return dev->release == iscsi_conn_release;
406}
407
408/**
409 * iscsi_create_conn - create iscsi class connection
410 * @session: iscsi cls session
411 * @cid: connection id
412 *
413 * This can be called from a LLD or iscsi_transport. The connection
414 * is child of the session so cid must be unique for all connections
415 * on the session.
Mike Christieb5c7a122006-04-06 21:13:33 -0500416 *
417 * Since we do not support MCS, cid will normally be zero. In some cases
418 * for software iscsi we could be trying to preallocate a connection struct
419 * in which case there could be two connection structs and cid would be
420 * non-zero.
Mike Christie7b8631b2006-01-13 18:05:50 -0600421 **/
422struct iscsi_cls_conn *
423iscsi_create_conn(struct iscsi_cls_session *session, uint32_t cid)
424{
425 struct iscsi_transport *transport = session->transport;
Mike Christie7b8631b2006-01-13 18:05:50 -0600426 struct iscsi_cls_conn *conn;
427 int err;
428
429 conn = kzalloc(sizeof(*conn) + transport->conndata_size, GFP_KERNEL);
430 if (!conn)
431 return NULL;
432
433 if (transport->conndata_size)
434 conn->dd_data = &conn[1];
435
436 INIT_LIST_HEAD(&conn->conn_list);
437 conn->transport = transport;
Mike Christieb5c7a122006-04-06 21:13:33 -0500438 conn->cid = cid;
Mike Christie7b8631b2006-01-13 18:05:50 -0600439
440 /* this is released in the dev's release function */
441 if (!get_device(&session->dev))
Mike Christie43a145a2006-10-16 18:09:38 -0400442 goto free_conn;
Mike Christieb5c7a122006-04-06 21:13:33 -0500443
Mike Christie7b8631b2006-01-13 18:05:50 -0600444 snprintf(conn->dev.bus_id, BUS_ID_SIZE, "connection%d:%u",
Mike Christieb5c7a122006-04-06 21:13:33 -0500445 session->sid, cid);
Mike Christie7b8631b2006-01-13 18:05:50 -0600446 conn->dev.parent = &session->dev;
447 conn->dev.release = iscsi_conn_release;
448 err = device_register(&conn->dev);
449 if (err) {
450 dev_printk(KERN_ERR, &conn->dev, "iscsi: could not register "
451 "connection's dev\n");
452 goto release_parent_ref;
453 }
454 transport_register_device(&conn->dev);
455 return conn;
456
457release_parent_ref:
458 put_device(&session->dev);
459free_conn:
460 kfree(conn);
461 return NULL;
462}
463
464EXPORT_SYMBOL_GPL(iscsi_create_conn);
465
466/**
467 * iscsi_destroy_conn - destroy iscsi class connection
468 * @session: iscsi cls session
469 *
470 * This can be called from a LLD or iscsi_transport.
471 **/
472int iscsi_destroy_conn(struct iscsi_cls_conn *conn)
473{
474 transport_unregister_device(&conn->dev);
475 device_unregister(&conn->dev);
476 return 0;
477}
478
479EXPORT_SYMBOL_GPL(iscsi_destroy_conn);
480
481/*
Mike Christie7b8631b2006-01-13 18:05:50 -0600482 * iscsi interface functions
483 */
Alex Aizman0896b752005-08-04 19:33:07 -0700484static struct iscsi_internal *
485iscsi_if_transport_lookup(struct iscsi_transport *tt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486{
Alex Aizman0896b752005-08-04 19:33:07 -0700487 struct iscsi_internal *priv;
488 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
Alex Aizman0896b752005-08-04 19:33:07 -0700490 spin_lock_irqsave(&iscsi_transport_lock, flags);
491 list_for_each_entry(priv, &iscsi_transports, list) {
492 if (tt == priv->iscsi_transport) {
493 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
494 return priv;
495 }
496 }
497 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
498 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Alex Aizman0896b752005-08-04 19:33:07 -0700501static int
Mike Christie43a145a2006-10-16 18:09:38 -0400502iscsi_broadcast_skb(struct sk_buff *skb, gfp_t gfp)
Mike Christie53cb8a12006-06-28 12:00:32 -0500503{
Mike Christie53cb8a12006-06-28 12:00:32 -0500504 int rc;
505
Mike Christie9aaa2b42006-07-24 15:47:34 -0500506 rc = netlink_broadcast(nls, skb, 0, 1, gfp);
Mike Christie53cb8a12006-06-28 12:00:32 -0500507 if (rc < 0) {
Mike Christie53cb8a12006-06-28 12:00:32 -0500508 printk(KERN_ERR "iscsi: can not broadcast skb (%d)\n", rc);
509 return rc;
510 }
511
Mike Christie53cb8a12006-06-28 12:00:32 -0500512 return 0;
513}
514
515static int
Mike Christie43a145a2006-10-16 18:09:38 -0400516iscsi_unicast_skb(struct sk_buff *skb, int pid)
Alex Aizman0896b752005-08-04 19:33:07 -0700517{
Alex Aizman0896b752005-08-04 19:33:07 -0700518 int rc;
519
Mike Christie790f39a2006-05-18 20:31:39 -0500520 rc = netlink_unicast(nls, skb, pid, MSG_DONTWAIT);
Alex Aizman0896b752005-08-04 19:33:07 -0700521 if (rc < 0) {
Alex Aizman0896b752005-08-04 19:33:07 -0700522 printk(KERN_ERR "iscsi: can not unicast skb (%d)\n", rc);
523 return rc;
524 }
525
Alex Aizman0896b752005-08-04 19:33:07 -0700526 return 0;
527}
528
Mike Christie7b7232f2006-02-01 21:06:49 -0600529int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
Alex Aizman0896b752005-08-04 19:33:07 -0700530 char *data, uint32_t data_size)
531{
532 struct nlmsghdr *nlh;
533 struct sk_buff *skb;
534 struct iscsi_uevent *ev;
Alex Aizman0896b752005-08-04 19:33:07 -0700535 char *pdu;
Mike Christie790f39a2006-05-18 20:31:39 -0500536 struct iscsi_internal *priv;
Alex Aizman0896b752005-08-04 19:33:07 -0700537 int len = NLMSG_SPACE(sizeof(*ev) + sizeof(struct iscsi_hdr) +
538 data_size);
539
Mike Christie790f39a2006-05-18 20:31:39 -0500540 priv = iscsi_if_transport_lookup(conn->transport);
541 if (!priv)
542 return -EINVAL;
543
Mike Christie43a145a2006-10-16 18:09:38 -0400544 skb = alloc_skb(len, GFP_ATOMIC);
Alex Aizman0896b752005-08-04 19:33:07 -0700545 if (!skb) {
Mike Christie7b7232f2006-02-01 21:06:49 -0600546 iscsi_conn_error(conn, ISCSI_ERR_CONN_FAILED);
Mike Christie7b8631b2006-01-13 18:05:50 -0600547 dev_printk(KERN_ERR, &conn->dev, "iscsi: can not deliver "
548 "control PDU: OOM\n");
Alex Aizman0896b752005-08-04 19:33:07 -0700549 return -ENOMEM;
550 }
551
Mike Christie790f39a2006-05-18 20:31:39 -0500552 nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
Alex Aizman0896b752005-08-04 19:33:07 -0700553 ev = NLMSG_DATA(nlh);
554 memset(ev, 0, sizeof(*ev));
555 ev->transport_handle = iscsi_handle(conn->transport);
556 ev->type = ISCSI_KEVENT_RECV_PDU;
Mike Christieb5c7a122006-04-06 21:13:33 -0500557 ev->r.recv_req.cid = conn->cid;
558 ev->r.recv_req.sid = iscsi_conn_get_sid(conn);
Alex Aizman0896b752005-08-04 19:33:07 -0700559 pdu = (char*)ev + sizeof(*ev);
560 memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
561 memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
562
Mike Christie43a145a2006-10-16 18:09:38 -0400563 return iscsi_unicast_skb(skb, priv->daemon_pid);
Alex Aizman0896b752005-08-04 19:33:07 -0700564}
565EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
566
Mike Christie7b7232f2006-02-01 21:06:49 -0600567void iscsi_conn_error(struct iscsi_cls_conn *conn, enum iscsi_err error)
Alex Aizman0896b752005-08-04 19:33:07 -0700568{
569 struct nlmsghdr *nlh;
570 struct sk_buff *skb;
571 struct iscsi_uevent *ev;
Mike Christie790f39a2006-05-18 20:31:39 -0500572 struct iscsi_internal *priv;
Alex Aizman0896b752005-08-04 19:33:07 -0700573 int len = NLMSG_SPACE(sizeof(*ev));
574
Mike Christie790f39a2006-05-18 20:31:39 -0500575 priv = iscsi_if_transport_lookup(conn->transport);
576 if (!priv)
577 return;
578
Mike Christie43a145a2006-10-16 18:09:38 -0400579 skb = alloc_skb(len, GFP_ATOMIC);
Alex Aizman0896b752005-08-04 19:33:07 -0700580 if (!skb) {
Mike Christie7b8631b2006-01-13 18:05:50 -0600581 dev_printk(KERN_ERR, &conn->dev, "iscsi: gracefully ignored "
582 "conn error (%d)\n", error);
Alex Aizman0896b752005-08-04 19:33:07 -0700583 return;
584 }
585
Mike Christie790f39a2006-05-18 20:31:39 -0500586 nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
Alex Aizman0896b752005-08-04 19:33:07 -0700587 ev = NLMSG_DATA(nlh);
588 ev->transport_handle = iscsi_handle(conn->transport);
589 ev->type = ISCSI_KEVENT_CONN_ERROR;
Alex Aizman0896b752005-08-04 19:33:07 -0700590 ev->r.connerror.error = error;
Mike Christieb5c7a122006-04-06 21:13:33 -0500591 ev->r.connerror.cid = conn->cid;
592 ev->r.connerror.sid = iscsi_conn_get_sid(conn);
Alex Aizman0896b752005-08-04 19:33:07 -0700593
Mike Christie43a145a2006-10-16 18:09:38 -0400594 iscsi_broadcast_skb(skb, GFP_ATOMIC);
Alex Aizman0896b752005-08-04 19:33:07 -0700595
Mike Christie7b8631b2006-01-13 18:05:50 -0600596 dev_printk(KERN_INFO, &conn->dev, "iscsi: detected conn error (%d)\n",
597 error);
Alex Aizman0896b752005-08-04 19:33:07 -0700598}
599EXPORT_SYMBOL_GPL(iscsi_conn_error);
600
601static int
602iscsi_if_send_reply(int pid, int seq, int type, int done, int multi,
603 void *payload, int size)
604{
605 struct sk_buff *skb;
606 struct nlmsghdr *nlh;
607 int len = NLMSG_SPACE(size);
608 int flags = multi ? NLM_F_MULTI : 0;
609 int t = done ? NLMSG_DONE : type;
610
Mike Christie43a145a2006-10-16 18:09:38 -0400611 skb = alloc_skb(len, GFP_ATOMIC);
Alex Aizman0896b752005-08-04 19:33:07 -0700612 /*
613 * FIXME:
614 * user is supposed to react on iferror == -ENOMEM;
615 * see iscsi_if_rx().
616 */
617 BUG_ON(!skb);
618
619 nlh = __nlmsg_put(skb, pid, seq, t, (len - sizeof(*nlh)), 0);
620 nlh->nlmsg_flags = flags;
621 memcpy(NLMSG_DATA(nlh), payload, size);
Mike Christie43a145a2006-10-16 18:09:38 -0400622 return iscsi_unicast_skb(skb, pid);
Alex Aizman0896b752005-08-04 19:33:07 -0700623}
624
625static int
Mike Christie5b940ad2006-02-01 21:06:56 -0600626iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
Alex Aizman0896b752005-08-04 19:33:07 -0700627{
628 struct iscsi_uevent *ev = NLMSG_DATA(nlh);
629 struct iscsi_stats *stats;
630 struct sk_buff *skbstat;
Mike Christie7b8631b2006-01-13 18:05:50 -0600631 struct iscsi_cls_conn *conn;
Alex Aizman0896b752005-08-04 19:33:07 -0700632 struct nlmsghdr *nlhstat;
633 struct iscsi_uevent *evstat;
Mike Christie790f39a2006-05-18 20:31:39 -0500634 struct iscsi_internal *priv;
Alex Aizman0896b752005-08-04 19:33:07 -0700635 int len = NLMSG_SPACE(sizeof(*ev) +
636 sizeof(struct iscsi_stats) +
637 sizeof(struct iscsi_stats_custom) *
638 ISCSI_STATS_CUSTOM_MAX);
639 int err = 0;
640
Mike Christie790f39a2006-05-18 20:31:39 -0500641 priv = iscsi_if_transport_lookup(transport);
642 if (!priv)
643 return -EINVAL;
644
Mike Christieb5c7a122006-04-06 21:13:33 -0500645 conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid);
Alex Aizman0896b752005-08-04 19:33:07 -0700646 if (!conn)
647 return -EEXIST;
648
649 do {
650 int actual_size;
651
Mike Christie43a145a2006-10-16 18:09:38 -0400652 skbstat = alloc_skb(len, GFP_ATOMIC);
Alex Aizman0896b752005-08-04 19:33:07 -0700653 if (!skbstat) {
Mike Christie7b8631b2006-01-13 18:05:50 -0600654 dev_printk(KERN_ERR, &conn->dev, "iscsi: can not "
655 "deliver stats: OOM\n");
Alex Aizman0896b752005-08-04 19:33:07 -0700656 return -ENOMEM;
657 }
658
Mike Christie790f39a2006-05-18 20:31:39 -0500659 nlhstat = __nlmsg_put(skbstat, priv->daemon_pid, 0, 0,
Alex Aizman0896b752005-08-04 19:33:07 -0700660 (len - sizeof(*nlhstat)), 0);
661 evstat = NLMSG_DATA(nlhstat);
662 memset(evstat, 0, sizeof(*evstat));
663 evstat->transport_handle = iscsi_handle(conn->transport);
664 evstat->type = nlh->nlmsg_type;
Mike Christieb5c7a122006-04-06 21:13:33 -0500665 evstat->u.get_stats.cid =
666 ev->u.get_stats.cid;
667 evstat->u.get_stats.sid =
668 ev->u.get_stats.sid;
Alex Aizman0896b752005-08-04 19:33:07 -0700669 stats = (struct iscsi_stats *)
670 ((char*)evstat + sizeof(*evstat));
671 memset(stats, 0, sizeof(*stats));
672
Mike Christie7b7232f2006-02-01 21:06:49 -0600673 transport->get_stats(conn, stats);
Alex Aizman0896b752005-08-04 19:33:07 -0700674 actual_size = NLMSG_SPACE(sizeof(struct iscsi_uevent) +
675 sizeof(struct iscsi_stats) +
676 sizeof(struct iscsi_stats_custom) *
677 stats->custom_length);
678 actual_size -= sizeof(*nlhstat);
679 actual_size = NLMSG_LENGTH(actual_size);
Mike Christie5b940ad2006-02-01 21:06:56 -0600680 skb_trim(skbstat, NLMSG_ALIGN(actual_size));
Alex Aizman0896b752005-08-04 19:33:07 -0700681 nlhstat->nlmsg_len = actual_size;
682
Mike Christie43a145a2006-10-16 18:09:38 -0400683 err = iscsi_unicast_skb(skbstat, priv->daemon_pid);
Alex Aizman0896b752005-08-04 19:33:07 -0700684 } while (err < 0 && err != -ECONNREFUSED);
685
686 return err;
687}
688
Mike Christie53cb8a12006-06-28 12:00:32 -0500689/**
690 * iscsi_if_destroy_session_done - send session destr. completion event
691 * @conn: last connection for session
692 *
693 * This is called by HW iscsi LLDs to notify userpsace that its HW has
694 * removed a session.
695 **/
696int iscsi_if_destroy_session_done(struct iscsi_cls_conn *conn)
697{
698 struct iscsi_internal *priv;
699 struct iscsi_cls_session *session;
700 struct Scsi_Host *shost;
701 struct iscsi_uevent *ev;
702 struct sk_buff *skb;
703 struct nlmsghdr *nlh;
704 unsigned long flags;
705 int rc, len = NLMSG_SPACE(sizeof(*ev));
706
707 priv = iscsi_if_transport_lookup(conn->transport);
708 if (!priv)
709 return -EINVAL;
710
711 session = iscsi_dev_to_session(conn->dev.parent);
712 shost = iscsi_session_to_shost(session);
713
Mike Christie43a145a2006-10-16 18:09:38 -0400714 skb = alloc_skb(len, GFP_KERNEL);
Mike Christie53cb8a12006-06-28 12:00:32 -0500715 if (!skb) {
716 dev_printk(KERN_ERR, &conn->dev, "Cannot notify userspace of "
717 "session creation event\n");
718 return -ENOMEM;
719 }
720
721 nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
722 ev = NLMSG_DATA(nlh);
723 ev->transport_handle = iscsi_handle(conn->transport);
724 ev->type = ISCSI_KEVENT_DESTROY_SESSION;
725 ev->r.d_session.host_no = shost->host_no;
726 ev->r.d_session.sid = session->sid;
727
728 /*
729 * this will occur if the daemon is not up, so we just warn
730 * the user and when the daemon is restarted it will handle it
731 */
Mike Christie43a145a2006-10-16 18:09:38 -0400732 rc = iscsi_broadcast_skb(skb, GFP_KERNEL);
Mike Christie53cb8a12006-06-28 12:00:32 -0500733 if (rc < 0)
734 dev_printk(KERN_ERR, &conn->dev, "Cannot notify userspace of "
735 "session destruction event. Check iscsi daemon\n");
736
737 spin_lock_irqsave(&sesslock, flags);
738 list_del(&session->sess_list);
739 spin_unlock_irqrestore(&sesslock, flags);
740
741 spin_lock_irqsave(&connlock, flags);
742 conn->active = 0;
743 list_del(&conn->conn_list);
744 spin_unlock_irqrestore(&connlock, flags);
745
746 return rc;
747}
748EXPORT_SYMBOL_GPL(iscsi_if_destroy_session_done);
749
750/**
751 * iscsi_if_create_session_done - send session creation completion event
752 * @conn: leading connection for session
753 *
754 * This is called by HW iscsi LLDs to notify userpsace that its HW has
755 * created a session or a existing session is back in the logged in state.
756 **/
757int iscsi_if_create_session_done(struct iscsi_cls_conn *conn)
758{
759 struct iscsi_internal *priv;
760 struct iscsi_cls_session *session;
761 struct Scsi_Host *shost;
762 struct iscsi_uevent *ev;
763 struct sk_buff *skb;
764 struct nlmsghdr *nlh;
765 unsigned long flags;
766 int rc, len = NLMSG_SPACE(sizeof(*ev));
767
768 priv = iscsi_if_transport_lookup(conn->transport);
769 if (!priv)
770 return -EINVAL;
771
772 session = iscsi_dev_to_session(conn->dev.parent);
773 shost = iscsi_session_to_shost(session);
774
Mike Christie43a145a2006-10-16 18:09:38 -0400775 skb = alloc_skb(len, GFP_KERNEL);
Mike Christie53cb8a12006-06-28 12:00:32 -0500776 if (!skb) {
777 dev_printk(KERN_ERR, &conn->dev, "Cannot notify userspace of "
778 "session creation event\n");
779 return -ENOMEM;
780 }
781
782 nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
783 ev = NLMSG_DATA(nlh);
784 ev->transport_handle = iscsi_handle(conn->transport);
785 ev->type = ISCSI_UEVENT_CREATE_SESSION;
786 ev->r.c_session_ret.host_no = shost->host_no;
787 ev->r.c_session_ret.sid = session->sid;
788
789 /*
790 * this will occur if the daemon is not up, so we just warn
791 * the user and when the daemon is restarted it will handle it
792 */
Mike Christie43a145a2006-10-16 18:09:38 -0400793 rc = iscsi_broadcast_skb(skb, GFP_KERNEL);
Mike Christie53cb8a12006-06-28 12:00:32 -0500794 if (rc < 0)
795 dev_printk(KERN_ERR, &conn->dev, "Cannot notify userspace of "
796 "session creation event. Check iscsi daemon\n");
797
798 spin_lock_irqsave(&sesslock, flags);
799 list_add(&session->sess_list, &sesslist);
800 spin_unlock_irqrestore(&sesslock, flags);
801
802 spin_lock_irqsave(&connlock, flags);
803 list_add(&conn->conn_list, &connlist);
804 conn->active = 1;
805 spin_unlock_irqrestore(&connlock, flags);
806 return rc;
807}
808EXPORT_SYMBOL_GPL(iscsi_if_create_session_done);
809
Alex Aizman0896b752005-08-04 19:33:07 -0700810static int
Mike Christie7b8631b2006-01-13 18:05:50 -0600811iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_uevent *ev)
812{
813 struct iscsi_transport *transport = priv->iscsi_transport;
Mike Christie7b7232f2006-02-01 21:06:49 -0600814 struct iscsi_cls_session *session;
Mike Christie7996a772006-04-06 21:13:41 -0500815 unsigned long flags;
Mike Christieb5c7a122006-04-06 21:13:33 -0500816 uint32_t hostno;
Mike Christie7b8631b2006-01-13 18:05:50 -0600817
Mike Christie7996a772006-04-06 21:13:41 -0500818 session = transport->create_session(transport, &priv->t,
Mike Christie7b7232f2006-02-01 21:06:49 -0600819 ev->u.c_session.initial_cmdsn,
Mike Christieb5c7a122006-04-06 21:13:33 -0500820 &hostno);
Mike Christie7b7232f2006-02-01 21:06:49 -0600821 if (!session)
Mike Christie7b8631b2006-01-13 18:05:50 -0600822 return -ENOMEM;
823
Mike Christie7996a772006-04-06 21:13:41 -0500824 spin_lock_irqsave(&sesslock, flags);
825 list_add(&session->sess_list, &sesslist);
826 spin_unlock_irqrestore(&sesslock, flags);
827
Mike Christieb5c7a122006-04-06 21:13:33 -0500828 ev->r.c_session_ret.host_no = hostno;
829 ev->r.c_session_ret.sid = session->sid;
Mike Christie7b8631b2006-01-13 18:05:50 -0600830 return 0;
831}
832
833static int
Mike Christie7b7232f2006-02-01 21:06:49 -0600834iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
Mike Christie7b8631b2006-01-13 18:05:50 -0600835{
Mike Christie7b8631b2006-01-13 18:05:50 -0600836 struct iscsi_cls_conn *conn;
Mike Christie7b7232f2006-02-01 21:06:49 -0600837 struct iscsi_cls_session *session;
Mike Christie7b8631b2006-01-13 18:05:50 -0600838 unsigned long flags;
839
Mike Christieb5c7a122006-04-06 21:13:33 -0500840 session = iscsi_session_lookup(ev->u.c_conn.sid);
841 if (!session) {
842 printk(KERN_ERR "iscsi: invalid session %d\n",
843 ev->u.c_conn.sid);
Mike Christie7b8631b2006-01-13 18:05:50 -0600844 return -EINVAL;
Mike Christieb5c7a122006-04-06 21:13:33 -0500845 }
Mike Christie7b8631b2006-01-13 18:05:50 -0600846
Mike Christie7b7232f2006-02-01 21:06:49 -0600847 conn = transport->create_conn(session, ev->u.c_conn.cid);
Mike Christieb5c7a122006-04-06 21:13:33 -0500848 if (!conn) {
849 printk(KERN_ERR "iscsi: couldn't create a new "
850 "connection for session %d\n",
851 session->sid);
Mike Christie7b7232f2006-02-01 21:06:49 -0600852 return -ENOMEM;
Mike Christieb5c7a122006-04-06 21:13:33 -0500853 }
Mike Christie7b8631b2006-01-13 18:05:50 -0600854
Mike Christieb5c7a122006-04-06 21:13:33 -0500855 ev->r.c_conn_ret.sid = session->sid;
856 ev->r.c_conn_ret.cid = conn->cid;
Mike Christie7b8631b2006-01-13 18:05:50 -0600857
858 spin_lock_irqsave(&connlock, flags);
859 list_add(&conn->conn_list, &connlist);
860 conn->active = 1;
861 spin_unlock_irqrestore(&connlock, flags);
862
Mike Christie7b8631b2006-01-13 18:05:50 -0600863 return 0;
Mike Christie7b8631b2006-01-13 18:05:50 -0600864}
865
866static int
867iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
868{
869 unsigned long flags;
870 struct iscsi_cls_conn *conn;
Mike Christie7b8631b2006-01-13 18:05:50 -0600871
Mike Christieb5c7a122006-04-06 21:13:33 -0500872 conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid);
Mike Christie7b8631b2006-01-13 18:05:50 -0600873 if (!conn)
Mike Christie7b8631b2006-01-13 18:05:50 -0600874 return -EINVAL;
Mike Christie7b8631b2006-01-13 18:05:50 -0600875 spin_lock_irqsave(&connlock, flags);
876 conn->active = 0;
877 list_del(&conn->conn_list);
878 spin_unlock_irqrestore(&connlock, flags);
879
Mike Christie7b8631b2006-01-13 18:05:50 -0600880 if (transport->destroy_conn)
881 transport->destroy_conn(conn);
Mike Christie7b8631b2006-01-13 18:05:50 -0600882 return 0;
883}
884
Mike Christiefd7255f2006-04-06 21:13:36 -0500885static int
886iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev)
887{
888 char *data = (char*)ev + sizeof(*ev);
889 struct iscsi_cls_conn *conn;
890 struct iscsi_cls_session *session;
Mike Christiea54a52c2006-06-28 12:00:23 -0500891 int err = 0, value = 0;
Mike Christiefd7255f2006-04-06 21:13:36 -0500892
893 session = iscsi_session_lookup(ev->u.set_param.sid);
894 conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid);
895 if (!conn || !session)
896 return -EINVAL;
897
898 switch (ev->u.set_param.param) {
Mike Christie30a6c652006-04-06 21:13:39 -0500899 case ISCSI_PARAM_SESS_RECOVERY_TMO:
Mike Christiea54a52c2006-06-28 12:00:23 -0500900 sscanf(data, "%d", &value);
Mike Christie30a6c652006-04-06 21:13:39 -0500901 if (value != 0)
902 session->recovery_tmo = value;
903 break;
Mike Christiefd7255f2006-04-06 21:13:36 -0500904 default:
Mike Christiea54a52c2006-06-28 12:00:23 -0500905 err = transport->set_param(conn, ev->u.set_param.param,
906 data, ev->u.set_param.len);
Mike Christiefd7255f2006-04-06 21:13:36 -0500907 }
908
909 return err;
910}
911
Mike Christie7b8631b2006-01-13 18:05:50 -0600912static int
Or Gerlitz264faaa2006-05-02 19:46:36 -0500913iscsi_if_transport_ep(struct iscsi_transport *transport,
914 struct iscsi_uevent *ev, int msg_type)
915{
916 struct sockaddr *dst_addr;
917 int rc = 0;
918
919 switch (msg_type) {
920 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
921 if (!transport->ep_connect)
922 return -EINVAL;
923
924 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
925 rc = transport->ep_connect(dst_addr,
926 ev->u.ep_connect.non_blocking,
927 &ev->r.ep_connect_ret.handle);
928 break;
929 case ISCSI_UEVENT_TRANSPORT_EP_POLL:
930 if (!transport->ep_poll)
931 return -EINVAL;
932
933 ev->r.retcode = transport->ep_poll(ev->u.ep_poll.ep_handle,
934 ev->u.ep_poll.timeout_ms);
935 break;
936 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
937 if (!transport->ep_disconnect)
938 return -EINVAL;
939
940 transport->ep_disconnect(ev->u.ep_disconnect.ep_handle);
941 break;
942 }
943 return rc;
944}
945
946static int
Mike Christie01cb2252006-06-28 12:00:22 -0500947iscsi_tgt_dscvr(struct iscsi_transport *transport,
948 struct iscsi_uevent *ev)
949{
950 struct sockaddr *dst_addr;
951
952 if (!transport->tgt_dscvr)
953 return -EINVAL;
954
955 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
956 return transport->tgt_dscvr(ev->u.tgt_dscvr.type,
957 ev->u.tgt_dscvr.host_no,
958 ev->u.tgt_dscvr.enable, dst_addr);
959}
960
961static int
Alex Aizman0896b752005-08-04 19:33:07 -0700962iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
963{
964 int err = 0;
965 struct iscsi_uevent *ev = NLMSG_DATA(nlh);
966 struct iscsi_transport *transport = NULL;
967 struct iscsi_internal *priv;
Mike Christie7b7232f2006-02-01 21:06:49 -0600968 struct iscsi_cls_session *session;
969 struct iscsi_cls_conn *conn;
Mike Christie7996a772006-04-06 21:13:41 -0500970 unsigned long flags;
Alex Aizman0896b752005-08-04 19:33:07 -0700971
Alex Aizman0896b752005-08-04 19:33:07 -0700972 priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle));
973 if (!priv)
974 return -EINVAL;
975 transport = priv->iscsi_transport;
976
Mike Christie7b7232f2006-02-01 21:06:49 -0600977 if (!try_module_get(transport->owner))
978 return -EINVAL;
979
Mike Christie790f39a2006-05-18 20:31:39 -0500980 priv->daemon_pid = NETLINK_CREDS(skb)->pid;
981
Alex Aizman0896b752005-08-04 19:33:07 -0700982 switch (nlh->nlmsg_type) {
983 case ISCSI_UEVENT_CREATE_SESSION:
984 err = iscsi_if_create_session(priv, ev);
985 break;
986 case ISCSI_UEVENT_DESTROY_SESSION:
Mike Christieb5c7a122006-04-06 21:13:33 -0500987 session = iscsi_session_lookup(ev->u.d_session.sid);
Mike Christie7996a772006-04-06 21:13:41 -0500988 if (session) {
989 spin_lock_irqsave(&sesslock, flags);
990 list_del(&session->sess_list);
991 spin_unlock_irqrestore(&sesslock, flags);
992
Mike Christie7b7232f2006-02-01 21:06:49 -0600993 transport->destroy_session(session);
Mike Christie7996a772006-04-06 21:13:41 -0500994 } else
Mike Christie7b7232f2006-02-01 21:06:49 -0600995 err = -EINVAL;
Alex Aizman0896b752005-08-04 19:33:07 -0700996 break;
997 case ISCSI_UEVENT_CREATE_CONN:
998 err = iscsi_if_create_conn(transport, ev);
999 break;
1000 case ISCSI_UEVENT_DESTROY_CONN:
1001 err = iscsi_if_destroy_conn(transport, ev);
1002 break;
1003 case ISCSI_UEVENT_BIND_CONN:
Mike Christieb5c7a122006-04-06 21:13:33 -05001004 session = iscsi_session_lookup(ev->u.b_conn.sid);
1005 conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid);
Mike Christie7b7232f2006-02-01 21:06:49 -06001006
1007 if (session && conn)
1008 ev->r.retcode = transport->bind_conn(session, conn,
Or Gerlitz264faaa2006-05-02 19:46:36 -05001009 ev->u.b_conn.transport_eph,
Mike Christie7b7232f2006-02-01 21:06:49 -06001010 ev->u.b_conn.is_leading);
1011 else
1012 err = -EINVAL;
Alex Aizman0896b752005-08-04 19:33:07 -07001013 break;
1014 case ISCSI_UEVENT_SET_PARAM:
Mike Christiefd7255f2006-04-06 21:13:36 -05001015 err = iscsi_set_param(transport, ev);
Alex Aizman0896b752005-08-04 19:33:07 -07001016 break;
1017 case ISCSI_UEVENT_START_CONN:
Mike Christieb5c7a122006-04-06 21:13:33 -05001018 conn = iscsi_conn_lookup(ev->u.start_conn.sid, ev->u.start_conn.cid);
Mike Christie7b7232f2006-02-01 21:06:49 -06001019 if (conn)
1020 ev->r.retcode = transport->start_conn(conn);
1021 else
1022 err = -EINVAL;
Alex Aizman0896b752005-08-04 19:33:07 -07001023 break;
1024 case ISCSI_UEVENT_STOP_CONN:
Mike Christieb5c7a122006-04-06 21:13:33 -05001025 conn = iscsi_conn_lookup(ev->u.stop_conn.sid, ev->u.stop_conn.cid);
Mike Christie7b7232f2006-02-01 21:06:49 -06001026 if (conn)
1027 transport->stop_conn(conn, ev->u.stop_conn.flag);
1028 else
1029 err = -EINVAL;
Alex Aizman0896b752005-08-04 19:33:07 -07001030 break;
1031 case ISCSI_UEVENT_SEND_PDU:
Mike Christieb5c7a122006-04-06 21:13:33 -05001032 conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid);
Mike Christie7b7232f2006-02-01 21:06:49 -06001033 if (conn)
1034 ev->r.retcode = transport->send_pdu(conn,
1035 (struct iscsi_hdr*)((char*)ev + sizeof(*ev)),
1036 (char*)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,
1037 ev->u.send_pdu.data_size);
1038 else
1039 err = -EINVAL;
Alex Aizman0896b752005-08-04 19:33:07 -07001040 break;
1041 case ISCSI_UEVENT_GET_STATS:
Mike Christie5b940ad2006-02-01 21:06:56 -06001042 err = iscsi_if_get_stats(transport, nlh);
Alex Aizman0896b752005-08-04 19:33:07 -07001043 break;
Or Gerlitz264faaa2006-05-02 19:46:36 -05001044 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
1045 case ISCSI_UEVENT_TRANSPORT_EP_POLL:
1046 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
1047 err = iscsi_if_transport_ep(transport, ev, nlh->nlmsg_type);
1048 break;
Mike Christie01cb2252006-06-28 12:00:22 -05001049 case ISCSI_UEVENT_TGT_DSCVR:
1050 err = iscsi_tgt_dscvr(transport, ev);
1051 break;
Alex Aizman0896b752005-08-04 19:33:07 -07001052 default:
1053 err = -EINVAL;
1054 break;
1055 }
1056
Mike Christie7b7232f2006-02-01 21:06:49 -06001057 module_put(transport->owner);
Alex Aizman0896b752005-08-04 19:33:07 -07001058 return err;
1059}
1060
Mike Christieb5c7a122006-04-06 21:13:33 -05001061/*
1062 * Get message from skb (based on rtnetlink_rcv_skb). Each message is
1063 * processed by iscsi_if_recv_msg. Malformed skbs with wrong lengths or
1064 * invalid creds are discarded silently.
1065 */
Alex Aizman0896b752005-08-04 19:33:07 -07001066static void
1067iscsi_if_rx(struct sock *sk, int len)
1068{
1069 struct sk_buff *skb;
1070
Arjan van de Ven0b950672006-01-11 13:16:10 +01001071 mutex_lock(&rx_queue_mutex);
Alex Aizman0896b752005-08-04 19:33:07 -07001072 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
Mike Christieee7f8e42006-02-01 21:07:01 -06001073 if (NETLINK_CREDS(skb)->uid) {
1074 skb_pull(skb, skb->len);
1075 goto free_skb;
1076 }
Mike Christieee7f8e42006-02-01 21:07:01 -06001077
Alex Aizman0896b752005-08-04 19:33:07 -07001078 while (skb->len >= NLMSG_SPACE(0)) {
1079 int err;
1080 uint32_t rlen;
1081 struct nlmsghdr *nlh;
1082 struct iscsi_uevent *ev;
1083
1084 nlh = (struct nlmsghdr *)skb->data;
1085 if (nlh->nlmsg_len < sizeof(*nlh) ||
1086 skb->len < nlh->nlmsg_len) {
1087 break;
1088 }
Mike Christieee7f8e42006-02-01 21:07:01 -06001089
Alex Aizman0896b752005-08-04 19:33:07 -07001090 ev = NLMSG_DATA(nlh);
1091 rlen = NLMSG_ALIGN(nlh->nlmsg_len);
1092 if (rlen > skb->len)
1093 rlen = skb->len;
Mike Christieee7f8e42006-02-01 21:07:01 -06001094
Alex Aizman0896b752005-08-04 19:33:07 -07001095 err = iscsi_if_recv_msg(skb, nlh);
1096 if (err) {
1097 ev->type = ISCSI_KEVENT_IF_ERROR;
1098 ev->iferror = err;
1099 }
1100 do {
1101 /*
1102 * special case for GET_STATS:
1103 * on success - sending reply and stats from
1104 * inside of if_recv_msg(),
1105 * on error - fall through.
1106 */
1107 if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
1108 break;
1109 err = iscsi_if_send_reply(
1110 NETLINK_CREDS(skb)->pid, nlh->nlmsg_seq,
1111 nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
Alex Aizman0896b752005-08-04 19:33:07 -07001112 } while (err < 0 && err != -ECONNREFUSED);
1113 skb_pull(skb, rlen);
1114 }
Mike Christieee7f8e42006-02-01 21:07:01 -06001115free_skb:
Alex Aizman0896b752005-08-04 19:33:07 -07001116 kfree_skb(skb);
1117 }
Arjan van de Ven0b950672006-01-11 13:16:10 +01001118 mutex_unlock(&rx_queue_mutex);
Alex Aizman0896b752005-08-04 19:33:07 -07001119}
1120
Mike Christie7b8631b2006-01-13 18:05:50 -06001121#define iscsi_cdev_to_conn(_cdev) \
1122 iscsi_dev_to_conn(_cdev->dev)
1123
Mike Christiefd7255f2006-04-06 21:13:36 -05001124#define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \
1125struct class_device_attribute class_device_attr_##_prefix##_##_name = \
1126 __ATTR(_name,_mode,_show,_store)
1127
Alex Aizman0896b752005-08-04 19:33:07 -07001128/*
1129 * iSCSI connection attrs
1130 */
Mike Christiea54a52c2006-06-28 12:00:23 -05001131#define iscsi_conn_attr_show(param) \
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132static ssize_t \
Mike Christiea54a52c2006-06-28 12:00:23 -05001133show_conn_param_##param(struct class_device *cdev, char *buf) \
Mike Christiefd7255f2006-04-06 21:13:36 -05001134{ \
1135 struct iscsi_cls_conn *conn = iscsi_cdev_to_conn(cdev); \
1136 struct iscsi_transport *t = conn->transport; \
Mike Christiea54a52c2006-06-28 12:00:23 -05001137 return t->get_conn_param(conn, param, buf); \
Mike Christiefd7255f2006-04-06 21:13:36 -05001138}
1139
Mike Christiea54a52c2006-06-28 12:00:23 -05001140#define iscsi_conn_attr(field, param) \
1141 iscsi_conn_attr_show(param) \
1142static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param, \
Mike Christiefd7255f2006-04-06 21:13:36 -05001143 NULL);
1144
Mike Christiea54a52c2006-06-28 12:00:23 -05001145iscsi_conn_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH);
1146iscsi_conn_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH);
1147iscsi_conn_attr(header_digest, ISCSI_PARAM_HDRDGST_EN);
1148iscsi_conn_attr(data_digest, ISCSI_PARAM_DATADGST_EN);
1149iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN);
1150iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN);
1151iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT);
1152iscsi_conn_attr(port, ISCSI_PARAM_CONN_PORT);
1153iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN);
1154iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS);
1155iscsi_conn_attr(address, ISCSI_PARAM_CONN_ADDRESS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156
Mike Christie7b8631b2006-01-13 18:05:50 -06001157#define iscsi_cdev_to_session(_cdev) \
1158 iscsi_dev_to_session(_cdev->dev)
1159
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160/*
Alex Aizman0896b752005-08-04 19:33:07 -07001161 * iSCSI session attrs
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 */
Mike Christiea54a52c2006-06-28 12:00:23 -05001163#define iscsi_session_attr_show(param) \
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164static ssize_t \
Mike Christiea54a52c2006-06-28 12:00:23 -05001165show_session_param_##param(struct class_device *cdev, char *buf) \
Mike Christiefd7255f2006-04-06 21:13:36 -05001166{ \
1167 struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev); \
1168 struct iscsi_transport *t = session->transport; \
Mike Christiea54a52c2006-06-28 12:00:23 -05001169 return t->get_session_param(session, param, buf); \
Mike Christiefd7255f2006-04-06 21:13:36 -05001170}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171
Mike Christiea54a52c2006-06-28 12:00:23 -05001172#define iscsi_session_attr(field, param) \
1173 iscsi_session_attr_show(param) \
1174static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
Mike Christiefd7255f2006-04-06 21:13:36 -05001175 NULL);
1176
Mike Christiea54a52c2006-06-28 12:00:23 -05001177iscsi_session_attr(targetname, ISCSI_PARAM_TARGET_NAME);
1178iscsi_session_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN);
1179iscsi_session_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T);
1180iscsi_session_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN);
1181iscsi_session_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST);
1182iscsi_session_attr(max_burst_len, ISCSI_PARAM_MAX_BURST);
1183iscsi_session_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN);
1184iscsi_session_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN);
1185iscsi_session_attr(erl, ISCSI_PARAM_ERL);
1186iscsi_session_attr(tpgt, ISCSI_PARAM_TPGT);
Mike Christiefd7255f2006-04-06 21:13:36 -05001187
Mike Christiefd7255f2006-04-06 21:13:36 -05001188#define iscsi_priv_session_attr_show(field, format) \
1189static ssize_t \
Mike Christiea54a52c2006-06-28 12:00:23 -05001190show_priv_session_##field(struct class_device *cdev, char *buf) \
Mike Christiefd7255f2006-04-06 21:13:36 -05001191{ \
Mike Christiea54a52c2006-06-28 12:00:23 -05001192 struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);\
Mike Christiefd7255f2006-04-06 21:13:36 -05001193 return sprintf(buf, format"\n", session->field); \
1194}
1195
1196#define iscsi_priv_session_attr(field, format) \
1197 iscsi_priv_session_attr_show(field, format) \
1198static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO, show_priv_session_##field, \
1199 NULL)
Mike Christie30a6c652006-04-06 21:13:39 -05001200iscsi_priv_session_attr(recovery_tmo, "%d");
Mike Christiefd7255f2006-04-06 21:13:36 -05001201
Mike Christiefd7255f2006-04-06 21:13:36 -05001202#define SETUP_PRIV_SESSION_RD_ATTR(field) \
1203do { \
1204 priv->session_attrs[count] = &class_device_attr_priv_sess_##field; \
1205 count++; \
1206} while (0)
1207
Mike Christiea54a52c2006-06-28 12:00:23 -05001208
Mike Christiefd7255f2006-04-06 21:13:36 -05001209#define SETUP_SESSION_RD_ATTR(field, param_flag) \
1210do { \
1211 if (tt->param_mask & param_flag) { \
1212 priv->session_attrs[count] = &class_device_attr_sess_##field; \
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 count++; \
Mike Christiefd7255f2006-04-06 21:13:36 -05001214 } \
1215} while (0)
1216
Mike Christiefd7255f2006-04-06 21:13:36 -05001217#define SETUP_CONN_RD_ATTR(field, param_flag) \
1218do { \
1219 if (tt->param_mask & param_flag) { \
1220 priv->conn_attrs[count] = &class_device_attr_conn_##field; \
1221 count++; \
1222 } \
1223} while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224
Alex Aizman0896b752005-08-04 19:33:07 -07001225static int iscsi_session_match(struct attribute_container *cont,
1226 struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227{
Mike Christie7b8631b2006-01-13 18:05:50 -06001228 struct iscsi_cls_session *session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 struct Scsi_Host *shost;
Alex Aizman0896b752005-08-04 19:33:07 -07001230 struct iscsi_internal *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231
Alex Aizman0896b752005-08-04 19:33:07 -07001232 if (!iscsi_is_session_dev(dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 return 0;
1234
Mike Christie7b8631b2006-01-13 18:05:50 -06001235 session = iscsi_dev_to_session(dev);
1236 shost = iscsi_session_to_shost(session);
Alex Aizman0896b752005-08-04 19:33:07 -07001237 if (!shost->transportt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 return 0;
1239
Alex Aizman0896b752005-08-04 19:33:07 -07001240 priv = to_iscsi_internal(shost->transportt);
1241 if (priv->session_cont.ac.class != &iscsi_session_class.class)
1242 return 0;
1243
1244 return &priv->session_cont.ac == cont;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245}
1246
Alex Aizman0896b752005-08-04 19:33:07 -07001247static int iscsi_conn_match(struct attribute_container *cont,
1248 struct device *dev)
1249{
Mike Christie7b8631b2006-01-13 18:05:50 -06001250 struct iscsi_cls_session *session;
1251 struct iscsi_cls_conn *conn;
Alex Aizman0896b752005-08-04 19:33:07 -07001252 struct Scsi_Host *shost;
1253 struct iscsi_internal *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254
Alex Aizman0896b752005-08-04 19:33:07 -07001255 if (!iscsi_is_conn_dev(dev))
1256 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257
Mike Christie7b8631b2006-01-13 18:05:50 -06001258 conn = iscsi_dev_to_conn(dev);
1259 session = iscsi_dev_to_session(conn->dev.parent);
1260 shost = iscsi_session_to_shost(session);
1261
Alex Aizman0896b752005-08-04 19:33:07 -07001262 if (!shost->transportt)
1263 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264
Alex Aizman0896b752005-08-04 19:33:07 -07001265 priv = to_iscsi_internal(shost->transportt);
1266 if (priv->conn_cont.ac.class != &iscsi_connection_class.class)
1267 return 0;
1268
1269 return &priv->conn_cont.ac == cont;
1270}
1271
Mike Christie30a6c652006-04-06 21:13:39 -05001272static int iscsi_host_match(struct attribute_container *cont,
1273 struct device *dev)
1274{
1275 struct Scsi_Host *shost;
1276 struct iscsi_internal *priv;
1277
1278 if (!scsi_is_host_device(dev))
1279 return 0;
1280
1281 shost = dev_to_shost(dev);
1282 if (!shost->transportt ||
1283 shost->transportt->host_attrs.ac.class != &iscsi_host_class.class)
1284 return 0;
1285
1286 priv = to_iscsi_internal(shost->transportt);
1287 return &priv->t.host_attrs.ac == cont;
1288}
1289
Mike Christie7b8631b2006-01-13 18:05:50 -06001290struct scsi_transport_template *
1291iscsi_register_transport(struct iscsi_transport *tt)
Alex Aizman0896b752005-08-04 19:33:07 -07001292{
1293 struct iscsi_internal *priv;
1294 unsigned long flags;
1295 int count = 0, err;
1296
1297 BUG_ON(!tt);
1298
1299 priv = iscsi_if_transport_lookup(tt);
1300 if (priv)
Mike Christie7b8631b2006-01-13 18:05:50 -06001301 return NULL;
Alex Aizman0896b752005-08-04 19:33:07 -07001302
Jes Sorensen24669f752006-01-16 10:31:18 -05001303 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
Alex Aizman0896b752005-08-04 19:33:07 -07001304 if (!priv)
Mike Christie7b8631b2006-01-13 18:05:50 -06001305 return NULL;
Alex Aizman0896b752005-08-04 19:33:07 -07001306 INIT_LIST_HEAD(&priv->list);
Mike Christie53cb8a12006-06-28 12:00:32 -05001307 priv->daemon_pid = -1;
Alex Aizman0896b752005-08-04 19:33:07 -07001308 priv->iscsi_transport = tt;
Mike Christie30a6c652006-04-06 21:13:39 -05001309 priv->t.user_scan = iscsi_user_scan;
Alex Aizman0896b752005-08-04 19:33:07 -07001310
1311 priv->cdev.class = &iscsi_transport_class;
1312 snprintf(priv->cdev.class_id, BUS_ID_SIZE, "%s", tt->name);
1313 err = class_device_register(&priv->cdev);
1314 if (err)
1315 goto free_priv;
1316
1317 err = sysfs_create_group(&priv->cdev.kobj, &iscsi_transport_group);
1318 if (err)
1319 goto unregister_cdev;
1320
Mike Christie30a6c652006-04-06 21:13:39 -05001321 /* host parameters */
1322 priv->t.host_attrs.ac.attrs = &priv->host_attrs[0];
1323 priv->t.host_attrs.ac.class = &iscsi_host_class.class;
1324 priv->t.host_attrs.ac.match = iscsi_host_match;
1325 priv->t.host_size = sizeof(struct iscsi_host);
1326 priv->host_attrs[0] = NULL;
1327 transport_container_register(&priv->t.host_attrs);
1328
Alex Aizman0896b752005-08-04 19:33:07 -07001329 /* connection parameters */
1330 priv->conn_cont.ac.attrs = &priv->conn_attrs[0];
1331 priv->conn_cont.ac.class = &iscsi_connection_class.class;
1332 priv->conn_cont.ac.match = iscsi_conn_match;
1333 transport_container_register(&priv->conn_cont);
1334
Mike Christiefd7255f2006-04-06 21:13:36 -05001335 SETUP_CONN_RD_ATTR(max_recv_dlength, ISCSI_MAX_RECV_DLENGTH);
1336 SETUP_CONN_RD_ATTR(max_xmit_dlength, ISCSI_MAX_XMIT_DLENGTH);
1337 SETUP_CONN_RD_ATTR(header_digest, ISCSI_HDRDGST_EN);
1338 SETUP_CONN_RD_ATTR(data_digest, ISCSI_DATADGST_EN);
1339 SETUP_CONN_RD_ATTR(ifmarker, ISCSI_IFMARKER_EN);
1340 SETUP_CONN_RD_ATTR(ofmarker, ISCSI_OFMARKER_EN);
1341 SETUP_CONN_RD_ATTR(address, ISCSI_CONN_ADDRESS);
1342 SETUP_CONN_RD_ATTR(port, ISCSI_CONN_PORT);
Mike Christie8d2860b2006-05-02 19:46:47 -05001343 SETUP_CONN_RD_ATTR(exp_statsn, ISCSI_EXP_STATSN);
Mike Christiea54a52c2006-06-28 12:00:23 -05001344 SETUP_CONN_RD_ATTR(persistent_address, ISCSI_PERSISTENT_ADDRESS);
1345 SETUP_CONN_RD_ATTR(persistent_port, ISCSI_PERSISTENT_PORT);
Alex Aizman0896b752005-08-04 19:33:07 -07001346
1347 BUG_ON(count > ISCSI_CONN_ATTRS);
1348 priv->conn_attrs[count] = NULL;
1349 count = 0;
1350
1351 /* session parameters */
1352 priv->session_cont.ac.attrs = &priv->session_attrs[0];
1353 priv->session_cont.ac.class = &iscsi_session_class.class;
1354 priv->session_cont.ac.match = iscsi_session_match;
1355 transport_container_register(&priv->session_cont);
1356
Mike Christiefd7255f2006-04-06 21:13:36 -05001357 SETUP_SESSION_RD_ATTR(initial_r2t, ISCSI_INITIAL_R2T_EN);
1358 SETUP_SESSION_RD_ATTR(max_outstanding_r2t, ISCSI_MAX_R2T);
1359 SETUP_SESSION_RD_ATTR(immediate_data, ISCSI_IMM_DATA_EN);
1360 SETUP_SESSION_RD_ATTR(first_burst_len, ISCSI_FIRST_BURST);
1361 SETUP_SESSION_RD_ATTR(max_burst_len, ISCSI_MAX_BURST);
1362 SETUP_SESSION_RD_ATTR(data_pdu_in_order, ISCSI_PDU_INORDER_EN);
1363 SETUP_SESSION_RD_ATTR(data_seq_in_order, ISCSI_DATASEQ_INORDER_EN);
1364 SETUP_SESSION_RD_ATTR(erl, ISCSI_ERL);
Mike Christiea54a52c2006-06-28 12:00:23 -05001365 SETUP_SESSION_RD_ATTR(targetname, ISCSI_TARGET_NAME);
1366 SETUP_SESSION_RD_ATTR(tpgt, ISCSI_TPGT);
Mike Christie30a6c652006-04-06 21:13:39 -05001367 SETUP_PRIV_SESSION_RD_ATTR(recovery_tmo);
Mike Christiefd7255f2006-04-06 21:13:36 -05001368
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 BUG_ON(count > ISCSI_SESSION_ATTRS);
Alex Aizman0896b752005-08-04 19:33:07 -07001370 priv->session_attrs[count] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371
Alex Aizman0896b752005-08-04 19:33:07 -07001372 spin_lock_irqsave(&iscsi_transport_lock, flags);
1373 list_add(&priv->list, &iscsi_transports);
1374 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
Alex Aizman0896b752005-08-04 19:33:07 -07001376 printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
Mike Christie7b8631b2006-01-13 18:05:50 -06001377 return &priv->t;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378
Alex Aizman0896b752005-08-04 19:33:07 -07001379unregister_cdev:
1380 class_device_unregister(&priv->cdev);
1381free_priv:
1382 kfree(priv);
Mike Christie7b8631b2006-01-13 18:05:50 -06001383 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384}
Alex Aizman0896b752005-08-04 19:33:07 -07001385EXPORT_SYMBOL_GPL(iscsi_register_transport);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386
Alex Aizman0896b752005-08-04 19:33:07 -07001387int iscsi_unregister_transport(struct iscsi_transport *tt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388{
Alex Aizman0896b752005-08-04 19:33:07 -07001389 struct iscsi_internal *priv;
1390 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
Alex Aizman0896b752005-08-04 19:33:07 -07001392 BUG_ON(!tt);
1393
Arjan van de Ven0b950672006-01-11 13:16:10 +01001394 mutex_lock(&rx_queue_mutex);
Alex Aizman0896b752005-08-04 19:33:07 -07001395
1396 priv = iscsi_if_transport_lookup(tt);
1397 BUG_ON (!priv);
1398
Alex Aizman0896b752005-08-04 19:33:07 -07001399 spin_lock_irqsave(&iscsi_transport_lock, flags);
1400 list_del(&priv->list);
1401 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
1402
1403 transport_container_unregister(&priv->conn_cont);
1404 transport_container_unregister(&priv->session_cont);
Mike Christie30a6c652006-04-06 21:13:39 -05001405 transport_container_unregister(&priv->t.host_attrs);
Alex Aizman0896b752005-08-04 19:33:07 -07001406
1407 sysfs_remove_group(&priv->cdev.kobj, &iscsi_transport_group);
1408 class_device_unregister(&priv->cdev);
Arjan van de Ven0b950672006-01-11 13:16:10 +01001409 mutex_unlock(&rx_queue_mutex);
Alex Aizman0896b752005-08-04 19:33:07 -07001410
1411 return 0;
1412}
1413EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
1414
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415static __init int iscsi_transport_init(void)
1416{
Alex Aizman0896b752005-08-04 19:33:07 -07001417 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418
Meelis Roos09492602006-12-17 12:10:26 -06001419 printk(KERN_INFO "Loading iSCSI transport class v%s.\n",
Mike Christief4246b32006-07-24 15:47:54 -05001420 ISCSI_TRANSPORT_VERSION);
1421
Alex Aizman0896b752005-08-04 19:33:07 -07001422 err = class_register(&iscsi_transport_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 if (err)
1424 return err;
Alex Aizman0896b752005-08-04 19:33:07 -07001425
Mike Christie30a6c652006-04-06 21:13:39 -05001426 err = transport_class_register(&iscsi_host_class);
Alex Aizman0896b752005-08-04 19:33:07 -07001427 if (err)
1428 goto unregister_transport_class;
1429
Mike Christie30a6c652006-04-06 21:13:39 -05001430 err = transport_class_register(&iscsi_connection_class);
1431 if (err)
1432 goto unregister_host_class;
1433
Alex Aizman0896b752005-08-04 19:33:07 -07001434 err = transport_class_register(&iscsi_session_class);
1435 if (err)
1436 goto unregister_conn_class;
1437
James Bottomley2290d2b2005-09-08 10:14:11 -05001438 nls = netlink_kernel_create(NETLINK_ISCSI, 1, iscsi_if_rx,
Mike Christie7b8631b2006-01-13 18:05:50 -06001439 THIS_MODULE);
Alex Aizman0896b752005-08-04 19:33:07 -07001440 if (!nls) {
1441 err = -ENOBUFS;
Mike Christie43a145a2006-10-16 18:09:38 -04001442 goto unregister_session_class;
Alex Aizman0896b752005-08-04 19:33:07 -07001443 }
1444
Mike Christie43a145a2006-10-16 18:09:38 -04001445 return 0;
Alex Aizman0896b752005-08-04 19:33:07 -07001446
Alex Aizman0896b752005-08-04 19:33:07 -07001447unregister_session_class:
1448 transport_class_unregister(&iscsi_session_class);
1449unregister_conn_class:
1450 transport_class_unregister(&iscsi_connection_class);
Mike Christie30a6c652006-04-06 21:13:39 -05001451unregister_host_class:
1452 transport_class_unregister(&iscsi_host_class);
Alex Aizman0896b752005-08-04 19:33:07 -07001453unregister_transport_class:
1454 class_unregister(&iscsi_transport_class);
1455 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456}
1457
1458static void __exit iscsi_transport_exit(void)
1459{
Alex Aizman0896b752005-08-04 19:33:07 -07001460 sock_release(nls->sk_socket);
Alex Aizman0896b752005-08-04 19:33:07 -07001461 transport_class_unregister(&iscsi_connection_class);
1462 transport_class_unregister(&iscsi_session_class);
Mike Christie30a6c652006-04-06 21:13:39 -05001463 transport_class_unregister(&iscsi_host_class);
Alex Aizman0896b752005-08-04 19:33:07 -07001464 class_unregister(&iscsi_transport_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465}
1466
1467module_init(iscsi_transport_init);
1468module_exit(iscsi_transport_exit);
1469
Alex Aizman0896b752005-08-04 19:33:07 -07001470MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
1471 "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
1472 "Alex Aizman <itn780@yahoo.com>");
1473MODULE_DESCRIPTION("iSCSI Transport Interface");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474MODULE_LICENSE("GPL");
Mike Christief4246b32006-07-24 15:47:54 -05001475MODULE_VERSION(ISCSI_TRANSPORT_VERSION);