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