projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] libiscsi: add warm target reset tmf support
[deliverable/linux.git] / drivers / scsi / scsi_transport_iscsi.c
CommitLineData
0896b752 1/*
1da177e4
LT		 2 * iSCSI transport class definitions
3 *
4 * Copyright (C) IBM Corporation, 2004
0896b752
AA		 5 * Copyright (C) Mike Christie, 2004 - 2005
6 * Copyright (C) Dmitry Yusupov, 2004 - 2005
7 * Copyright (C) Alex Aizman, 2004 - 2005
1da177e4
LT		 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#include <linux/module.h>
0b950672 24#include <linux/mutex.h>
0896b752 25#include <net/tcp.h>
1da177e4
LT		 26#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>
0896b752 31#include <scsi/iscsi_if.h>
1da177e4 32
3fe5ae8b 33#define ISCSI_SESSION_ATTRS 22
c238c3bb 34#define ISCSI_CONN_ATTRS 13
d8196ed2 35#define ISCSI_HOST_ATTRS 4
d82ff9be 36
4c2133c8 37#define ISCSI_TRANSPORT_VERSION "2.0-870"
1da177e4 38
632248aa
MC		 39static int dbg_session;
40module_param_named(debug_session, dbg_session, int,
41 S_IRUGO | S_IWUSR);
42MODULE_PARM_DESC(debug_session,
43 "Turn on debugging for sessions in scsi_transport_iscsi "
44 "module. Set to 1 to turn on, and zero to turn off. Default "
45 "is off.");
46
47static int dbg_conn;
48module_param_named(debug_conn, dbg_conn, int,
49 S_IRUGO | S_IWUSR);
50MODULE_PARM_DESC(debug_conn,
51 "Turn on debugging for connections in scsi_transport_iscsi "
52 "module. Set to 1 to turn on, and zero to turn off. Default "
53 "is off.");
54
55#define ISCSI_DBG_TRANS_SESSION(_session, dbg_fmt, arg...) \
56 do { \
57 if (dbg_session) \
58 iscsi_cls_session_printk(KERN_INFO, _session, \
59 "%s: " dbg_fmt, \
60 __func__, ##arg); \
61 } while (0);
62
63#define ISCSI_DBG_TRANS_CONN(_conn, dbg_fmt, arg...) \
64 do { \
65 if (dbg_conn) \
66 iscsi_cls_conn_printk(KERN_INFO, _conn, \
67 "%s: " dbg_fmt, \
68 __func__, ##arg); \
69 } while (0);
70
1da177e4
LT		 71struct iscsi_internal {
72 struct scsi_transport_template t;
0896b752
AA		 73 struct iscsi_transport *iscsi_transport;
74 struct list_head list;
ee959b00 75 struct device dev;
30a6c652 76
ee959b00 77 struct device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
0896b752 78 struct transport_container conn_cont;
ee959b00 79 struct device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1];
0896b752 80 struct transport_container session_cont;
ee959b00 81 struct device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
1da177e4
LT		 82};
83
41be1444 84static atomic_t iscsi_session_nr; /* sysfs session id for next new session */
d8bf541e 85static struct workqueue_struct *iscsi_eh_timer_workq;
b5c7a12d 86
0896b752
AA		 87/*
88 * list of registered transports and lock that must
89 * be held while accessing list. The iscsi_transport_lock must
0b950672 90 * be acquired after the rx_queue_mutex.
0896b752
AA		 91 */
92static LIST_HEAD(iscsi_transports);
93static DEFINE_SPINLOCK(iscsi_transport_lock);
94
95#define to_iscsi_internal(tmpl) \
96 container_of(tmpl, struct iscsi_internal, t)
97
ee959b00
TJ		 98#define dev_to_iscsi_internal(_dev) \
99 container_of(_dev, struct iscsi_internal, dev)
0896b752 100
ee959b00 101static void iscsi_transport_release(struct device *dev)
0896b752 102{
ee959b00 103 struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
0896b752
AA		 104 kfree(priv);
105}
1da177e4 106
0896b752
AA		 107/*
108 * iscsi_transport_class represents the iscsi_transports that are
109 * registered.
110 */
111static struct class iscsi_transport_class = {
112 .name = "iscsi_transport",
ee959b00 113 .dev_release = iscsi_transport_release,
0896b752
AA		 114};
115
116static ssize_t
ee959b00
TJ		 117show_transport_handle(struct device *dev, struct device_attribute *attr,
118 char *buf)
0896b752 119{
ee959b00 120 struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
762e2bfa 121 return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
0896b752 122}
ee959b00 123static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
0896b752
AA		 124
125#define show_transport_attr(name, format) \
126static ssize_t \
ee959b00
TJ		 127show_transport_##name(struct device *dev, \
128 struct device_attribute *attr,char *buf) \
0896b752 129{ \
ee959b00 130 struct iscsi_internal *priv = dev_to_iscsi_internal(dev); \
0896b752
AA		 131 return sprintf(buf, format"\n", priv->iscsi_transport->name); \
132} \
ee959b00 133static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
0896b752
AA		 134
135show_transport_attr(caps, "0x%x");
0896b752
AA		 136
137static struct attribute *iscsi_transport_attrs[] = {
ee959b00
TJ		 138 &dev_attr_handle.attr,
139 &dev_attr_caps.attr,
0896b752
AA		 140 NULL,
141};
142
143static struct attribute_group iscsi_transport_group = {
144 .attrs = iscsi_transport_attrs,
145};
146
d82ff9be
MC		 147/*
148 * iSCSI endpoint attrs
149 */
150#define iscsi_dev_to_endpoint(_dev) \
151 container_of(_dev, struct iscsi_endpoint, dev)
152
153#define ISCSI_ATTR(_prefix,_name,_mode,_show,_store) \
154struct device_attribute dev_attr_##_prefix##_##_name = \
155 __ATTR(_name,_mode,_show,_store)
156
157static void iscsi_endpoint_release(struct device *dev)
158{
159 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
160 kfree(ep);
161}
162
163static struct class iscsi_endpoint_class = {
164 .name = "iscsi_endpoint",
165 .dev_release = iscsi_endpoint_release,
166};
167
168static ssize_t
169show_ep_handle(struct device *dev, struct device_attribute *attr, char *buf)
170{
171 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
21536062 172 return sprintf(buf, "%llu\n", (unsigned long long) ep->id);
d82ff9be
MC		 173}
174static ISCSI_ATTR(ep, handle, S_IRUGO, show_ep_handle, NULL);
175
176static struct attribute *iscsi_endpoint_attrs[] = {
177 &dev_attr_ep_handle.attr,
178 NULL,
179};
180
181static struct attribute_group iscsi_endpoint_group = {
182 .attrs = iscsi_endpoint_attrs,
183};
184
185#define ISCSI_MAX_EPID -1
186
187static int iscsi_match_epid(struct device *dev, void *data)
188{
189 struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
21536062 190 uint64_t *epid = (uint64_t *) data;
d82ff9be
MC		 191
192 return *epid == ep->id;
193}
194
195struct iscsi_endpoint *
196iscsi_create_endpoint(int dd_size)
197{
198 struct device *dev;
199 struct iscsi_endpoint *ep;
21536062 200 uint64_t id;
d82ff9be
MC		 201 int err;
202
203 for (id = 1; id < ISCSI_MAX_EPID; id++) {
695794ae 204 dev = class_find_device(&iscsi_endpoint_class, NULL, &id,
d82ff9be
MC		 205 iscsi_match_epid);
206 if (!dev)
207 break;
208 }
209 if (id == ISCSI_MAX_EPID) {
210 printk(KERN_ERR "Too many connections. Max supported %u\n",
211 ISCSI_MAX_EPID - 1);
212 return NULL;
213 }
214
215 ep = kzalloc(sizeof(*ep) + dd_size, GFP_KERNEL);
216 if (!ep)
217 return NULL;
218
219 ep->id = id;
220 ep->dev.class = &iscsi_endpoint_class;
71610f55 221 dev_set_name(&ep->dev, "ep-%llu", (unsigned long long) id);
d82ff9be
MC		 222 err = device_register(&ep->dev);
223 if (err)
224 goto free_ep;
225
226 err = sysfs_create_group(&ep->dev.kobj, &iscsi_endpoint_group);
227 if (err)
228 goto unregister_dev;
229
230 if (dd_size)
231 ep->dd_data = &ep[1];
232 return ep;
233
234unregister_dev:
235 device_unregister(&ep->dev);
236 return NULL;
237
238free_ep:
239 kfree(ep);
240 return NULL;
241}
242EXPORT_SYMBOL_GPL(iscsi_create_endpoint);
243
244void iscsi_destroy_endpoint(struct iscsi_endpoint *ep)
245{
246 sysfs_remove_group(&ep->dev.kobj, &iscsi_endpoint_group);
247 device_unregister(&ep->dev);
248}
249EXPORT_SYMBOL_GPL(iscsi_destroy_endpoint);
250
251struct iscsi_endpoint *iscsi_lookup_endpoint(u64 handle)
252{
f80f868e 253 struct iscsi_endpoint *ep;
d82ff9be
MC		 254 struct device *dev;
255
695794ae 256 dev = class_find_device(&iscsi_endpoint_class, NULL, &handle,
d82ff9be
MC		 257 iscsi_match_epid);
258 if (!dev)
259 return NULL;
260
f80f868e
MC		 261 ep = iscsi_dev_to_endpoint(dev);
262 /*
263 * we can drop this now because the interface will prevent
264 * removals and lookups from racing.
265 */
266 put_device(dev);
267 return ep;
d82ff9be
MC		 268}
269EXPORT_SYMBOL_GPL(iscsi_lookup_endpoint);
270
30a6c652 271static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
ee959b00 272 struct device *cdev)
30a6c652
MC		 273{
274 struct Scsi_Host *shost = dev_to_shost(dev);
32c6e1b9 275 struct iscsi_cls_host *ihost = shost->shost_data;
30a6c652
MC		 276
277 memset(ihost, 0, sizeof(*ihost));
8aae18ad 278 atomic_set(&ihost->nr_scans, 0);
7970634b 279 mutex_init(&ihost->mutex);
30a6c652
MC		 280 return 0;
281}
282
283static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
284 "iscsi_host",
285 iscsi_setup_host,
06d25af4 286 NULL,
30a6c652
MC		 287 NULL);
288
0896b752
AA		 289static DECLARE_TRANSPORT_CLASS(iscsi_session_class,
290 "iscsi_session",
1da177e4
LT		 291 NULL,
292 NULL,
293 NULL);
294
0896b752
AA		 295static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
296 "iscsi_connection",
1da177e4
LT		 297 NULL,
298 NULL,
299 NULL);
0896b752
AA		 300
301static struct sock *nls;
0b950672 302static DEFINE_MUTEX(rx_queue_mutex);
0896b752 303
7b7232f3
MC		 304static LIST_HEAD(sesslist);
305static DEFINE_SPINLOCK(sesslock);
7b8631b5
MC		 306static LIST_HEAD(connlist);
307static DEFINE_SPINLOCK(connlock);
0896b752 308
b5c7a12d
MC		 309static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn *conn)
310{
311 struct iscsi_cls_session *sess = iscsi_dev_to_session(conn->dev.parent);
312 return sess->sid;
313}
314
315/*
316 * Returns the matching session to a given sid
317 */
318static struct iscsi_cls_session *iscsi_session_lookup(uint32_t sid)
7b7232f3
MC		 319{
320 unsigned long flags;
321 struct iscsi_cls_session *sess;
322
323 spin_lock_irqsave(&sesslock, flags);
324 list_for_each_entry(sess, &sesslist, sess_list) {
b5c7a12d 325 if (sess->sid == sid) {
7b7232f3
MC		 326 spin_unlock_irqrestore(&sesslock, flags);
327 return sess;
328 }
329 }
330 spin_unlock_irqrestore(&sesslock, flags);
331 return NULL;
332}
333
b5c7a12d
MC		 334/*
335 * Returns the matching connection to a given sid / cid tuple
336 */
337static struct iscsi_cls_conn *iscsi_conn_lookup(uint32_t sid, uint32_t cid)
7b7232f3
MC		 338{
339 unsigned long flags;
340 struct iscsi_cls_conn *conn;
341
342 spin_lock_irqsave(&connlock, flags);
343 list_for_each_entry(conn, &connlist, conn_list) {
b5c7a12d 344 if ((conn->cid == cid) && (iscsi_conn_get_sid(conn) == sid)) {
7b7232f3
MC		 345 spin_unlock_irqrestore(&connlock, flags);
346 return conn;
347 }
348 }
349 spin_unlock_irqrestore(&connlock, flags);
350 return NULL;
351}
352
7b8631b5
MC		 353/*
354 * The following functions can be used by LLDs that allocate
355 * their own scsi_hosts or by software iscsi LLDs
356 */
6eabafbe
MC		 357static struct {
358 int value;
359 char *name;
360} iscsi_session_state_names[] = {
361 { ISCSI_SESSION_LOGGED_IN, "LOGGED_IN" },
362 { ISCSI_SESSION_FAILED, "FAILED" },
363 { ISCSI_SESSION_FREE, "FREE" },
364};
365
3b0f208a 366static const char *iscsi_session_state_name(int state)
6eabafbe
MC		 367{
368 int i;
369 char *name = NULL;
370
371 for (i = 0; i < ARRAY_SIZE(iscsi_session_state_names); i++) {
372 if (iscsi_session_state_names[i].value == state) {
373 name = iscsi_session_state_names[i].name;
374 break;
375 }
376 }
377 return name;
378}
379
380int iscsi_session_chkready(struct iscsi_cls_session *session)
381{
382 unsigned long flags;
383 int err;
384
385 spin_lock_irqsave(&session->lock, flags);
386 switch (session->state) {
387 case ISCSI_SESSION_LOGGED_IN:
388 err = 0;
389 break;
390 case ISCSI_SESSION_FAILED:
9a1a69a1 391 err = DID_IMM_RETRY << 16;
6eabafbe
MC		 392 break;
393 case ISCSI_SESSION_FREE:
56d7fcfa 394 err = DID_TRANSPORT_FAILFAST << 16;
6eabafbe
MC		 395 break;
396 default:
397 err = DID_NO_CONNECT << 16;
398 break;
399 }
400 spin_unlock_irqrestore(&session->lock, flags);
401 return err;
402}
403EXPORT_SYMBOL_GPL(iscsi_session_chkready);
404
7b8631b5
MC		 405static void iscsi_session_release(struct device *dev)
406{
407 struct iscsi_cls_session *session = iscsi_dev_to_session(dev);
7b8631b5 408 struct Scsi_Host *shost;
0896b752 409
7b8631b5
MC		 410 shost = iscsi_session_to_shost(session);
411 scsi_host_put(shost);
632248aa 412 ISCSI_DBG_TRANS_SESSION(session, "Completing session release\n");
7b8631b5 413 kfree(session);
7b8631b5 414}
0896b752 415
7b8631b5
MC		 416static int iscsi_is_session_dev(const struct device *dev)
417{
418 return dev->release == iscsi_session_release;
419}
0896b752 420
a4804cd6
MC		 421static int iscsi_iter_session_fn(struct device *dev, void *data)
422{
423 void (* fn) (struct iscsi_cls_session *) = data;
424
425 if (!iscsi_is_session_dev(dev))
426 return 0;
427 fn(iscsi_dev_to_session(dev));
428 return 0;
429}
430
431void iscsi_host_for_each_session(struct Scsi_Host *shost,
432 void (*fn)(struct iscsi_cls_session *))
433{
434 device_for_each_child(&shost->shost_gendev, fn,
435 iscsi_iter_session_fn);
436}
437EXPORT_SYMBOL_GPL(iscsi_host_for_each_session);
438
8aae18ad
MC		 439/**
440 * iscsi_scan_finished - helper to report when running scans are done
441 * @shost: scsi host
442 * @time: scan run time
443 *
444 * This function can be used by drives like qla4xxx to report to the scsi
445 * layer when the scans it kicked off at module load time are done.
446 */
447int iscsi_scan_finished(struct Scsi_Host *shost, unsigned long time)
448{
32c6e1b9 449 struct iscsi_cls_host *ihost = shost->shost_data;
8aae18ad
MC		 450 /*
451 * qla4xxx will have kicked off some session unblocks before calling
452 * scsi_scan_host, so just wait for them to complete.
453 */
454 return !atomic_read(&ihost->nr_scans);
455}
456EXPORT_SYMBOL_GPL(iscsi_scan_finished);
457
7970634b
MC		 458struct iscsi_scan_data {
459 unsigned int channel;
460 unsigned int id;
461 unsigned int lun;
462};
463
464static int iscsi_user_scan_session(struct device *dev, void *data)
30a6c652 465{
7970634b 466 struct iscsi_scan_data *scan_data = data;
30a6c652 467 struct iscsi_cls_session *session;
7970634b
MC		 468 struct Scsi_Host *shost;
469 struct iscsi_cls_host *ihost;
470 unsigned long flags;
471 unsigned int id;
472
473 if (!iscsi_is_session_dev(dev))
474 return 0;
475
476 session = iscsi_dev_to_session(dev);
632248aa
MC		 477
478 ISCSI_DBG_TRANS_SESSION(session, "Scanning session\n");
479
7970634b
MC		 480 shost = iscsi_session_to_shost(session);
481 ihost = shost->shost_data;
30a6c652
MC		 482
483 mutex_lock(&ihost->mutex);
7970634b
MC		 484 spin_lock_irqsave(&session->lock, flags);
485 if (session->state != ISCSI_SESSION_LOGGED_IN) {
486 spin_unlock_irqrestore(&session->lock, flags);
632248aa 487 goto user_scan_exit;
30a6c652 488 }
7970634b
MC		 489 id = session->target_id;
490 spin_unlock_irqrestore(&session->lock, flags);
30a6c652 491
7970634b
MC		 492 if (id != ISCSI_MAX_TARGET) {
493 if ((scan_data->channel == SCAN_WILD_CARD ||
494 scan_data->channel == 0) &&
495 (scan_data->id == SCAN_WILD_CARD ||
496 scan_data->id == id))
497 scsi_scan_target(&session->dev, 0, id,
498 scan_data->lun, 1);
499 }
632248aa
MC		 500
501user_scan_exit:
7970634b 502 mutex_unlock(&ihost->mutex);
632248aa 503 ISCSI_DBG_TRANS_SESSION(session, "Completed session scan\n");
30a6c652
MC		 504 return 0;
505}
506
7970634b
MC		 507static int iscsi_user_scan(struct Scsi_Host *shost, uint channel,
508 uint id, uint lun)
509{
510 struct iscsi_scan_data scan_data;
511
512 scan_data.channel = channel;
513 scan_data.id = id;
514 scan_data.lun = lun;
515
516 return device_for_each_child(&shost->shost_gendev, &scan_data,
517 iscsi_user_scan_session);
518}
519
bd976f62
MC		 520static void iscsi_scan_session(struct work_struct *work)
521{
522 struct iscsi_cls_session *session =
523 container_of(work, struct iscsi_cls_session, scan_work);
8aae18ad 524 struct Scsi_Host *shost = iscsi_session_to_shost(session);
32c6e1b9 525 struct iscsi_cls_host *ihost = shost->shost_data;
7970634b 526 struct iscsi_scan_data scan_data;
bd976f62 527
7970634b
MC		 528 scan_data.channel = 0;
529 scan_data.id = SCAN_WILD_CARD;
530 scan_data.lun = SCAN_WILD_CARD;
bd976f62 531
7970634b 532 iscsi_user_scan_session(&session->dev, &scan_data);
8aae18ad 533 atomic_dec(&ihost->nr_scans);
bd976f62
MC		 534}
535
c4028958 536static void session_recovery_timedout(struct work_struct *work)
30a6c652 537{
c4028958
DH		 538 struct iscsi_cls_session *session =
539 container_of(work, struct iscsi_cls_session,
540 recovery_work.work);
6eabafbe 541 unsigned long flags;
30a6c652 542
322d739d
MC		 543 iscsi_cls_session_printk(KERN_INFO, session,
544 "session recovery timed out after %d secs\n",
545 session->recovery_tmo);
30a6c652 546
6eabafbe
MC		 547 spin_lock_irqsave(&session->lock, flags);
548 switch (session->state) {
549 case ISCSI_SESSION_FAILED:
550 session->state = ISCSI_SESSION_FREE;
551 break;
552 case ISCSI_SESSION_LOGGED_IN:
553 case ISCSI_SESSION_FREE:
554 /* we raced with the unblock's flush */
555 spin_unlock_irqrestore(&session->lock, flags);
556 return;
557 }
558 spin_unlock_irqrestore(&session->lock, flags);
559
30a6c652
MC		 560 if (session->transport->session_recovery_timedout)
561 session->transport->session_recovery_timedout(session);
562
632248aa 563 ISCSI_DBG_TRANS_SESSION(session, "Unblocking SCSI target\n");
30a6c652 564 scsi_target_unblock(&session->dev);
632248aa 565 ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking SCSI target\n");
30a6c652
MC		 566}
567
45ab33b6 568static void __iscsi_unblock_session(struct work_struct *work)
6eabafbe 569{
45ab33b6
MC		 570 struct iscsi_cls_session *session =
571 container_of(work, struct iscsi_cls_session,
572 unblock_work);
bd976f62 573 struct Scsi_Host *shost = iscsi_session_to_shost(session);
32c6e1b9 574 struct iscsi_cls_host *ihost = shost->shost_data;
6eabafbe
MC		 575 unsigned long flags;
576
632248aa 577 ISCSI_DBG_TRANS_SESSION(session, "Unblocking session\n");
45ab33b6
MC		 578 /*
579 * The recovery and unblock work get run from the same workqueue,
580 * so try to cancel it if it was going to run after this unblock.
581 */
582 cancel_delayed_work(&session->recovery_work);
6eabafbe
MC		 583 spin_lock_irqsave(&session->lock, flags);
584 session->state = ISCSI_SESSION_LOGGED_IN;
585 spin_unlock_irqrestore(&session->lock, flags);
45ab33b6
MC		 586 /* start IO */
587 scsi_target_unblock(&session->dev);
8aae18ad
MC		 588 /*
589 * Only do kernel scanning if the driver is properly hooked into
590 * the async scanning code (drivers like iscsi_tcp do login and
591 * scanning from userspace).
592 */
593 if (shost->hostt->scan_finished) {
06d25af4 594 if (scsi_queue_work(shost, &session->scan_work))
8aae18ad
MC		 595 atomic_inc(&ihost->nr_scans);
596 }
632248aa 597 ISCSI_DBG_TRANS_SESSION(session, "Completed unblocking session\n");
6eabafbe 598}
45ab33b6
MC		 599
600/**
601 * iscsi_unblock_session - set a session as logged in and start IO.
602 * @session: iscsi session
603 *
604 * Mark a session as ready to accept IO.
605 */
606void iscsi_unblock_session(struct iscsi_cls_session *session)
607{
608 queue_work(iscsi_eh_timer_workq, &session->unblock_work);
609 /*
610 * make sure all the events have completed before tell the driver
611 * it is safe
612 */
613 flush_workqueue(iscsi_eh_timer_workq);
614}
30a6c652
MC		 615EXPORT_SYMBOL_GPL(iscsi_unblock_session);
616
45ab33b6 617static void __iscsi_block_session(struct work_struct *work)
30a6c652 618{
45ab33b6
MC		 619 struct iscsi_cls_session *session =
620 container_of(work, struct iscsi_cls_session,
621 block_work);
6eabafbe
MC		 622 unsigned long flags;
623
632248aa 624 ISCSI_DBG_TRANS_SESSION(session, "Blocking session\n");
6eabafbe
MC		 625 spin_lock_irqsave(&session->lock, flags);
626 session->state = ISCSI_SESSION_FAILED;
627 spin_unlock_irqrestore(&session->lock, flags);
30a6c652 628 scsi_target_block(&session->dev);
632248aa 629 ISCSI_DBG_TRANS_SESSION(session, "Completed SCSI target blocking\n");
d8bf541e
MC		 630 queue_delayed_work(iscsi_eh_timer_workq, &session->recovery_work,
631 session->recovery_tmo * HZ);
30a6c652 632}
45ab33b6
MC		 633
634void iscsi_block_session(struct iscsi_cls_session *session)
635{
636 queue_work(iscsi_eh_timer_workq, &session->block_work);
637}
30a6c652
MC		 638EXPORT_SYMBOL_GPL(iscsi_block_session);
639
26974789
MC		 640static void __iscsi_unbind_session(struct work_struct *work)
641{
642 struct iscsi_cls_session *session =
643 container_of(work, struct iscsi_cls_session,
644 unbind_work);
645 struct Scsi_Host *shost = iscsi_session_to_shost(session);
32c6e1b9 646 struct iscsi_cls_host *ihost = shost->shost_data;
7970634b 647 unsigned long flags;
26974789 648
632248aa
MC		 649 ISCSI_DBG_TRANS_SESSION(session, "Unbinding session\n");
650
26974789
MC		 651 /* Prevent new scans and make sure scanning is not in progress */
652 mutex_lock(&ihost->mutex);
7970634b
MC		 653 spin_lock_irqsave(&session->lock, flags);
654 if (session->target_id == ISCSI_MAX_TARGET) {
655 spin_unlock_irqrestore(&session->lock, flags);
26974789
MC		 656 mutex_unlock(&ihost->mutex);
657 return;
658 }
7970634b
MC		 659 session->target_id = ISCSI_MAX_TARGET;
660 spin_unlock_irqrestore(&session->lock, flags);
26974789
MC		 661 mutex_unlock(&ihost->mutex);
662
663 scsi_remove_target(&session->dev);
664 iscsi_session_event(session, ISCSI_KEVENT_UNBIND_SESSION);
632248aa 665 ISCSI_DBG_TRANS_SESSION(session, "Completed target removal\n");
26974789
MC		 666}
667
7b8631b5 668struct iscsi_cls_session *
5d91e209
MC		 669iscsi_alloc_session(struct Scsi_Host *shost, struct iscsi_transport *transport,
670 int dd_size)
7b8631b5
MC		 671{
672 struct iscsi_cls_session *session;
7b8631b5 673
5d91e209 674 session = kzalloc(sizeof(*session) + dd_size,
b5c7a12d 675 GFP_KERNEL);
7b8631b5 676 if (!session)
f53a88da
MC		 677 return NULL;
678
7b8631b5 679 session->transport = transport;
30a6c652 680 session->recovery_tmo = 120;
6eabafbe 681 session->state = ISCSI_SESSION_FREE;
c4028958 682 INIT_DELAYED_WORK(&session->recovery_work, session_recovery_timedout);
30a6c652 683 INIT_LIST_HEAD(&session->sess_list);
45ab33b6
MC		 684 INIT_WORK(&session->unblock_work, __iscsi_unblock_session);
685 INIT_WORK(&session->block_work, __iscsi_block_session);
26974789 686 INIT_WORK(&session->unbind_work, __iscsi_unbind_session);
bd976f62 687 INIT_WORK(&session->scan_work, iscsi_scan_session);
6eabafbe 688 spin_lock_init(&session->lock);
7b8631b5 689
6a8a0d36
MC		 690 /* this is released in the dev's release function */
691 scsi_host_get(shost);
8434aa8b
MC		 692 session->dev.parent = &shost->shost_gendev;
693 session->dev.release = iscsi_session_release;
694 device_initialize(&session->dev);
5d91e209 695 if (dd_size)
b5c7a12d 696 session->dd_data = &session[1];
632248aa
MC		 697
698 ISCSI_DBG_TRANS_SESSION(session, "Completed session allocation\n");
8434aa8b
MC		 699 return session;
700}
701EXPORT_SYMBOL_GPL(iscsi_alloc_session);
702
7970634b
MC		 703static int iscsi_get_next_target_id(struct device *dev, void *data)
704{
705 struct iscsi_cls_session *session;
706 unsigned long flags;
707 int err = 0;
708
709 if (!iscsi_is_session_dev(dev))
710 return 0;
711
712 session = iscsi_dev_to_session(dev);
713 spin_lock_irqsave(&session->lock, flags);
714 if (*((unsigned int *) data) == session->target_id)
715 err = -EEXIST;
716 spin_unlock_irqrestore(&session->lock, flags);
717 return err;
718}
719
6a8a0d36 720int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id)
8434aa8b
MC		 721{
722 struct Scsi_Host *shost = iscsi_session_to_shost(session);
32c6e1b9 723 struct iscsi_cls_host *ihost;
26974789 724 unsigned long flags;
7970634b 725 unsigned int id = target_id;
8434aa8b 726 int err;
b5c7a12d 727
30a6c652 728 ihost = shost->shost_data;
41be1444 729 session->sid = atomic_add_return(1, &iscsi_session_nr);
7970634b
MC		 730
731 if (id == ISCSI_MAX_TARGET) {
732 for (id = 0; id < ISCSI_MAX_TARGET; id++) {
733 err = device_for_each_child(&shost->shost_gendev, &id,
734 iscsi_get_next_target_id);
735 if (!err)
736 break;
737 }
738
739 if (id == ISCSI_MAX_TARGET) {
740 iscsi_cls_session_printk(KERN_ERR, session,
741 "Too many iscsi targets. Max "
742 "number of targets is %d.\n",
743 ISCSI_MAX_TARGET - 1);
24add1c4 744 err = -EOVERFLOW;
7970634b
MC		 745 goto release_host;
746 }
747 }
748 session->target_id = id;
30a6c652 749
71610f55 750 dev_set_name(&session->dev, "session%u", session->sid);
8434aa8b 751 err = device_add(&session->dev);
7b8631b5 752 if (err) {
322d739d
MC		 753 iscsi_cls_session_printk(KERN_ERR, session,
754 "could not register session's dev\n");
8434aa8b 755 goto release_host;
7b8631b5
MC		 756 }
757 transport_register_device(&session->dev);
758
26974789
MC		 759 spin_lock_irqsave(&sesslock, flags);
760 list_add(&session->sess_list, &sesslist);
761 spin_unlock_irqrestore(&sesslock, flags);
762
26974789 763 iscsi_session_event(session, ISCSI_KEVENT_CREATE_SESSION);
632248aa 764 ISCSI_DBG_TRANS_SESSION(session, "Completed session adding\n");
8434aa8b 765 return 0;
30a6c652 766
8434aa8b
MC		 767release_host:
768 scsi_host_put(shost);
769 return err;
7b8631b5 770}
8434aa8b 771EXPORT_SYMBOL_GPL(iscsi_add_session);
7b8631b5
MC		 772
773/**
8434aa8b
MC		 774 * iscsi_create_session - create iscsi class session
775 * @shost: scsi host
776 * @transport: iscsi transport
5d91e209 777 * @dd_size: private driver data size
eb44820c 778 * @target_id: which target
7b8631b5 779 *
8434aa8b 780 * This can be called from a LLD or iscsi_transport.
eb44820c 781 */
8434aa8b 782struct iscsi_cls_session *
5d91e209
MC		 783iscsi_create_session(struct Scsi_Host *shost, struct iscsi_transport *transport,
784 int dd_size, unsigned int target_id)
8434aa8b
MC		 785{
786 struct iscsi_cls_session *session;
787
5d91e209 788 session = iscsi_alloc_session(shost, transport, dd_size);
8434aa8b
MC		 789 if (!session)
790 return NULL;
791
6a8a0d36 792 if (iscsi_add_session(session, target_id)) {
8434aa8b
MC		 793 iscsi_free_session(session);
794 return NULL;
795 }
796 return session;
797}
798EXPORT_SYMBOL_GPL(iscsi_create_session);
799
26974789
MC		 800static void iscsi_conn_release(struct device *dev)
801{
802 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev);
803 struct device *parent = conn->dev.parent;
804
632248aa 805 ISCSI_DBG_TRANS_CONN(conn, "Releasing conn\n");
26974789
MC		 806 kfree(conn);
807 put_device(parent);
808}
809
810static int iscsi_is_conn_dev(const struct device *dev)
811{
812 return dev->release == iscsi_conn_release;
813}
814
815static int iscsi_iter_destroy_conn_fn(struct device *dev, void *data)
816{
817 if (!iscsi_is_conn_dev(dev))
818 return 0;
819 return iscsi_destroy_conn(iscsi_dev_to_conn(dev));
820}
821
8434aa8b 822void iscsi_remove_session(struct iscsi_cls_session *session)
7b8631b5 823{
30a6c652 824 struct Scsi_Host *shost = iscsi_session_to_shost(session);
26974789
MC		 825 unsigned long flags;
826 int err;
827
632248aa
MC		 828 ISCSI_DBG_TRANS_SESSION(session, "Removing session\n");
829
26974789
MC		 830 spin_lock_irqsave(&sesslock, flags);
831 list_del(&session->sess_list);
832 spin_unlock_irqrestore(&sesslock, flags);
30a6c652 833
45ab33b6
MC		 834 /* make sure there are no blocks/unblocks queued */
835 flush_workqueue(iscsi_eh_timer_workq);
836 /* make sure the timedout callout is not running */
837 if (!cancel_delayed_work(&session->recovery_work))
838 flush_workqueue(iscsi_eh_timer_workq);
26974789
MC		 839 /*
840 * If we are blocked let commands flow again. The lld or iscsi
841 * layer should set up the queuecommand to fail commands.
45ab33b6
MC		 842 * We assume that LLD will not be calling block/unblock while
843 * removing the session.
26974789 844 */
6eabafbe
MC		 845 spin_lock_irqsave(&session->lock, flags);
846 session->state = ISCSI_SESSION_FREE;
847 spin_unlock_irqrestore(&session->lock, flags);
bd976f62 848
45ab33b6
MC		 849 scsi_target_unblock(&session->dev);
850 /* flush running scans then delete devices */
06d25af4 851 scsi_flush_work(shost);
45ab33b6 852 __iscsi_unbind_session(&session->unbind_work);
30a6c652 853
26974789
MC		 854 /* hw iscsi may not have removed all connections from session */
855 err = device_for_each_child(&session->dev, NULL,
856 iscsi_iter_destroy_conn_fn);
857 if (err)
322d739d
MC		 858 iscsi_cls_session_printk(KERN_ERR, session,
859 "Could not delete all connections "
860 "for session. Error %d.\n", err);
8434aa8b 861
7b8631b5 862 transport_unregister_device(&session->dev);
632248aa
MC		 863
864 ISCSI_DBG_TRANS_SESSION(session, "Completing session removal\n");
8434aa8b
MC		 865 device_del(&session->dev);
866}
867EXPORT_SYMBOL_GPL(iscsi_remove_session);
868
869void iscsi_free_session(struct iscsi_cls_session *session)
870{
632248aa 871 ISCSI_DBG_TRANS_SESSION(session, "Freeing session\n");
26974789 872 iscsi_session_event(session, ISCSI_KEVENT_DESTROY_SESSION);
8434aa8b 873 put_device(&session->dev);
7b8631b5 874}
8434aa8b
MC		 875EXPORT_SYMBOL_GPL(iscsi_free_session);
876
877/**
878 * iscsi_destroy_session - destroy iscsi session
879 * @session: iscsi_session
880 *
881 * Can be called by a LLD or iscsi_transport. There must not be
882 * any running connections.
eb44820c 883 */
8434aa8b
MC		 884int iscsi_destroy_session(struct iscsi_cls_session *session)
885{
886 iscsi_remove_session(session);
632248aa 887 ISCSI_DBG_TRANS_SESSION(session, "Completing session destruction\n");
8434aa8b
MC		 888 iscsi_free_session(session);
889 return 0;
890}
7b8631b5
MC		 891EXPORT_SYMBOL_GPL(iscsi_destroy_session);
892
7b8631b5
MC		 893/**
894 * iscsi_create_conn - create iscsi class connection
895 * @session: iscsi cls session
5d91e209 896 * @dd_size: private driver data size
7b8631b5
MC		 897 * @cid: connection id
898 *
899 * This can be called from a LLD or iscsi_transport. The connection
900 * is child of the session so cid must be unique for all connections
901 * on the session.
b5c7a12d
MC		 902 *
903 * Since we do not support MCS, cid will normally be zero. In some cases
904 * for software iscsi we could be trying to preallocate a connection struct
905 * in which case there could be two connection structs and cid would be
906 * non-zero.
eb44820c 907 */
7b8631b5 908struct iscsi_cls_conn *
5d91e209 909iscsi_create_conn(struct iscsi_cls_session *session, int dd_size, uint32_t cid)
7b8631b5
MC		 910{
911 struct iscsi_transport *transport = session->transport;
7b8631b5 912 struct iscsi_cls_conn *conn;
26974789 913 unsigned long flags;
7b8631b5
MC		 914 int err;
915
5d91e209 916 conn = kzalloc(sizeof(*conn) + dd_size, GFP_KERNEL);
7b8631b5
MC		 917 if (!conn)
918 return NULL;
5d91e209 919 if (dd_size)
7b8631b5
MC		 920 conn->dd_data = &conn[1];
921
922 INIT_LIST_HEAD(&conn->conn_list);
923 conn->transport = transport;
b5c7a12d 924 conn->cid = cid;
7b8631b5
MC		 925
926 /* this is released in the dev's release function */
927 if (!get_device(&session->dev))
43a145a3 928 goto free_conn;
b5c7a12d 929
71610f55 930 dev_set_name(&conn->dev, "connection%d:%u", session->sid, cid);
7b8631b5
MC		 931 conn->dev.parent = &session->dev;
932 conn->dev.release = iscsi_conn_release;
933 err = device_register(&conn->dev);
934 if (err) {
322d739d
MC		 935 iscsi_cls_session_printk(KERN_ERR, session, "could not "
936 "register connection's dev\n");
7b8631b5
MC		 937 goto release_parent_ref;
938 }
939 transport_register_device(&conn->dev);
26974789
MC		 940
941 spin_lock_irqsave(&connlock, flags);
942 list_add(&conn->conn_list, &connlist);
943 conn->active = 1;
944 spin_unlock_irqrestore(&connlock, flags);
632248aa
MC		 945
946 ISCSI_DBG_TRANS_CONN(conn, "Completed conn creation\n");
7b8631b5
MC		 947 return conn;
948
949release_parent_ref:
950 put_device(&session->dev);
951free_conn:
952 kfree(conn);
953 return NULL;
954}
955
956EXPORT_SYMBOL_GPL(iscsi_create_conn);
957
958/**
959 * iscsi_destroy_conn - destroy iscsi class connection
eb44820c 960 * @conn: iscsi cls session
7b8631b5 961 *
26974789 962 * This can be called from a LLD or iscsi_transport.
eb44820c 963 */
7b8631b5
MC		 964int iscsi_destroy_conn(struct iscsi_cls_conn *conn)
965{
26974789
MC		 966 unsigned long flags;
967
968 spin_lock_irqsave(&connlock, flags);
969 conn->active = 0;
970 list_del(&conn->conn_list);
971 spin_unlock_irqrestore(&connlock, flags);
972
7b8631b5 973 transport_unregister_device(&conn->dev);
632248aa 974 ISCSI_DBG_TRANS_CONN(conn, "Completing conn destruction\n");
7b8631b5
MC		 975 device_unregister(&conn->dev);
976 return 0;
977}
7b8631b5
MC		 978EXPORT_SYMBOL_GPL(iscsi_destroy_conn);
979
7b8631b5
MC		 980/*
981 * iscsi interface functions
982 */
0896b752
AA		 983static struct iscsi_internal *
984iscsi_if_transport_lookup(struct iscsi_transport *tt)
985{
986 struct iscsi_internal *priv;
987 unsigned long flags;
988
989 spin_lock_irqsave(&iscsi_transport_lock, flags);
990 list_for_each_entry(priv, &iscsi_transports, list) {
991 if (tt == priv->iscsi_transport) {
992 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
993 return priv;
994 }
995 }
996 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
997 return NULL;
998}
1da177e4 999
53cb8a1f 1000static int
43514774 1001iscsi_multicast_skb(struct sk_buff *skb, uint32_t group, gfp_t gfp)
53cb8a1f 1002{
43514774 1003 return nlmsg_multicast(nls, skb, 0, group, gfp);
1da177e4 1004}
1da177e4 1005
7b7232f3 1006int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
0896b752 1007 char *data, uint32_t data_size)
1da177e4 1008{
0896b752
AA		 1009 struct nlmsghdr *nlh;
1010 struct sk_buff *skb;
1011 struct iscsi_uevent *ev;
0896b752 1012 char *pdu;
790f39a2 1013 struct iscsi_internal *priv;
0896b752
AA		 1014 int len = NLMSG_SPACE(sizeof(*ev) + sizeof(struct iscsi_hdr) +
1015 data_size);
1016
790f39a2
MC		 1017 priv = iscsi_if_transport_lookup(conn->transport);
1018 if (!priv)
1019 return -EINVAL;
1020
43a145a3 1021 skb = alloc_skb(len, GFP_ATOMIC);
0896b752 1022 if (!skb) {
e5bd7b54 1023 iscsi_conn_error_event(conn, ISCSI_ERR_CONN_FAILED);
322d739d
MC		 1024 iscsi_cls_conn_printk(KERN_ERR, conn, "can not deliver "
1025 "control PDU: OOM\n");
0896b752
AA		 1026 return -ENOMEM;
1027 }
1da177e4 1028
43514774 1029 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
0896b752
AA		 1030 ev = NLMSG_DATA(nlh);
1031 memset(ev, 0, sizeof(*ev));
1032 ev->transport_handle = iscsi_handle(conn->transport);
1033 ev->type = ISCSI_KEVENT_RECV_PDU;
b5c7a12d
MC		 1034 ev->r.recv_req.cid = conn->cid;
1035 ev->r.recv_req.sid = iscsi_conn_get_sid(conn);
0896b752
AA		 1036 pdu = (char*)ev + sizeof(*ev);
1037 memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
1038 memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
1da177e4 1039
43514774 1040 return iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
1da177e4 1041}
0896b752 1042EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
1da177e4 1043
43514774
MC		 1044int iscsi_offload_mesg(struct Scsi_Host *shost,
1045 struct iscsi_transport *transport, uint32_t type,
1046 char *data, uint16_t data_size)
1047{
1048 struct nlmsghdr *nlh;
1049 struct sk_buff *skb;
1050 struct iscsi_uevent *ev;
1051 int len = NLMSG_SPACE(sizeof(*ev) + data_size);
1052
a541f840 1053 skb = alloc_skb(len, GFP_ATOMIC);
43514774
MC		 1054 if (!skb) {
1055 printk(KERN_ERR "can not deliver iscsi offload message:OOM\n");
1056 return -ENOMEM;
1057 }
1058
1059 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
1060 ev = NLMSG_DATA(nlh);
1061 memset(ev, 0, sizeof(*ev));
1062 ev->type = type;
1063 ev->transport_handle = iscsi_handle(transport);
1064 switch (type) {
1065 case ISCSI_KEVENT_PATH_REQ:
1066 ev->r.req_path.host_no = shost->host_no;
1067 break;
1068 case ISCSI_KEVENT_IF_DOWN:
1069 ev->r.notify_if_down.host_no = shost->host_no;
1070 break;
1071 }
1072
1073 memcpy((char *)ev + sizeof(*ev), data, data_size);
1074
a541f840 1075 return iscsi_multicast_skb(skb, ISCSI_NL_GRP_UIP, GFP_ATOMIC);
43514774
MC		 1076}
1077EXPORT_SYMBOL_GPL(iscsi_offload_mesg);
1078
e5bd7b54 1079void iscsi_conn_error_event(struct iscsi_cls_conn *conn, enum iscsi_err error)
1da177e4 1080{
0896b752
AA		 1081 struct nlmsghdr *nlh;
1082 struct sk_buff *skb;
1083 struct iscsi_uevent *ev;
790f39a2 1084 struct iscsi_internal *priv;
0896b752
AA		 1085 int len = NLMSG_SPACE(sizeof(*ev));
1086
790f39a2
MC		 1087 priv = iscsi_if_transport_lookup(conn->transport);
1088 if (!priv)
1089 return;
1090
43a145a3 1091 skb = alloc_skb(len, GFP_ATOMIC);
0896b752 1092 if (!skb) {
322d739d
MC		 1093 iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored "
1094 "conn error (%d)\n", error);
0896b752
AA		 1095 return;
1096 }
1097
43514774 1098 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
0896b752
AA		 1099 ev = NLMSG_DATA(nlh);
1100 ev->transport_handle = iscsi_handle(conn->transport);
1101 ev->type = ISCSI_KEVENT_CONN_ERROR;
0896b752 1102 ev->r.connerror.error = error;
b5c7a12d
MC		 1103 ev->r.connerror.cid = conn->cid;
1104 ev->r.connerror.sid = iscsi_conn_get_sid(conn);
1da177e4 1105
43514774 1106 iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_ATOMIC);
1da177e4 1107
322d739d
MC		 1108 iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn error (%d)\n",
1109 error);
0896b752 1110}
e5bd7b54 1111EXPORT_SYMBOL_GPL(iscsi_conn_error_event);
0896b752
AA		 1112
1113static int
43514774
MC		 1114iscsi_if_send_reply(uint32_t group, int seq, int type, int done, int multi,
1115 void *payload, int size)
0896b752
AA		 1116{
1117 struct sk_buff *skb;
1118 struct nlmsghdr *nlh;
1119 int len = NLMSG_SPACE(size);
1120 int flags = multi ? NLM_F_MULTI : 0;
1121 int t = done ? NLMSG_DONE : type;
1122
43a145a3 1123 skb = alloc_skb(len, GFP_ATOMIC);
239a7dc2
MC		 1124 if (!skb) {
1125 printk(KERN_ERR "Could not allocate skb to send reply.\n");
1126 return -ENOMEM;
1127 }
0896b752 1128
43514774 1129 nlh = __nlmsg_put(skb, 0, 0, t, (len - sizeof(*nlh)), 0);
0896b752
AA		 1130 nlh->nlmsg_flags = flags;
1131 memcpy(NLMSG_DATA(nlh), payload, size);
43514774 1132 return iscsi_multicast_skb(skb, group, GFP_ATOMIC);
1da177e4 1133}
1da177e4 1134
7b8631b5 1135static int
5b940adf 1136iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
7b8631b5
MC		 1137{
1138 struct iscsi_uevent *ev = NLMSG_DATA(nlh);
1139 struct iscsi_stats *stats;
1140 struct sk_buff *skbstat;
1141 struct iscsi_cls_conn *conn;
1142 struct nlmsghdr *nlhstat;
1143 struct iscsi_uevent *evstat;
790f39a2 1144 struct iscsi_internal *priv;
7b8631b5
MC		 1145 int len = NLMSG_SPACE(sizeof(*ev) +
1146 sizeof(struct iscsi_stats) +
1147 sizeof(struct iscsi_stats_custom) *
1148 ISCSI_STATS_CUSTOM_MAX);
1149 int err = 0;
0896b752 1150
790f39a2
MC		 1151 priv = iscsi_if_transport_lookup(transport);
1152 if (!priv)
1153 return -EINVAL;
1154
b5c7a12d 1155 conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid);
7b8631b5
MC		 1156 if (!conn)
1157 return -EEXIST;
0896b752 1158
7b8631b5
MC		 1159 do {
1160 int actual_size;
0896b752 1161
43a145a3 1162 skbstat = alloc_skb(len, GFP_ATOMIC);
7b8631b5 1163 if (!skbstat) {
322d739d
MC		 1164 iscsi_cls_conn_printk(KERN_ERR, conn, "can not "
1165 "deliver stats: OOM\n");
7b8631b5
MC		 1166 return -ENOMEM;
1167 }
1168
43514774 1169 nlhstat = __nlmsg_put(skbstat, 0, 0, 0,
7b8631b5
MC		 1170 (len - sizeof(*nlhstat)), 0);
1171 evstat = NLMSG_DATA(nlhstat);
1172 memset(evstat, 0, sizeof(*evstat));
1173 evstat->transport_handle = iscsi_handle(conn->transport);
1174 evstat->type = nlh->nlmsg_type;
b5c7a12d
MC		 1175 evstat->u.get_stats.cid =
1176 ev->u.get_stats.cid;
1177 evstat->u.get_stats.sid =
1178 ev->u.get_stats.sid;
7b8631b5
MC		 1179 stats = (struct iscsi_stats *)
1180 ((char*)evstat + sizeof(*evstat));
1181 memset(stats, 0, sizeof(*stats));
1182
7b7232f3 1183 transport->get_stats(conn, stats);
7b8631b5
MC		 1184 actual_size = NLMSG_SPACE(sizeof(struct iscsi_uevent) +
1185 sizeof(struct iscsi_stats) +
1186 sizeof(struct iscsi_stats_custom) *
1187 stats->custom_length);
1188 actual_size -= sizeof(*nlhstat);
1189 actual_size = NLMSG_LENGTH(actual_size);
5b940adf 1190 skb_trim(skbstat, NLMSG_ALIGN(actual_size));
7b8631b5
MC		 1191 nlhstat->nlmsg_len = actual_size;
1192
43514774
MC		 1193 err = iscsi_multicast_skb(skbstat, ISCSI_NL_GRP_ISCSID,
1194 GFP_ATOMIC);
7b8631b5
MC		 1195 } while (err < 0 && err != -ECONNREFUSED);
1196
1197 return err;
0896b752
AA		 1198}
1199
53cb8a1f 1200/**
26974789
MC		 1201 * iscsi_session_event - send session destr. completion event
1202 * @session: iscsi class session
1203 * @event: type of event
eb44820c 1204 */
26974789
MC		 1205int iscsi_session_event(struct iscsi_cls_session *session,
1206 enum iscsi_uevent_e event)
53cb8a1f
MC		 1207{
1208 struct iscsi_internal *priv;
53cb8a1f
MC		 1209 struct Scsi_Host *shost;
1210 struct iscsi_uevent *ev;
1211 struct sk_buff *skb;
1212 struct nlmsghdr *nlh;
53cb8a1f
MC		 1213 int rc, len = NLMSG_SPACE(sizeof(*ev));
1214
26974789 1215 priv = iscsi_if_transport_lookup(session->transport);
53cb8a1f
MC		 1216 if (!priv)
1217 return -EINVAL;
53cb8a1f
MC		 1218 shost = iscsi_session_to_shost(session);
1219
43a145a3 1220 skb = alloc_skb(len, GFP_KERNEL);
53cb8a1f 1221 if (!skb) {
322d739d
MC		 1222 iscsi_cls_session_printk(KERN_ERR, session,
1223 "Cannot notify userspace of session "
1224 "event %u\n", event);
53cb8a1f
MC		 1225 return -ENOMEM;
1226 }
1227
43514774 1228 nlh = __nlmsg_put(skb, 0, 0, 0, (len - sizeof(*nlh)), 0);
53cb8a1f 1229 ev = NLMSG_DATA(nlh);
26974789 1230 ev->transport_handle = iscsi_handle(session->transport);
53cb8a1f 1231
26974789
MC		 1232 ev->type = event;
1233 switch (event) {
1234 case ISCSI_KEVENT_DESTROY_SESSION:
1235 ev->r.d_session.host_no = shost->host_no;
1236 ev->r.d_session.sid = session->sid;
1237 break;
1238 case ISCSI_KEVENT_CREATE_SESSION:
1239 ev->r.c_session_ret.host_no = shost->host_no;
1240 ev->r.c_session_ret.sid = session->sid;
1241 break;
1242 case ISCSI_KEVENT_UNBIND_SESSION:
1243 ev->r.unbind_session.host_no = shost->host_no;
1244 ev->r.unbind_session.sid = session->sid;
1245 break;
1246 default:
322d739d
MC		 1247 iscsi_cls_session_printk(KERN_ERR, session, "Invalid event "
1248 "%u.\n", event);
26974789 1249 kfree_skb(skb);
53cb8a1f 1250 return -EINVAL;
53cb8a1f
MC		 1251 }
1252
53cb8a1f
MC		 1253 /*
1254 * this will occur if the daemon is not up, so we just warn
1255 * the user and when the daemon is restarted it will handle it
1256 */
43514774 1257 rc = iscsi_multicast_skb(skb, ISCSI_NL_GRP_ISCSID, GFP_KERNEL);
ff491a73 1258 if (rc == -ESRCH)
322d739d
MC		 1259 iscsi_cls_session_printk(KERN_ERR, session,
1260 "Cannot notify userspace of session "
1261 "event %u. Check iscsi daemon\n",
1262 event);
632248aa
MC		 1263
1264 ISCSI_DBG_TRANS_SESSION(session, "Completed handling event %d rc %d\n",
1265 event, rc);
53cb8a1f
MC		 1266 return rc;
1267}
26974789 1268EXPORT_SYMBOL_GPL(iscsi_session_event);
53cb8a1f 1269
0896b752 1270static int
d82ff9be
MC		 1271iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_endpoint *ep,
1272 struct iscsi_uevent *ev, uint32_t initial_cmdsn,
40753caa 1273 uint16_t cmds_max, uint16_t queue_depth)
0896b752
AA		 1274{
1275 struct iscsi_transport *transport = priv->iscsi_transport;
7b7232f3 1276 struct iscsi_cls_session *session;
5e7facb7 1277 struct Scsi_Host *shost;
0896b752 1278
d82ff9be 1279 session = transport->create_session(ep, cmds_max, queue_depth,
5e7facb7 1280 initial_cmdsn);
7b7232f3 1281 if (!session)
7b8631b5 1282 return -ENOMEM;
0896b752 1283
5e7facb7
MC		 1284 shost = iscsi_session_to_shost(session);
1285 ev->r.c_session_ret.host_no = shost->host_no;
b5c7a12d 1286 ev->r.c_session_ret.sid = session->sid;
632248aa
MC		 1287 ISCSI_DBG_TRANS_SESSION(session,
1288 "Completed creating transport session\n");
0896b752 1289 return 0;
0896b752
AA		 1290}
1291
1292static int
7b7232f3 1293iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
0896b752 1294{
7b8631b5 1295 struct iscsi_cls_conn *conn;
7b7232f3 1296 struct iscsi_cls_session *session;
7b8631b5 1297
b5c7a12d
MC		 1298 session = iscsi_session_lookup(ev->u.c_conn.sid);
1299 if (!session) {
322d739d 1300 printk(KERN_ERR "iscsi: invalid session %d.\n",
b5c7a12d 1301 ev->u.c_conn.sid);
7b8631b5 1302 return -EINVAL;
b5c7a12d 1303 }
0896b752 1304
7b7232f3 1305 conn = transport->create_conn(session, ev->u.c_conn.cid);
b5c7a12d 1306 if (!conn) {
322d739d
MC		 1307 iscsi_cls_session_printk(KERN_ERR, session,
1308 "couldn't create a new connection.");
7b7232f3 1309 return -ENOMEM;
b5c7a12d 1310 }
0896b752 1311
b5c7a12d
MC		 1312 ev->r.c_conn_ret.sid = session->sid;
1313 ev->r.c_conn_ret.cid = conn->cid;
632248aa
MC		 1314
1315 ISCSI_DBG_TRANS_CONN(conn, "Completed creating transport conn\n");
0896b752 1316 return 0;
1da177e4
LT		 1317}
1318
0896b752
AA		 1319static int
1320iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
1321{
7b8631b5 1322 struct iscsi_cls_conn *conn;
0896b752 1323
b5c7a12d 1324 conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid);
0896b752 1325 if (!conn)
7b8631b5 1326 return -EINVAL;
0896b752 1327
632248aa 1328 ISCSI_DBG_TRANS_CONN(conn, "Destroying transport conn\n");
7b8631b5
MC		 1329 if (transport->destroy_conn)
1330 transport->destroy_conn(conn);
632248aa 1331
7b8631b5 1332 return 0;
0896b752
AA		 1333}
1334
fd7255f5
MC		 1335static int
1336iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev)
1337{
1338 char *data = (char*)ev + sizeof(*ev);
1339 struct iscsi_cls_conn *conn;
1340 struct iscsi_cls_session *session;
a54a52ca 1341 int err = 0, value = 0;
fd7255f5
MC		 1342
1343 session = iscsi_session_lookup(ev->u.set_param.sid);
1344 conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid);
1345 if (!conn || !session)
1346 return -EINVAL;
1347
1348 switch (ev->u.set_param.param) {
30a6c652 1349 case ISCSI_PARAM_SESS_RECOVERY_TMO:
a54a52ca 1350 sscanf(data, "%d", &value);
30a6c652
MC		 1351 if (value != 0)
1352 session->recovery_tmo = value;
1353 break;
fd7255f5 1354 default:
a54a52ca
MC		 1355 err = transport->set_param(conn, ev->u.set_param.param,
1356 data, ev->u.set_param.len);
fd7255f5
MC		 1357 }
1358
1359 return err;
1360}
1361
10eb0f01
MC		 1362static int iscsi_if_ep_connect(struct iscsi_transport *transport,
1363 struct iscsi_uevent *ev, int msg_type)
1364{
1365 struct iscsi_endpoint *ep;
1366 struct sockaddr *dst_addr;
1367 struct Scsi_Host *shost = NULL;
1368 int non_blocking, err = 0;
1369
1370 if (!transport->ep_connect)
1371 return -EINVAL;
1372
1373 if (msg_type == ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST) {
1374 shost = scsi_host_lookup(ev->u.ep_connect_through_host.host_no);
1375 if (!shost) {
1376 printk(KERN_ERR "ep connect failed. Could not find "
1377 "host no %u\n",
1378 ev->u.ep_connect_through_host.host_no);
1379 return -ENODEV;
1380 }
1381 non_blocking = ev->u.ep_connect_through_host.non_blocking;
1382 } else
1383 non_blocking = ev->u.ep_connect.non_blocking;
1384
1385 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
1386 ep = transport->ep_connect(shost, dst_addr, non_blocking);
1387 if (IS_ERR(ep)) {
1388 err = PTR_ERR(ep);
1389 goto release_host;
1390 }
1391
1392 ev->r.ep_connect_ret.handle = ep->id;
1393release_host:
1394 if (shost)
1395 scsi_host_put(shost);
1396 return err;
1397}
1398
264faaaa
OG		 1399static int
1400iscsi_if_transport_ep(struct iscsi_transport *transport,
1401 struct iscsi_uevent *ev, int msg_type)
1402{
d82ff9be 1403 struct iscsi_endpoint *ep;
264faaaa
OG		 1404 int rc = 0;
1405
1406 switch (msg_type) {
10eb0f01 1407 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST:
264faaaa 1408 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
10eb0f01 1409 rc = iscsi_if_ep_connect(transport, ev, msg_type);
264faaaa
OG		 1410 break;
1411 case ISCSI_UEVENT_TRANSPORT_EP_POLL:
1412 if (!transport->ep_poll)
1413 return -EINVAL;
1414
d82ff9be
MC		 1415 ep = iscsi_lookup_endpoint(ev->u.ep_poll.ep_handle);
1416 if (!ep)
1417 return -EINVAL;
1418
1419 ev->r.retcode = transport->ep_poll(ep,
264faaaa
OG		 1420 ev->u.ep_poll.timeout_ms);
1421 break;
1422 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
1423 if (!transport->ep_disconnect)
1424 return -EINVAL;
1425
d82ff9be
MC		 1426 ep = iscsi_lookup_endpoint(ev->u.ep_disconnect.ep_handle);
1427 if (!ep)
1428 return -EINVAL;
1429
1430 transport->ep_disconnect(ep);
264faaaa
OG		 1431 break;
1432 }
1433 return rc;
1434}
1435
01cb225d
MC		 1436static int
1437iscsi_tgt_dscvr(struct iscsi_transport *transport,
1438 struct iscsi_uevent *ev)
1439{
2174a04e 1440 struct Scsi_Host *shost;
01cb225d 1441 struct sockaddr *dst_addr;
2174a04e 1442 int err;
01cb225d
MC		 1443
1444 if (!transport->tgt_dscvr)
1445 return -EINVAL;
1446
2174a04e 1447 shost = scsi_host_lookup(ev->u.tgt_dscvr.host_no);
315cb0ad 1448 if (!shost) {
2174a04e
MC		 1449 printk(KERN_ERR "target discovery could not find host no %u\n",
1450 ev->u.tgt_dscvr.host_no);
1451 return -ENODEV;
1452 }
1453
1454
01cb225d 1455 dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
2174a04e
MC		 1456 err = transport->tgt_dscvr(shost, ev->u.tgt_dscvr.type,
1457 ev->u.tgt_dscvr.enable, dst_addr);
1458 scsi_host_put(shost);
1459 return err;
01cb225d
MC		 1460}
1461
1d9bf13a
MC		 1462static int
1463iscsi_set_host_param(struct iscsi_transport *transport,
1464 struct iscsi_uevent *ev)
1465{
1466 char *data = (char*)ev + sizeof(*ev);
1467 struct Scsi_Host *shost;
1468 int err;
1469
1470 if (!transport->set_host_param)
1471 return -ENOSYS;
1472
1473 shost = scsi_host_lookup(ev->u.set_host_param.host_no);
315cb0ad 1474 if (!shost) {
1d9bf13a
MC		 1475 printk(KERN_ERR "set_host_param could not find host no %u\n",
1476 ev->u.set_host_param.host_no);
1477 return -ENODEV;
1478 }
1479
1480 err = transport->set_host_param(shost, ev->u.set_host_param.param,
1481 data, ev->u.set_host_param.len);
1482 scsi_host_put(shost);
1483 return err;
1484}
1485
0896b752 1486static int
43514774
MC		 1487iscsi_set_path(struct iscsi_transport *transport, struct iscsi_uevent *ev)
1488{
1489 struct Scsi_Host *shost;
1490 struct iscsi_path *params;
1491 int err;
1492
1493 if (!transport->set_path)
1494 return -ENOSYS;
1495
1496 shost = scsi_host_lookup(ev->u.set_path.host_no);
1497 if (!shost) {
1498 printk(KERN_ERR "set path could not find host no %u\n",
1499 ev->u.set_path.host_no);
1500 return -ENODEV;
1501 }
1502
1503 params = (struct iscsi_path *)((char *)ev + sizeof(*ev));
1504 err = transport->set_path(shost, params);
1505
1506 scsi_host_put(shost);
1507 return err;
1508}
1509
1510static int
1511iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, uint32_t *group)
0896b752
AA		 1512{
1513 int err = 0;
1514 struct iscsi_uevent *ev = NLMSG_DATA(nlh);
1515 struct iscsi_transport *transport = NULL;
1516 struct iscsi_internal *priv;
7b7232f3
MC		 1517 struct iscsi_cls_session *session;
1518 struct iscsi_cls_conn *conn;
d82ff9be 1519 struct iscsi_endpoint *ep = NULL;
0896b752 1520
43514774
MC		 1521 if (nlh->nlmsg_type == ISCSI_UEVENT_PATH_UPDATE)
1522 *group = ISCSI_NL_GRP_UIP;
1523 else
1524 *group = ISCSI_NL_GRP_ISCSID;
1525
0896b752
AA		 1526 priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle));
1527 if (!priv)
1528 return -EINVAL;
1529 transport = priv->iscsi_transport;
1530
7b7232f3
MC		 1531 if (!try_module_get(transport->owner))
1532 return -EINVAL;
1533
0896b752
AA		 1534 switch (nlh->nlmsg_type) {
1535 case ISCSI_UEVENT_CREATE_SESSION:
d82ff9be 1536 err = iscsi_if_create_session(priv, ep, ev,
40753caa
MC		 1537 ev->u.c_session.initial_cmdsn,
1538 ev->u.c_session.cmds_max,
1539 ev->u.c_session.queue_depth);
1540 break;
1541 case ISCSI_UEVENT_CREATE_BOUND_SESSION:
d82ff9be 1542 ep = iscsi_lookup_endpoint(ev->u.c_bound_session.ep_handle);
c95fddc7
MC		 1543 if (!ep) {
1544 err = -EINVAL;
1545 break;
1546 }
d82ff9be
MC		 1547
1548 err = iscsi_if_create_session(priv, ep, ev,
40753caa
MC		 1549 ev->u.c_bound_session.initial_cmdsn,
1550 ev->u.c_bound_session.cmds_max,
1551 ev->u.c_bound_session.queue_depth);
0896b752
AA		 1552 break;
1553 case ISCSI_UEVENT_DESTROY_SESSION:
b5c7a12d 1554 session = iscsi_session_lookup(ev->u.d_session.sid);
26974789 1555 if (session)
7b7232f3 1556 transport->destroy_session(session);
26974789
MC		 1557 else
1558 err = -EINVAL;
1559 break;
1560 case ISCSI_UEVENT_UNBIND_SESSION:
1561 session = iscsi_session_lookup(ev->u.d_session.sid);
1562 if (session)
06d25af4
MC		 1563 scsi_queue_work(iscsi_session_to_shost(session),
1564 &session->unbind_work);
26974789 1565 else
7b7232f3 1566 err = -EINVAL;
0896b752
AA		 1567 break;
1568 case ISCSI_UEVENT_CREATE_CONN:
1569 err = iscsi_if_create_conn(transport, ev);
1570 break;
1571 case ISCSI_UEVENT_DESTROY_CONN:
1572 err = iscsi_if_destroy_conn(transport, ev);
1573 break;
1574 case ISCSI_UEVENT_BIND_CONN:
b5c7a12d
MC		 1575 session = iscsi_session_lookup(ev->u.b_conn.sid);
1576 conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid);
7b7232f3
MC		 1577
1578 if (session && conn)
1579 ev->r.retcode = transport->bind_conn(session, conn,
264faaaa 1580 ev->u.b_conn.transport_eph,
7b7232f3
MC		 1581 ev->u.b_conn.is_leading);
1582 else
1583 err = -EINVAL;
0896b752
AA		 1584 break;
1585 case ISCSI_UEVENT_SET_PARAM:
fd7255f5 1586 err = iscsi_set_param(transport, ev);
0896b752
AA		 1587 break;
1588 case ISCSI_UEVENT_START_CONN:
b5c7a12d 1589 conn = iscsi_conn_lookup(ev->u.start_conn.sid, ev->u.start_conn.cid);
7b7232f3
MC		 1590 if (conn)
1591 ev->r.retcode = transport->start_conn(conn);
1592 else
1593 err = -EINVAL;
0896b752
AA		 1594 break;
1595 case ISCSI_UEVENT_STOP_CONN:
b5c7a12d 1596 conn = iscsi_conn_lookup(ev->u.stop_conn.sid, ev->u.stop_conn.cid);
7b7232f3
MC		 1597 if (conn)
1598 transport->stop_conn(conn, ev->u.stop_conn.flag);
1599 else
1600 err = -EINVAL;
0896b752
AA		 1601 break;
1602 case ISCSI_UEVENT_SEND_PDU:
b5c7a12d 1603 conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid);
7b7232f3
MC		 1604 if (conn)
1605 ev->r.retcode = transport->send_pdu(conn,
1606 (struct iscsi_hdr*)((char*)ev + sizeof(*ev)),
1607 (char*)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,
1608 ev->u.send_pdu.data_size);
1609 else
1610 err = -EINVAL;
0896b752
AA		 1611 break;
1612 case ISCSI_UEVENT_GET_STATS:
5b940adf 1613 err = iscsi_if_get_stats(transport, nlh);
0896b752 1614 break;
264faaaa
OG		 1615 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
1616 case ISCSI_UEVENT_TRANSPORT_EP_POLL:
1617 case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
10eb0f01 1618 case ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST:
264faaaa
OG		 1619 err = iscsi_if_transport_ep(transport, ev, nlh->nlmsg_type);
1620 break;
01cb225d
MC		 1621 case ISCSI_UEVENT_TGT_DSCVR:
1622 err = iscsi_tgt_dscvr(transport, ev);
1623 break;
1d9bf13a
MC		 1624 case ISCSI_UEVENT_SET_HOST_PARAM:
1625 err = iscsi_set_host_param(transport, ev);
1626 break;
43514774
MC		 1627 case ISCSI_UEVENT_PATH_UPDATE:
1628 err = iscsi_set_path(transport, ev);
1629 break;
0896b752 1630 default:
1d9bf13a 1631 err = -ENOSYS;
0896b752
AA		 1632 break;
1633 }
1634
7b7232f3 1635 module_put(transport->owner);
0896b752
AA		 1636 return err;
1637}
1638
b5c7a12d 1639/*
cd40b7d3
DL		 1640 * Get message from skb. Each message is processed by iscsi_if_recv_msg.
1641 * Malformed skbs with wrong lengths or invalid creds are not processed.
b5c7a12d 1642 */
0896b752 1643static void
cd40b7d3 1644iscsi_if_rx(struct sk_buff *skb)
0896b752 1645{
0b950672 1646 mutex_lock(&rx_queue_mutex);
cd40b7d3
DL		 1647 while (skb->len >= NLMSG_SPACE(0)) {
1648 int err;
1649 uint32_t rlen;
1650 struct nlmsghdr *nlh;
1651 struct iscsi_uevent *ev;
43514774 1652 uint32_t group;
cd40b7d3
DL		 1653
1654 nlh = nlmsg_hdr(skb);
1655 if (nlh->nlmsg_len < sizeof(*nlh) ||
1656 skb->len < nlh->nlmsg_len) {
1657 break;
ee7f8e40 1658 }
ee7f8e40 1659
cd40b7d3
DL		 1660 ev = NLMSG_DATA(nlh);
1661 rlen = NLMSG_ALIGN(nlh->nlmsg_len);
1662 if (rlen > skb->len)
1663 rlen = skb->len;
0896b752 1664
43514774 1665 err = iscsi_if_recv_msg(skb, nlh, &group);
cd40b7d3
DL		 1666 if (err) {
1667 ev->type = ISCSI_KEVENT_IF_ERROR;
1668 ev->iferror = err;
0896b752 1669 }
cd40b7d3
DL		 1670 do {
1671 /*
1672 * special case for GET_STATS:
1673 * on success - sending reply and stats from
1674 * inside of if_recv_msg(),
1675 * on error - fall through.
1676 */
1677 if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
1678 break;
43514774 1679 err = iscsi_if_send_reply(group, nlh->nlmsg_seq,
cd40b7d3
DL		 1680 nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
1681 } while (err < 0 && err != -ECONNREFUSED);
1682 skb_pull(skb, rlen);
0896b752 1683 }
0b950672 1684 mutex_unlock(&rx_queue_mutex);
0896b752 1685}
1da177e4 1686
fd7255f5 1687#define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store) \
ee959b00 1688struct device_attribute dev_attr_##_prefix##_##_name = \
fd7255f5
MC		 1689 __ATTR(_name,_mode,_show,_store)
1690
1da177e4 1691/*
0896b752 1692 * iSCSI connection attrs
1da177e4 1693 */
a54a52ca 1694#define iscsi_conn_attr_show(param) \
0896b752 1695static ssize_t \
ee959b00
TJ		 1696show_conn_param_##param(struct device *dev, \
1697 struct device_attribute *attr, char *buf) \
0896b752 1698{ \
ee959b00 1699 struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent); \
7b8631b5 1700 struct iscsi_transport *t = conn->transport; \
a54a52ca 1701 return t->get_conn_param(conn, param, buf); \
0896b752
AA		 1702}
1703
a54a52ca
MC		 1704#define iscsi_conn_attr(field, param) \
1705 iscsi_conn_attr_show(param) \
1706static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param, \
fd7255f5 1707 NULL);
0896b752 1708
a54a52ca
MC		 1709iscsi_conn_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH);
1710iscsi_conn_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH);
1711iscsi_conn_attr(header_digest, ISCSI_PARAM_HDRDGST_EN);
1712iscsi_conn_attr(data_digest, ISCSI_PARAM_DATADGST_EN);
1713iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN);
1714iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN);
1715iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT);
1716iscsi_conn_attr(port, ISCSI_PARAM_CONN_PORT);
1717iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN);
1718iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS);
1719iscsi_conn_attr(address, ISCSI_PARAM_CONN_ADDRESS);
f6d5180c
MC		 1720iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);
1721iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);
1da177e4
LT		 1722
1723/*
0896b752 1724 * iSCSI session attrs
1da177e4 1725 */
b2c64167 1726#define iscsi_session_attr_show(param, perm) \
fd7255f5 1727static ssize_t \
ee959b00
TJ		 1728show_session_param_##param(struct device *dev, \
1729 struct device_attribute *attr, char *buf) \
fd7255f5 1730{ \
ee959b00
TJ		 1731 struct iscsi_cls_session *session = \
1732 iscsi_dev_to_session(dev->parent); \
fd7255f5 1733 struct iscsi_transport *t = session->transport; \
b2c64167
MC		 1734 \
1735 if (perm && !capable(CAP_SYS_ADMIN)) \
1736 return -EACCES; \
a54a52ca 1737 return t->get_session_param(session, param, buf); \
fd7255f5
MC		 1738}
1739
b2c64167
MC		 1740#define iscsi_session_attr(field, param, perm) \
1741 iscsi_session_attr_show(param, perm) \
a54a52ca 1742static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
fd7255f5
MC		 1743 NULL);
1744
b2c64167
MC		 1745iscsi_session_attr(targetname, ISCSI_PARAM_TARGET_NAME, 0);
1746iscsi_session_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN, 0);
1747iscsi_session_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T, 0);
1748iscsi_session_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN, 0);
1749iscsi_session_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST, 0);
1750iscsi_session_attr(max_burst_len, ISCSI_PARAM_MAX_BURST, 0);
1751iscsi_session_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN, 0);
1752iscsi_session_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN, 0);
1753iscsi_session_attr(erl, ISCSI_PARAM_ERL, 0);
1754iscsi_session_attr(tpgt, ISCSI_PARAM_TPGT, 0);
1755iscsi_session_attr(username, ISCSI_PARAM_USERNAME, 1);
1756iscsi_session_attr(username_in, ISCSI_PARAM_USERNAME_IN, 1);
1757iscsi_session_attr(password, ISCSI_PARAM_PASSWORD, 1);
1758iscsi_session_attr(password_in, ISCSI_PARAM_PASSWORD_IN, 1);
4cd49ea1
MC		 1759iscsi_session_attr(fast_abort, ISCSI_PARAM_FAST_ABORT, 0);
1760iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0);
1761iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0);
3fe5ae8b 1762iscsi_session_attr(tgt_reset_tmo, ISCSI_PARAM_TGT_RESET_TMO, 0);
88dfd340
MC		 1763iscsi_session_attr(ifacename, ISCSI_PARAM_IFACE_NAME, 0);
1764iscsi_session_attr(initiatorname, ISCSI_PARAM_INITIATOR_NAME, 0)
1da177e4 1765
6eabafbe 1766static ssize_t
ee959b00
TJ		 1767show_priv_session_state(struct device *dev, struct device_attribute *attr,
1768 char *buf)
6eabafbe 1769{
ee959b00 1770 struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
6eabafbe
MC		 1771 return sprintf(buf, "%s\n", iscsi_session_state_name(session->state));
1772}
1773static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
1774 NULL);
1775
fd7255f5
MC		 1776#define iscsi_priv_session_attr_show(field, format) \
1777static ssize_t \
ee959b00
TJ		 1778show_priv_session_##field(struct device *dev, \
1779 struct device_attribute *attr, char *buf) \
fd7255f5 1780{ \
ee959b00
TJ		 1781 struct iscsi_cls_session *session = \
1782 iscsi_dev_to_session(dev->parent); \
fd7255f5
MC		 1783 return sprintf(buf, format"\n", session->field); \
1784}
1785
1786#define iscsi_priv_session_attr(field, format) \
1787 iscsi_priv_session_attr_show(field, format) \
1788static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO, show_priv_session_##field, \
1789 NULL)
30a6c652 1790iscsi_priv_session_attr(recovery_tmo, "%d");
fd7255f5 1791
1819dc81
MC		 1792/*
1793 * iSCSI host attrs
1794 */
1795#define iscsi_host_attr_show(param) \
1796static ssize_t \
ee959b00
TJ		 1797show_host_param_##param(struct device *dev, \
1798 struct device_attribute *attr, char *buf) \
1819dc81 1799{ \
ee959b00 1800 struct Scsi_Host *shost = transport_class_to_shost(dev); \
1819dc81
MC		 1801 struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
1802 return priv->iscsi_transport->get_host_param(shost, param, buf); \
1803}
1804
1805#define iscsi_host_attr(field, param) \
1806 iscsi_host_attr_show(param) \
1807static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param, \
1808 NULL);
1809
d8196ed2 1810iscsi_host_attr(netdev, ISCSI_HOST_PARAM_NETDEV_NAME);
1819dc81 1811iscsi_host_attr(hwaddress, ISCSI_HOST_PARAM_HWADDRESS);
d8196ed2 1812iscsi_host_attr(ipaddress, ISCSI_HOST_PARAM_IPADDRESS);
8ad5781a 1813iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME);
1819dc81 1814
fd7255f5
MC		 1815#define SETUP_PRIV_SESSION_RD_ATTR(field) \
1816do { \
ee959b00 1817 priv->session_attrs[count] = &dev_attr_priv_sess_##field; \
fd7255f5
MC		 1818 count++; \
1819} while (0)
1820
a54a52ca 1821
fd7255f5
MC		 1822#define SETUP_SESSION_RD_ATTR(field, param_flag) \
1823do { \
1824 if (tt->param_mask & param_flag) { \
ee959b00 1825 priv->session_attrs[count] = &dev_attr_sess_##field; \
1da177e4 1826 count++; \
fd7255f5
MC		 1827 } \
1828} while (0)
1829
fd7255f5
MC		 1830#define SETUP_CONN_RD_ATTR(field, param_flag) \
1831do { \
1832 if (tt->param_mask & param_flag) { \
ee959b00 1833 priv->conn_attrs[count] = &dev_attr_conn_##field; \
fd7255f5
MC		 1834 count++; \
1835 } \
1836} while (0)
1da177e4 1837
1819dc81
MC		 1838#define SETUP_HOST_RD_ATTR(field, param_flag) \
1839do { \
1840 if (tt->host_param_mask & param_flag) { \
ee959b00 1841 priv->host_attrs[count] = &dev_attr_host_##field; \
1819dc81
MC		 1842 count++; \
1843 } \
1844} while (0)
1845
0896b752
AA		 1846static int iscsi_session_match(struct attribute_container *cont,
1847 struct device *dev)
1da177e4 1848{
7b8631b5 1849 struct iscsi_cls_session *session;
1da177e4 1850 struct Scsi_Host *shost;
0896b752
AA		 1851 struct iscsi_internal *priv;
1852
1853 if (!iscsi_is_session_dev(dev))
1854 return 0;
1da177e4 1855
7b8631b5
MC		 1856 session = iscsi_dev_to_session(dev);
1857 shost = iscsi_session_to_shost(session);
0896b752 1858 if (!shost->transportt)
1da177e4
LT		 1859 return 0;
1860
0896b752
AA		 1861 priv = to_iscsi_internal(shost->transportt);
1862 if (priv->session_cont.ac.class != &iscsi_session_class.class)
1da177e4
LT		 1863 return 0;
1864
0896b752 1865 return &priv->session_cont.ac == cont;
1da177e4
LT		 1866}
1867
0896b752
AA		 1868static int iscsi_conn_match(struct attribute_container *cont,
1869 struct device *dev)
1870{
7b8631b5
MC		 1871 struct iscsi_cls_session *session;
1872 struct iscsi_cls_conn *conn;
1da177e4 1873 struct Scsi_Host *shost;
0896b752 1874 struct iscsi_internal *priv;
1da177e4 1875
0896b752 1876 if (!iscsi_is_conn_dev(dev))
1da177e4
LT		 1877 return 0;
1878
7b8631b5
MC		 1879 conn = iscsi_dev_to_conn(dev);
1880 session = iscsi_dev_to_session(conn->dev.parent);
1881 shost = iscsi_session_to_shost(session);
1882
0896b752 1883 if (!shost->transportt)
1da177e4
LT		 1884 return 0;
1885
0896b752
AA		 1886 priv = to_iscsi_internal(shost->transportt);
1887 if (priv->conn_cont.ac.class != &iscsi_connection_class.class)
1888 return 0;
1da177e4 1889
0896b752
AA		 1890 return &priv->conn_cont.ac == cont;
1891}
1892
30a6c652
MC		 1893static int iscsi_host_match(struct attribute_container *cont,
1894 struct device *dev)
1895{
1896 struct Scsi_Host *shost;
1897 struct iscsi_internal *priv;
1898
1899 if (!scsi_is_host_device(dev))
1900 return 0;
1901
1902 shost = dev_to_shost(dev);
1903 if (!shost->transportt ||
1904 shost->transportt->host_attrs.ac.class != &iscsi_host_class.class)
1905 return 0;
1906
1907 priv = to_iscsi_internal(shost->transportt);
1908 return &priv->t.host_attrs.ac == cont;
1909}
1910
7b8631b5
MC		 1911struct scsi_transport_template *
1912iscsi_register_transport(struct iscsi_transport *tt)
0896b752
AA		 1913{
1914 struct iscsi_internal *priv;
1915 unsigned long flags;
1916 int count = 0, err;
1917
1918 BUG_ON(!tt);
1919
1920 priv = iscsi_if_transport_lookup(tt);
1921 if (priv)
7b8631b5 1922 return NULL;
0896b752 1923
24669f75 1924 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
0896b752 1925 if (!priv)
7b8631b5 1926 return NULL;
0896b752 1927 INIT_LIST_HEAD(&priv->list);
0896b752 1928 priv->iscsi_transport = tt;
30a6c652 1929 priv->t.user_scan = iscsi_user_scan;
06d25af4 1930 priv->t.create_work_queue = 1;
0896b752 1931
ee959b00 1932 priv->dev.class = &iscsi_transport_class;
71610f55 1933 dev_set_name(&priv->dev, "%s", tt->name);
ee959b00 1934 err = device_register(&priv->dev);
0896b752
AA		 1935 if (err)
1936 goto free_priv;
1937
ee959b00 1938 err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group);
0896b752 1939 if (err)
ee959b00 1940 goto unregister_dev;
0896b752 1941
30a6c652
MC		 1942 /* host parameters */
1943 priv->t.host_attrs.ac.attrs = &priv->host_attrs[0];
1944 priv->t.host_attrs.ac.class = &iscsi_host_class.class;
1945 priv->t.host_attrs.ac.match = iscsi_host_match;
32c6e1b9 1946 priv->t.host_size = sizeof(struct iscsi_cls_host);
30a6c652
MC		 1947 transport_container_register(&priv->t.host_attrs);
1948
d8196ed2 1949 SETUP_HOST_RD_ATTR(netdev, ISCSI_HOST_NETDEV_NAME);
22236961 1950 SETUP_HOST_RD_ATTR(ipaddress, ISCSI_HOST_IPADDRESS);
1819dc81 1951 SETUP_HOST_RD_ATTR(hwaddress, ISCSI_HOST_HWADDRESS);
8ad5781a 1952 SETUP_HOST_RD_ATTR(initiatorname, ISCSI_HOST_INITIATOR_NAME);
1819dc81
MC		 1953 BUG_ON(count > ISCSI_HOST_ATTRS);
1954 priv->host_attrs[count] = NULL;
1955 count = 0;
1956
0896b752
AA		 1957 /* connection parameters */
1958 priv->conn_cont.ac.attrs = &priv->conn_attrs[0];
1959 priv->conn_cont.ac.class = &iscsi_connection_class.class;
1960 priv->conn_cont.ac.match = iscsi_conn_match;
1961 transport_container_register(&priv->conn_cont);
1da177e4 1962
fd7255f5
MC		 1963 SETUP_CONN_RD_ATTR(max_recv_dlength, ISCSI_MAX_RECV_DLENGTH);
1964 SETUP_CONN_RD_ATTR(max_xmit_dlength, ISCSI_MAX_XMIT_DLENGTH);
1965 SETUP_CONN_RD_ATTR(header_digest, ISCSI_HDRDGST_EN);
1966 SETUP_CONN_RD_ATTR(data_digest, ISCSI_DATADGST_EN);
1967 SETUP_CONN_RD_ATTR(ifmarker, ISCSI_IFMARKER_EN);
1968 SETUP_CONN_RD_ATTR(ofmarker, ISCSI_OFMARKER_EN);
1969 SETUP_CONN_RD_ATTR(address, ISCSI_CONN_ADDRESS);
1970 SETUP_CONN_RD_ATTR(port, ISCSI_CONN_PORT);
8d2860b3 1971 SETUP_CONN_RD_ATTR(exp_statsn, ISCSI_EXP_STATSN);
a54a52ca
MC		 1972 SETUP_CONN_RD_ATTR(persistent_address, ISCSI_PERSISTENT_ADDRESS);
1973 SETUP_CONN_RD_ATTR(persistent_port, ISCSI_PERSISTENT_PORT);
f6d5180c
MC		 1974 SETUP_CONN_RD_ATTR(ping_tmo, ISCSI_PING_TMO);
1975 SETUP_CONN_RD_ATTR(recv_tmo, ISCSI_RECV_TMO);
0896b752
AA		 1976
1977 BUG_ON(count > ISCSI_CONN_ATTRS);
1978 priv->conn_attrs[count] = NULL;
1da177e4 1979 count = 0;
1da177e4 1980
0896b752
AA		 1981 /* session parameters */
1982 priv->session_cont.ac.attrs = &priv->session_attrs[0];
1983 priv->session_cont.ac.class = &iscsi_session_class.class;
1984 priv->session_cont.ac.match = iscsi_session_match;
1985 transport_container_register(&priv->session_cont);
1986
fd7255f5
MC		 1987 SETUP_SESSION_RD_ATTR(initial_r2t, ISCSI_INITIAL_R2T_EN);
1988 SETUP_SESSION_RD_ATTR(max_outstanding_r2t, ISCSI_MAX_R2T);
1989 SETUP_SESSION_RD_ATTR(immediate_data, ISCSI_IMM_DATA_EN);
1990 SETUP_SESSION_RD_ATTR(first_burst_len, ISCSI_FIRST_BURST);
1991 SETUP_SESSION_RD_ATTR(max_burst_len, ISCSI_MAX_BURST);
1992 SETUP_SESSION_RD_ATTR(data_pdu_in_order, ISCSI_PDU_INORDER_EN);
1993 SETUP_SESSION_RD_ATTR(data_seq_in_order, ISCSI_DATASEQ_INORDER_EN);
1994 SETUP_SESSION_RD_ATTR(erl, ISCSI_ERL);
a54a52ca
MC		 1995 SETUP_SESSION_RD_ATTR(targetname, ISCSI_TARGET_NAME);
1996 SETUP_SESSION_RD_ATTR(tpgt, ISCSI_TPGT);
b2c64167
MC		 1997 SETUP_SESSION_RD_ATTR(password, ISCSI_USERNAME);
1998 SETUP_SESSION_RD_ATTR(password_in, ISCSI_USERNAME_IN);
1999 SETUP_SESSION_RD_ATTR(username, ISCSI_PASSWORD);
2000 SETUP_SESSION_RD_ATTR(username_in, ISCSI_PASSWORD_IN);
843c0a8a 2001 SETUP_SESSION_RD_ATTR(fast_abort, ISCSI_FAST_ABORT);
4cd49ea1
MC		 2002 SETUP_SESSION_RD_ATTR(abort_tmo, ISCSI_ABORT_TMO);
2003 SETUP_SESSION_RD_ATTR(lu_reset_tmo,ISCSI_LU_RESET_TMO);
3fe5ae8b 2004 SETUP_SESSION_RD_ATTR(tgt_reset_tmo,ISCSI_TGT_RESET_TMO);
88dfd340
MC		 2005 SETUP_SESSION_RD_ATTR(ifacename, ISCSI_IFACE_NAME);
2006 SETUP_SESSION_RD_ATTR(initiatorname, ISCSI_INITIATOR_NAME);
30a6c652 2007 SETUP_PRIV_SESSION_RD_ATTR(recovery_tmo);
6eabafbe 2008 SETUP_PRIV_SESSION_RD_ATTR(state);
fd7255f5 2009
0896b752
AA		 2010 BUG_ON(count > ISCSI_SESSION_ATTRS);
2011 priv->session_attrs[count] = NULL;
2012
2013 spin_lock_irqsave(&iscsi_transport_lock, flags);
2014 list_add(&priv->list, &iscsi_transports);
2015 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
2016
2017 printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
7b8631b5 2018 return &priv->t;
1da177e4 2019
ee959b00
TJ		 2020unregister_dev:
2021 device_unregister(&priv->dev);
d82ff9be 2022 return NULL;
0896b752
AA		 2023free_priv:
2024 kfree(priv);
7b8631b5 2025 return NULL;
1da177e4 2026}
0896b752
AA		 2027EXPORT_SYMBOL_GPL(iscsi_register_transport);
2028
2029int iscsi_unregister_transport(struct iscsi_transport *tt)
2030{
2031 struct iscsi_internal *priv;
2032 unsigned long flags;
2033
2034 BUG_ON(!tt);
2035
0b950672 2036 mutex_lock(&rx_queue_mutex);
0896b752
AA		 2037
2038 priv = iscsi_if_transport_lookup(tt);
2039 BUG_ON (!priv);
2040
0896b752
AA		 2041 spin_lock_irqsave(&iscsi_transport_lock, flags);
2042 list_del(&priv->list);
2043 spin_unlock_irqrestore(&iscsi_transport_lock, flags);
2044
2045 transport_container_unregister(&priv->conn_cont);
2046 transport_container_unregister(&priv->session_cont);
30a6c652 2047 transport_container_unregister(&priv->t.host_attrs);
0896b752 2048
ee959b00
TJ		 2049 sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group);
2050 device_unregister(&priv->dev);
0b950672 2051 mutex_unlock(&rx_queue_mutex);
1da177e4 2052
0896b752
AA		 2053 return 0;
2054}
2055EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
1da177e4 2056
1da177e4
LT		 2057static __init int iscsi_transport_init(void)
2058{
0896b752 2059 int err;
1da177e4 2060
09492605 2061 printk(KERN_INFO "Loading iSCSI transport class v%s.\n",
f4246b33
MC		 2062 ISCSI_TRANSPORT_VERSION);
2063
41be1444
MC		 2064 atomic_set(&iscsi_session_nr, 0);
2065
0896b752 2066 err = class_register(&iscsi_transport_class);
1da177e4
LT		 2067 if (err)
2068 return err;
0896b752 2069
d82ff9be 2070 err = class_register(&iscsi_endpoint_class);
0896b752
AA		 2071 if (err)
2072 goto unregister_transport_class;
2073
d82ff9be
MC		 2074 err = transport_class_register(&iscsi_host_class);
2075 if (err)
2076 goto unregister_endpoint_class;
2077
30a6c652
MC		 2078 err = transport_class_register(&iscsi_connection_class);
2079 if (err)
2080 goto unregister_host_class;
2081
0896b752
AA		 2082 err = transport_class_register(&iscsi_session_class);
2083 if (err)
2084 goto unregister_conn_class;
2085
d82ff9be
MC		 2086 nls = netlink_kernel_create(&init_net, NETLINK_ISCSI, 1, iscsi_if_rx,
2087 NULL, THIS_MODULE);
0896b752
AA		 2088 if (!nls) {
2089 err = -ENOBUFS;
43a145a3 2090 goto unregister_session_class;
0896b752
AA		 2091 }
2092
d8bf541e
MC		 2093 iscsi_eh_timer_workq = create_singlethread_workqueue("iscsi_eh");
2094 if (!iscsi_eh_timer_workq)
2095 goto release_nls;
2096
43a145a3 2097 return 0;
0896b752 2098
d8bf541e 2099release_nls:
b7c6ba6e 2100 netlink_kernel_release(nls);
0896b752
AA		 2101unregister_session_class:
2102 transport_class_unregister(&iscsi_session_class);
2103unregister_conn_class:
2104 transport_class_unregister(&iscsi_connection_class);
30a6c652
MC		 2105unregister_host_class:
2106 transport_class_unregister(&iscsi_host_class);
d82ff9be
MC		 2107unregister_endpoint_class:
2108 class_unregister(&iscsi_endpoint_class);
0896b752
AA		 2109unregister_transport_class:
2110 class_unregister(&iscsi_transport_class);
2111 return err;
1da177e4
LT		 2112}
2113
2114static void __exit iscsi_transport_exit(void)
2115{
d8bf541e 2116 destroy_workqueue(iscsi_eh_timer_workq);
b7c6ba6e 2117 netlink_kernel_release(nls);
0896b752
AA		 2118 transport_class_unregister(&iscsi_connection_class);
2119 transport_class_unregister(&iscsi_session_class);
30a6c652 2120 transport_class_unregister(&iscsi_host_class);
d82ff9be 2121 class_unregister(&iscsi_endpoint_class);
0896b752 2122 class_unregister(&iscsi_transport_class);
1da177e4
LT		 2123}
2124
2125module_init(iscsi_transport_init);
2126module_exit(iscsi_transport_exit);
2127
0896b752
AA		 2128MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
2129 "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
2130 "Alex Aizman <itn780@yahoo.com>");
2131MODULE_DESCRIPTION("iSCSI Transport Interface");
1da177e4 2132MODULE_LICENSE("GPL");
f4246b33 2133MODULE_VERSION(ISCSI_TRANSPORT_VERSION);
Linux kernel - Deliverables
This page took 0.846573 seconds and 5 git commands to generate.