scsi_transport_iscsi.c 54.2 KB
Newer Older
1
/*
L
Linus Torvalds 已提交
2 3 4
 * iSCSI transport class definitions
 *
 * Copyright (C) IBM Corporation, 2004
5 6 7
 * Copyright (C) Mike Christie, 2004 - 2005
 * Copyright (C) Dmitry Yusupov, 2004 - 2005
 * Copyright (C) Alex Aizman, 2004 - 2005
L
Linus Torvalds 已提交
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
#include <linux/module.h>
24
#include <linux/mutex.h>
25
#include <net/tcp.h>
L
Linus Torvalds 已提交
26 27 28 29 30
#include <scsi/scsi.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_transport.h>
#include <scsi/scsi_transport_iscsi.h>
31
#include <scsi/iscsi_if.h>
L
Linus Torvalds 已提交
32

33
#define ISCSI_SESSION_ATTRS 21
34
#define ISCSI_CONN_ATTRS 13
35
#define ISCSI_HOST_ATTRS 4
36

37
#define ISCSI_TRANSPORT_VERSION "2.0-870"
L
Linus Torvalds 已提交
38 39

struct iscsi_internal {
40
	int daemon_pid;
L
Linus Torvalds 已提交
41
	struct scsi_transport_template t;
42 43
	struct iscsi_transport *iscsi_transport;
	struct list_head list;
44
	struct device dev;
M
Mike Christie 已提交
45

46
	struct device_attribute *host_attrs[ISCSI_HOST_ATTRS + 1];
47
	struct transport_container conn_cont;
48
	struct device_attribute *conn_attrs[ISCSI_CONN_ATTRS + 1];
49
	struct transport_container session_cont;
50
	struct device_attribute *session_attrs[ISCSI_SESSION_ATTRS + 1];
L
Linus Torvalds 已提交
51 52
};

53
static atomic_t iscsi_session_nr; /* sysfs session id for next new session */
54
static struct workqueue_struct *iscsi_eh_timer_workq;
55

56 57 58
/*
 * list of registered transports and lock that must
 * be held while accessing list. The iscsi_transport_lock must
59
 * be acquired after the rx_queue_mutex.
60 61 62 63 64 65 66
 */
static LIST_HEAD(iscsi_transports);
static DEFINE_SPINLOCK(iscsi_transport_lock);

#define to_iscsi_internal(tmpl) \
	container_of(tmpl, struct iscsi_internal, t)

67 68
#define dev_to_iscsi_internal(_dev) \
	container_of(_dev, struct iscsi_internal, dev)
69

70
static void iscsi_transport_release(struct device *dev)
71
{
72
	struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
73 74
	kfree(priv);
}
L
Linus Torvalds 已提交
75

76 77 78 79 80 81
/*
 * iscsi_transport_class represents the iscsi_transports that are
 * registered.
 */
static struct class iscsi_transport_class = {
	.name = "iscsi_transport",
82
	.dev_release = iscsi_transport_release,
83 84 85
};

static ssize_t
86 87
show_transport_handle(struct device *dev, struct device_attribute *attr,
		      char *buf)
88
{
89
	struct iscsi_internal *priv = dev_to_iscsi_internal(dev);
90
	return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
91
}
92
static DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);
93 94 95

#define show_transport_attr(name, format)				\
static ssize_t								\
96 97
show_transport_##name(struct device *dev, 				\
		      struct device_attribute *attr,char *buf)		\
98
{									\
99
	struct iscsi_internal *priv = dev_to_iscsi_internal(dev);	\
100 101
	return sprintf(buf, format"\n", priv->iscsi_transport->name);	\
}									\
102
static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);
103 104 105 106

show_transport_attr(caps, "0x%x");

static struct attribute *iscsi_transport_attrs[] = {
107 108
	&dev_attr_handle.attr,
	&dev_attr_caps.attr,
109 110 111 112 113 114 115
	NULL,
};

static struct attribute_group iscsi_transport_group = {
	.attrs = iscsi_transport_attrs,
};

116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
/*
 * iSCSI endpoint attrs
 */
#define iscsi_dev_to_endpoint(_dev) \
	container_of(_dev, struct iscsi_endpoint, dev)

#define ISCSI_ATTR(_prefix,_name,_mode,_show,_store)	\
struct device_attribute dev_attr_##_prefix##_##_name =	\
        __ATTR(_name,_mode,_show,_store)

static void iscsi_endpoint_release(struct device *dev)
{
	struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
	kfree(ep);
}

static struct class iscsi_endpoint_class = {
	.name = "iscsi_endpoint",
	.dev_release = iscsi_endpoint_release,
};

static ssize_t
show_ep_handle(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
	return sprintf(buf, "%u\n", ep->id);
}
static ISCSI_ATTR(ep, handle, S_IRUGO, show_ep_handle, NULL);

static struct attribute *iscsi_endpoint_attrs[] = {
	&dev_attr_ep_handle.attr,
	NULL,
};

static struct attribute_group iscsi_endpoint_group = {
	.attrs = iscsi_endpoint_attrs,
};

#define ISCSI_MAX_EPID -1

static int iscsi_match_epid(struct device *dev, void *data)
{
	struct iscsi_endpoint *ep = iscsi_dev_to_endpoint(dev);
	unsigned int *epid = (unsigned int *) data;

	return *epid == ep->id;
}

struct iscsi_endpoint *
iscsi_create_endpoint(int dd_size)
{
	struct device *dev;
	struct iscsi_endpoint *ep;
	unsigned int id;
	int err;

	for (id = 1; id < ISCSI_MAX_EPID; id++) {
173
		dev = class_find_device(&iscsi_endpoint_class, NULL, &id,
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
					iscsi_match_epid);
		if (!dev)
			break;
	}
	if (id == ISCSI_MAX_EPID) {
		printk(KERN_ERR "Too many connections. Max supported %u\n",
		       ISCSI_MAX_EPID - 1);
		return NULL;
	}

	ep = kzalloc(sizeof(*ep) + dd_size, GFP_KERNEL);
	if (!ep)
		return NULL;

	ep->id = id;
	ep->dev.class = &iscsi_endpoint_class;
	snprintf(ep->dev.bus_id, BUS_ID_SIZE, "ep-%u", id);
	err = device_register(&ep->dev);
        if (err)
                goto free_ep;

	err = sysfs_create_group(&ep->dev.kobj, &iscsi_endpoint_group);
	if (err)
		goto unregister_dev;

	if (dd_size)
		ep->dd_data = &ep[1];
	return ep;

unregister_dev:
	device_unregister(&ep->dev);
	return NULL;

free_ep:
	kfree(ep);
	return NULL;
}
EXPORT_SYMBOL_GPL(iscsi_create_endpoint);

void iscsi_destroy_endpoint(struct iscsi_endpoint *ep)
{
	sysfs_remove_group(&ep->dev.kobj, &iscsi_endpoint_group);
	device_unregister(&ep->dev);
}
EXPORT_SYMBOL_GPL(iscsi_destroy_endpoint);

struct iscsi_endpoint *iscsi_lookup_endpoint(u64 handle)
{
222
	struct iscsi_endpoint *ep;
223 224
	struct device *dev;

225
	dev = class_find_device(&iscsi_endpoint_class, NULL, &handle,
226 227 228 229
				iscsi_match_epid);
	if (!dev)
		return NULL;

230 231 232 233 234 235 236
	ep = iscsi_dev_to_endpoint(dev);
	/*
	 * we can drop this now because the interface will prevent
	 * removals and lookups from racing.
	 */
	put_device(dev);
	return ep;
237 238 239
}
EXPORT_SYMBOL_GPL(iscsi_lookup_endpoint);

M
Mike Christie 已提交
240
static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
241
			    struct device *cdev)
M
Mike Christie 已提交
242 243
{
	struct Scsi_Host *shost = dev_to_shost(dev);
244
	struct iscsi_cls_host *ihost = shost->shost_data;
M
Mike Christie 已提交
245 246

	memset(ihost, 0, sizeof(*ihost));
247
	atomic_set(&ihost->nr_scans, 0);
248
	mutex_init(&ihost->mutex);
M
Mike Christie 已提交
249

250 251
	snprintf(ihost->scan_workq_name, sizeof(ihost->scan_workq_name),
		 "iscsi_scan_%d", shost->host_no);
252 253 254
	ihost->scan_workq = create_singlethread_workqueue(
						ihost->scan_workq_name);
	if (!ihost->scan_workq)
M
Mike Christie 已提交
255 256 257 258 259
		return -ENOMEM;
	return 0;
}

static int iscsi_remove_host(struct transport_container *tc, struct device *dev,
260
			     struct device *cdev)
M
Mike Christie 已提交
261 262
{
	struct Scsi_Host *shost = dev_to_shost(dev);
263
	struct iscsi_cls_host *ihost = shost->shost_data;
M
Mike Christie 已提交
264

265
	destroy_workqueue(ihost->scan_workq);
M
Mike Christie 已提交
266 267 268 269 270 271
	return 0;
}

static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
			       "iscsi_host",
			       iscsi_setup_host,
M
Mike Christie 已提交
272
			       iscsi_remove_host,
M
Mike Christie 已提交
273 274
			       NULL);

275 276
static DECLARE_TRANSPORT_CLASS(iscsi_session_class,
			       "iscsi_session",
L
Linus Torvalds 已提交
277 278 279 280
			       NULL,
			       NULL,
			       NULL);

281 282
static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
			       "iscsi_connection",
L
Linus Torvalds 已提交
283 284 285
			       NULL,
			       NULL,
			       NULL);
286 287

static struct sock *nls;
288
static DEFINE_MUTEX(rx_queue_mutex);
289

290 291
static LIST_HEAD(sesslist);
static DEFINE_SPINLOCK(sesslock);
292 293
static LIST_HEAD(connlist);
static DEFINE_SPINLOCK(connlock);
294

295 296 297 298 299 300 301 302 303 304
static uint32_t iscsi_conn_get_sid(struct iscsi_cls_conn *conn)
{
	struct iscsi_cls_session *sess = iscsi_dev_to_session(conn->dev.parent);
	return sess->sid;
}

/*
 * Returns the matching session to a given sid
 */
static struct iscsi_cls_session *iscsi_session_lookup(uint32_t sid)
305 306 307 308 309 310
{
	unsigned long flags;
	struct iscsi_cls_session *sess;

	spin_lock_irqsave(&sesslock, flags);
	list_for_each_entry(sess, &sesslist, sess_list) {
311
		if (sess->sid == sid) {
312 313 314 315 316 317 318 319
			spin_unlock_irqrestore(&sesslock, flags);
			return sess;
		}
	}
	spin_unlock_irqrestore(&sesslock, flags);
	return NULL;
}

320 321 322 323
/*
 * Returns the matching connection to a given sid / cid tuple
 */
static struct iscsi_cls_conn *iscsi_conn_lookup(uint32_t sid, uint32_t cid)
324 325 326 327 328 329
{
	unsigned long flags;
	struct iscsi_cls_conn *conn;

	spin_lock_irqsave(&connlock, flags);
	list_for_each_entry(conn, &connlist, conn_list) {
330
		if ((conn->cid == cid) && (iscsi_conn_get_sid(conn) == sid)) {
331 332 333 334 335 336 337 338
			spin_unlock_irqrestore(&connlock, flags);
			return conn;
		}
	}
	spin_unlock_irqrestore(&connlock, flags);
	return NULL;
}

339 340 341 342
/*
 * The following functions can be used by LLDs that allocate
 * their own scsi_hosts or by software iscsi LLDs
 */
343 344 345 346 347 348 349 350 351
static struct {
	int value;
	char *name;
} iscsi_session_state_names[] = {
	{ ISCSI_SESSION_LOGGED_IN,	"LOGGED_IN" },
	{ ISCSI_SESSION_FAILED,		"FAILED" },
	{ ISCSI_SESSION_FREE,		"FREE" },
};

352
static const char *iscsi_session_state_name(int state)
353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
{
	int i;
	char *name = NULL;

	for (i = 0; i < ARRAY_SIZE(iscsi_session_state_names); i++) {
		if (iscsi_session_state_names[i].value == state) {
			name = iscsi_session_state_names[i].name;
			break;
		}
	}
	return name;
}

int iscsi_session_chkready(struct iscsi_cls_session *session)
{
	unsigned long flags;
	int err;

	spin_lock_irqsave(&session->lock, flags);
	switch (session->state) {
	case ISCSI_SESSION_LOGGED_IN:
		err = 0;
		break;
	case ISCSI_SESSION_FAILED:
377
		err = DID_TRANSPORT_DISRUPTED << 16;
378 379
		break;
	case ISCSI_SESSION_FREE:
380
		err = DID_TRANSPORT_FAILFAST << 16;
381 382 383 384 385 386 387 388 389 390
		break;
	default:
		err = DID_NO_CONNECT << 16;
		break;
	}
	spin_unlock_irqrestore(&session->lock, flags);
	return err;
}
EXPORT_SYMBOL_GPL(iscsi_session_chkready);

391 392 393 394
static void iscsi_session_release(struct device *dev)
{
	struct iscsi_cls_session *session = iscsi_dev_to_session(dev);
	struct Scsi_Host *shost;
395

396 397 398 399
	shost = iscsi_session_to_shost(session);
	scsi_host_put(shost);
	kfree(session);
}
400

401 402 403 404
static int iscsi_is_session_dev(const struct device *dev)
{
	return dev->release == iscsi_session_release;
}
405

406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
static int iscsi_iter_session_fn(struct device *dev, void *data)
{
	void (* fn) (struct iscsi_cls_session *) = data;

	if (!iscsi_is_session_dev(dev))
		return 0;
	fn(iscsi_dev_to_session(dev));
	return 0;
}

void iscsi_host_for_each_session(struct Scsi_Host *shost,
				 void (*fn)(struct iscsi_cls_session *))
{
	device_for_each_child(&shost->shost_gendev, fn,
			      iscsi_iter_session_fn);
}
EXPORT_SYMBOL_GPL(iscsi_host_for_each_session);

424 425 426 427 428 429 430 431 432 433
/**
 * iscsi_scan_finished - helper to report when running scans are done
 * @shost: scsi host
 * @time: scan run time
 *
 * This function can be used by drives like qla4xxx to report to the scsi
 * layer when the scans it kicked off at module load time are done.
 */
int iscsi_scan_finished(struct Scsi_Host *shost, unsigned long time)
{
434
	struct iscsi_cls_host *ihost = shost->shost_data;
435 436 437 438 439 440 441 442
	/*
	 * qla4xxx will have kicked off some session unblocks before calling
	 * scsi_scan_host, so just wait for them to complete.
	 */
	return !atomic_read(&ihost->nr_scans);
}
EXPORT_SYMBOL_GPL(iscsi_scan_finished);

443 444 445 446 447 448 449
struct iscsi_scan_data {
	unsigned int channel;
	unsigned int id;
	unsigned int lun;
};

static int iscsi_user_scan_session(struct device *dev, void *data)
M
Mike Christie 已提交
450
{
451
	struct iscsi_scan_data *scan_data = data;
M
Mike Christie 已提交
452
	struct iscsi_cls_session *session;
453 454 455 456 457 458 459 460 461 462 463
	struct Scsi_Host *shost;
	struct iscsi_cls_host *ihost;
	unsigned long flags;
	unsigned int id;

	if (!iscsi_is_session_dev(dev))
		return 0;

	session = iscsi_dev_to_session(dev);
	shost = iscsi_session_to_shost(session);
	ihost = shost->shost_data;
M
Mike Christie 已提交
464 465

	mutex_lock(&ihost->mutex);
466 467 468 469 470
	spin_lock_irqsave(&session->lock, flags);
	if (session->state != ISCSI_SESSION_LOGGED_IN) {
		spin_unlock_irqrestore(&session->lock, flags);
		mutex_unlock(&ihost->mutex);
		return 0;
M
Mike Christie 已提交
471
	}
472 473
	id = session->target_id;
	spin_unlock_irqrestore(&session->lock, flags);
M
Mike Christie 已提交
474

475 476 477 478 479 480 481 482 483
	if (id != ISCSI_MAX_TARGET) {
		if ((scan_data->channel == SCAN_WILD_CARD ||
		     scan_data->channel == 0) &&
		    (scan_data->id == SCAN_WILD_CARD ||
		     scan_data->id == id))
			scsi_scan_target(&session->dev, 0, id,
					 scan_data->lun, 1);
	}
	mutex_unlock(&ihost->mutex);
M
Mike Christie 已提交
484 485 486
	return 0;
}

487 488 489 490 491 492 493 494 495 496 497 498 499
static int iscsi_user_scan(struct Scsi_Host *shost, uint channel,
			   uint id, uint lun)
{
	struct iscsi_scan_data scan_data;

	scan_data.channel = channel;
	scan_data.id = id;
	scan_data.lun = lun;

	return device_for_each_child(&shost->shost_gendev, &scan_data,
				     iscsi_user_scan_session);
}

500 501 502 503
static void iscsi_scan_session(struct work_struct *work)
{
	struct iscsi_cls_session *session =
			container_of(work, struct iscsi_cls_session, scan_work);
504
	struct Scsi_Host *shost = iscsi_session_to_shost(session);
505
	struct iscsi_cls_host *ihost = shost->shost_data;
506
	struct iscsi_scan_data scan_data;
507

508 509 510
	scan_data.channel = 0;
	scan_data.id = SCAN_WILD_CARD;
	scan_data.lun = SCAN_WILD_CARD;
511

512
	iscsi_user_scan_session(&session->dev, &scan_data);
513
	atomic_dec(&ihost->nr_scans);
514 515
}

D
David Howells 已提交
516
static void session_recovery_timedout(struct work_struct *work)
M
Mike Christie 已提交
517
{
D
David Howells 已提交
518 519 520
	struct iscsi_cls_session *session =
		container_of(work, struct iscsi_cls_session,
			     recovery_work.work);
521
	unsigned long flags;
M
Mike Christie 已提交
522

523 524 525
	iscsi_cls_session_printk(KERN_INFO, session,
				 "session recovery timed out after %d secs\n",
				 session->recovery_tmo);
M
Mike Christie 已提交
526

527 528 529 530 531 532 533 534 535 536 537 538 539
	spin_lock_irqsave(&session->lock, flags);
	switch (session->state) {
	case ISCSI_SESSION_FAILED:
		session->state = ISCSI_SESSION_FREE;
		break;
	case ISCSI_SESSION_LOGGED_IN:
	case ISCSI_SESSION_FREE:
		/* we raced with the unblock's flush */
		spin_unlock_irqrestore(&session->lock, flags);
		return;
	}
	spin_unlock_irqrestore(&session->lock, flags);

M
Mike Christie 已提交
540 541 542 543 544 545
	if (session->transport->session_recovery_timedout)
		session->transport->session_recovery_timedout(session);

	scsi_target_unblock(&session->dev);
}

546
static void __iscsi_unblock_session(struct work_struct *work)
547
{
548 549 550
	struct iscsi_cls_session *session =
			container_of(work, struct iscsi_cls_session,
				     unblock_work);
551
	struct Scsi_Host *shost = iscsi_session_to_shost(session);
552
	struct iscsi_cls_host *ihost = shost->shost_data;
553 554
	unsigned long flags;

555 556 557 558 559
	/*
	 * The recovery and unblock work get run from the same workqueue,
	 * so try to cancel it if it was going to run after this unblock.
	 */
	cancel_delayed_work(&session->recovery_work);
560 561 562
	spin_lock_irqsave(&session->lock, flags);
	session->state = ISCSI_SESSION_LOGGED_IN;
	spin_unlock_irqrestore(&session->lock, flags);
563 564
	/* start IO */
	scsi_target_unblock(&session->dev);
565 566 567 568 569 570 571 572 573
	/*
	 * Only do kernel scanning if the driver is properly hooked into
	 * the async scanning code (drivers like iscsi_tcp do login and
	 * scanning from userspace).
	 */
	if (shost->hostt->scan_finished) {
		if (queue_work(ihost->scan_workq, &session->scan_work))
			atomic_inc(&ihost->nr_scans);
	}
574
}
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590

/**
 * iscsi_unblock_session - set a session as logged in and start IO.
 * @session: iscsi session
 *
 * Mark a session as ready to accept IO.
 */
void iscsi_unblock_session(struct iscsi_cls_session *session)
{
	queue_work(iscsi_eh_timer_workq, &session->unblock_work);
	/*
	 * make sure all the events have completed before tell the driver
	 * it is safe
	 */
	flush_workqueue(iscsi_eh_timer_workq);
}
M
Mike Christie 已提交
591 592
EXPORT_SYMBOL_GPL(iscsi_unblock_session);

593
static void __iscsi_block_session(struct work_struct *work)
M
Mike Christie 已提交
594
{
595 596 597
	struct iscsi_cls_session *session =
			container_of(work, struct iscsi_cls_session,
				     block_work);
598 599 600 601 602
	unsigned long flags;

	spin_lock_irqsave(&session->lock, flags);
	session->state = ISCSI_SESSION_FAILED;
	spin_unlock_irqrestore(&session->lock, flags);
M
Mike Christie 已提交
603
	scsi_target_block(&session->dev);
604 605
	queue_delayed_work(iscsi_eh_timer_workq, &session->recovery_work,
			   session->recovery_tmo * HZ);
M
Mike Christie 已提交
606
}
607 608 609 610 611

void iscsi_block_session(struct iscsi_cls_session *session)
{
	queue_work(iscsi_eh_timer_workq, &session->block_work);
}
M
Mike Christie 已提交
612 613
EXPORT_SYMBOL_GPL(iscsi_block_session);

M
Mike Christie 已提交
614 615 616 617 618 619
static void __iscsi_unbind_session(struct work_struct *work)
{
	struct iscsi_cls_session *session =
			container_of(work, struct iscsi_cls_session,
				     unbind_work);
	struct Scsi_Host *shost = iscsi_session_to_shost(session);
620
	struct iscsi_cls_host *ihost = shost->shost_data;
621
	unsigned long flags;
M
Mike Christie 已提交
622 623 624

	/* Prevent new scans and make sure scanning is not in progress */
	mutex_lock(&ihost->mutex);
625 626 627
	spin_lock_irqsave(&session->lock, flags);
	if (session->target_id == ISCSI_MAX_TARGET) {
		spin_unlock_irqrestore(&session->lock, flags);
M
Mike Christie 已提交
628 629 630
		mutex_unlock(&ihost->mutex);
		return;
	}
631 632
	session->target_id = ISCSI_MAX_TARGET;
	spin_unlock_irqrestore(&session->lock, flags);
M
Mike Christie 已提交
633 634 635 636 637 638 639 640 641
	mutex_unlock(&ihost->mutex);

	scsi_remove_target(&session->dev);
	iscsi_session_event(session, ISCSI_KEVENT_UNBIND_SESSION);
}

static int iscsi_unbind_session(struct iscsi_cls_session *session)
{
	struct Scsi_Host *shost = iscsi_session_to_shost(session);
642
	struct iscsi_cls_host *ihost = shost->shost_data;
M
Mike Christie 已提交
643

644
	return queue_work(ihost->scan_workq, &session->unbind_work);
M
Mike Christie 已提交
645 646
}

647
struct iscsi_cls_session *
648 649
iscsi_alloc_session(struct Scsi_Host *shost, struct iscsi_transport *transport,
		    int dd_size)
650 651 652
{
	struct iscsi_cls_session *session;

653
	session = kzalloc(sizeof(*session) + dd_size,
654
			  GFP_KERNEL);
655
	if (!session)
656 657
		return NULL;

658
	session->transport = transport;
M
Mike Christie 已提交
659
	session->recovery_tmo = 120;
660
	session->state = ISCSI_SESSION_FREE;
D
David Howells 已提交
661
	INIT_DELAYED_WORK(&session->recovery_work, session_recovery_timedout);
M
Mike Christie 已提交
662
	INIT_LIST_HEAD(&session->sess_list);
663 664
	INIT_WORK(&session->unblock_work, __iscsi_unblock_session);
	INIT_WORK(&session->block_work, __iscsi_block_session);
M
Mike Christie 已提交
665
	INIT_WORK(&session->unbind_work, __iscsi_unbind_session);
666
	INIT_WORK(&session->scan_work, iscsi_scan_session);
667
	spin_lock_init(&session->lock);
668

669 670
	/* this is released in the dev's release function */
	scsi_host_get(shost);
671 672 673
	session->dev.parent = &shost->shost_gendev;
	session->dev.release = iscsi_session_release;
	device_initialize(&session->dev);
674
	if (dd_size)
675
		session->dd_data = &session[1];
676 677 678 679
	return session;
}
EXPORT_SYMBOL_GPL(iscsi_alloc_session);

680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
static int iscsi_get_next_target_id(struct device *dev, void *data)
{
	struct iscsi_cls_session *session;
	unsigned long flags;
	int err = 0;

	if (!iscsi_is_session_dev(dev))
		return 0;

	session = iscsi_dev_to_session(dev);
	spin_lock_irqsave(&session->lock, flags);
	if (*((unsigned int *) data) == session->target_id)
		err = -EEXIST;
	spin_unlock_irqrestore(&session->lock, flags);
	return err;
}

697
int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id)
698 699
{
	struct Scsi_Host *shost = iscsi_session_to_shost(session);
700
	struct iscsi_cls_host *ihost;
M
Mike Christie 已提交
701
	unsigned long flags;
702
	unsigned int id = target_id;
703
	int err;
704

M
Mike Christie 已提交
705
	ihost = shost->shost_data;
706
	session->sid = atomic_add_return(1, &iscsi_session_nr);
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724

	if (id == ISCSI_MAX_TARGET) {
		for (id = 0; id < ISCSI_MAX_TARGET; id++) {
			err = device_for_each_child(&shost->shost_gendev, &id,
						    iscsi_get_next_target_id);
			if (!err)
				break;
		}

		if (id == ISCSI_MAX_TARGET) {
			iscsi_cls_session_printk(KERN_ERR, session,
						 "Too many iscsi targets. Max "
						 "number of targets is %d.\n",
						 ISCSI_MAX_TARGET - 1);
			goto release_host;
		}
	}
	session->target_id = id;
M
Mike Christie 已提交
725

726 727
	snprintf(session->dev.bus_id, BUS_ID_SIZE, "session%u",
		 session->sid);
728
	err = device_add(&session->dev);
729
	if (err) {
730 731
		iscsi_cls_session_printk(KERN_ERR, session,
					 "could not register session's dev\n");
732
		goto release_host;
733 734 735
	}
	transport_register_device(&session->dev);

M
Mike Christie 已提交
736 737 738 739 740
	spin_lock_irqsave(&sesslock, flags);
	list_add(&session->sess_list, &sesslist);
	spin_unlock_irqrestore(&sesslock, flags);

	iscsi_session_event(session, ISCSI_KEVENT_CREATE_SESSION);
741
	return 0;
M
Mike Christie 已提交
742

743 744 745
release_host:
	scsi_host_put(shost);
	return err;
746
}
747
EXPORT_SYMBOL_GPL(iscsi_add_session);
748 749

/**
750 751 752
 * iscsi_create_session - create iscsi class session
 * @shost: scsi host
 * @transport: iscsi transport
753
 * @dd_size: private driver data size
754
 * @target_id: which target
755
 *
756
 * This can be called from a LLD or iscsi_transport.
757
 */
758
struct iscsi_cls_session *
759 760
iscsi_create_session(struct Scsi_Host *shost, struct iscsi_transport *transport,
		     int dd_size, unsigned int target_id)
761 762 763
{
	struct iscsi_cls_session *session;

764
	session = iscsi_alloc_session(shost, transport, dd_size);
765 766 767
	if (!session)
		return NULL;

768
	if (iscsi_add_session(session, target_id)) {
769 770 771 772 773 774 775
		iscsi_free_session(session);
		return NULL;
	}
	return session;
}
EXPORT_SYMBOL_GPL(iscsi_create_session);

M
Mike Christie 已提交
776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
static void iscsi_conn_release(struct device *dev)
{
	struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev);
	struct device *parent = conn->dev.parent;

	kfree(conn);
	put_device(parent);
}

static int iscsi_is_conn_dev(const struct device *dev)
{
	return dev->release == iscsi_conn_release;
}

static int iscsi_iter_destroy_conn_fn(struct device *dev, void *data)
{
	if (!iscsi_is_conn_dev(dev))
		return 0;
	return iscsi_destroy_conn(iscsi_dev_to_conn(dev));
}

797
void iscsi_remove_session(struct iscsi_cls_session *session)
798
{
M
Mike Christie 已提交
799
	struct Scsi_Host *shost = iscsi_session_to_shost(session);
800
	struct iscsi_cls_host *ihost = shost->shost_data;
M
Mike Christie 已提交
801 802 803 804 805 806
	unsigned long flags;
	int err;

	spin_lock_irqsave(&sesslock, flags);
	list_del(&session->sess_list);
	spin_unlock_irqrestore(&sesslock, flags);
M
Mike Christie 已提交
807

808 809 810 811 812
	/* make sure there are no blocks/unblocks queued */
	flush_workqueue(iscsi_eh_timer_workq);
	/* make sure the timedout callout is not running */
	if (!cancel_delayed_work(&session->recovery_work))
		flush_workqueue(iscsi_eh_timer_workq);
M
Mike Christie 已提交
813 814 815
	/*
	 * If we are blocked let commands flow again. The lld or iscsi
	 * layer should set up the queuecommand to fail commands.
816 817
	 * We assume that LLD will not be calling block/unblock while
	 * removing the session.
M
Mike Christie 已提交
818
	 */
819 820 821
	spin_lock_irqsave(&session->lock, flags);
	session->state = ISCSI_SESSION_FREE;
	spin_unlock_irqrestore(&session->lock, flags);
822

823 824
	scsi_target_unblock(&session->dev);
	/* flush running scans then delete devices */
825
	flush_workqueue(ihost->scan_workq);
826
	__iscsi_unbind_session(&session->unbind_work);
M
Mike Christie 已提交
827

M
Mike Christie 已提交
828 829 830 831
	/* hw iscsi may not have removed all connections from session */
	err = device_for_each_child(&session->dev, NULL,
				    iscsi_iter_destroy_conn_fn);
	if (err)
832 833 834
		iscsi_cls_session_printk(KERN_ERR, session,
					 "Could not delete all connections "
					 "for session. Error %d.\n", err);
835

836
	transport_unregister_device(&session->dev);
837 838 839 840 841 842
	device_del(&session->dev);
}
EXPORT_SYMBOL_GPL(iscsi_remove_session);

void iscsi_free_session(struct iscsi_cls_session *session)
{
M
Mike Christie 已提交
843
	iscsi_session_event(session, ISCSI_KEVENT_DESTROY_SESSION);
844
	put_device(&session->dev);
845
}
846 847 848 849 850 851 852 853
EXPORT_SYMBOL_GPL(iscsi_free_session);

/**
 * iscsi_destroy_session - destroy iscsi session
 * @session: iscsi_session
 *
 * Can be called by a LLD or iscsi_transport. There must not be
 * any running connections.
854
 */
855 856 857 858 859 860
int iscsi_destroy_session(struct iscsi_cls_session *session)
{
	iscsi_remove_session(session);
	iscsi_free_session(session);
	return 0;
}
861 862 863 864 865
EXPORT_SYMBOL_GPL(iscsi_destroy_session);

/**
 * iscsi_create_conn - create iscsi class connection
 * @session: iscsi cls session
866
 * @dd_size: private driver data size
867 868 869 870 871
 * @cid: connection id
 *
 * This can be called from a LLD or iscsi_transport. The connection
 * is child of the session so cid must be unique for all connections
 * on the session.
872 873 874 875 876
 *
 * Since we do not support MCS, cid will normally be zero. In some cases
 * for software iscsi we could be trying to preallocate a connection struct
 * in which case there could be two connection structs and cid would be
 * non-zero.
877
 */
878
struct iscsi_cls_conn *
879
iscsi_create_conn(struct iscsi_cls_session *session, int dd_size, uint32_t cid)
880 881 882
{
	struct iscsi_transport *transport = session->transport;
	struct iscsi_cls_conn *conn;
M
Mike Christie 已提交
883
	unsigned long flags;
884 885
	int err;

886
	conn = kzalloc(sizeof(*conn) + dd_size, GFP_KERNEL);
887 888
	if (!conn)
		return NULL;
889
	if (dd_size)
890 891 892 893
		conn->dd_data = &conn[1];

	INIT_LIST_HEAD(&conn->conn_list);
	conn->transport = transport;
894
	conn->cid = cid;
895 896 897

	/* this is released in the dev's release function */
	if (!get_device(&session->dev))
898
		goto free_conn;
899

900
	snprintf(conn->dev.bus_id, BUS_ID_SIZE, "connection%d:%u",
901
		 session->sid, cid);
902 903 904 905
	conn->dev.parent = &session->dev;
	conn->dev.release = iscsi_conn_release;
	err = device_register(&conn->dev);
	if (err) {
906 907
		iscsi_cls_session_printk(KERN_ERR, session, "could not "
					 "register connection's dev\n");
908 909 910
		goto release_parent_ref;
	}
	transport_register_device(&conn->dev);
M
Mike Christie 已提交
911 912 913 914 915

	spin_lock_irqsave(&connlock, flags);
	list_add(&conn->conn_list, &connlist);
	conn->active = 1;
	spin_unlock_irqrestore(&connlock, flags);
916 917 918 919 920 921 922 923 924 925 926 927 928
	return conn;

release_parent_ref:
	put_device(&session->dev);
free_conn:
	kfree(conn);
	return NULL;
}

EXPORT_SYMBOL_GPL(iscsi_create_conn);

/**
 * iscsi_destroy_conn - destroy iscsi class connection
929
 * @conn: iscsi cls session
930
 *
M
Mike Christie 已提交
931
 * This can be called from a LLD or iscsi_transport.
932
 */
933 934
int iscsi_destroy_conn(struct iscsi_cls_conn *conn)
{
M
Mike Christie 已提交
935 936 937 938 939 940 941
	unsigned long flags;

	spin_lock_irqsave(&connlock, flags);
	conn->active = 0;
	list_del(&conn->conn_list);
	spin_unlock_irqrestore(&connlock, flags);

942 943 944 945 946 947 948 949 950
	transport_unregister_device(&conn->dev);
	device_unregister(&conn->dev);
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_destroy_conn);

/*
 * iscsi interface functions
 */
951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
static struct iscsi_internal *
iscsi_if_transport_lookup(struct iscsi_transport *tt)
{
	struct iscsi_internal *priv;
	unsigned long flags;

	spin_lock_irqsave(&iscsi_transport_lock, flags);
	list_for_each_entry(priv, &iscsi_transports, list) {
		if (tt == priv->iscsi_transport) {
			spin_unlock_irqrestore(&iscsi_transport_lock, flags);
			return priv;
		}
	}
	spin_unlock_irqrestore(&iscsi_transport_lock, flags);
	return NULL;
}
L
Linus Torvalds 已提交
967

968
static int
969
iscsi_broadcast_skb(struct sk_buff *skb, gfp_t gfp)
970 971 972
{
	int rc;

973
	rc = netlink_broadcast(nls, skb, 0, 1, gfp);
974 975 976 977 978 979 980 981
	if (rc < 0) {
		printk(KERN_ERR "iscsi: can not broadcast skb (%d)\n", rc);
		return rc;
	}

	return 0;
}

982
static int
983
iscsi_unicast_skb(struct sk_buff *skb, int pid)
984 985
{
	int rc;
L
Linus Torvalds 已提交
986

987
	rc = netlink_unicast(nls, skb, pid, MSG_DONTWAIT);
988 989 990 991 992 993
	if (rc < 0) {
		printk(KERN_ERR "iscsi: can not unicast skb (%d)\n", rc);
		return rc;
	}

	return 0;
L
Linus Torvalds 已提交
994 995
}

996
int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
997
		   char *data, uint32_t data_size)
L
Linus Torvalds 已提交
998
{
999 1000 1001 1002
	struct nlmsghdr	*nlh;
	struct sk_buff *skb;
	struct iscsi_uevent *ev;
	char *pdu;
1003
	struct iscsi_internal *priv;
1004 1005 1006
	int len = NLMSG_SPACE(sizeof(*ev) + sizeof(struct iscsi_hdr) +
			      data_size);

1007 1008 1009 1010
	priv = iscsi_if_transport_lookup(conn->transport);
	if (!priv)
		return -EINVAL;

1011
	skb = alloc_skb(len, GFP_ATOMIC);
1012
	if (!skb) {
1013
		iscsi_conn_error_event(conn, ISCSI_ERR_CONN_FAILED);
1014 1015
		iscsi_cls_conn_printk(KERN_ERR, conn, "can not deliver "
				      "control PDU: OOM\n");
1016 1017
		return -ENOMEM;
	}
L
Linus Torvalds 已提交
1018

1019
	nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
1020 1021 1022 1023
	ev = NLMSG_DATA(nlh);
	memset(ev, 0, sizeof(*ev));
	ev->transport_handle = iscsi_handle(conn->transport);
	ev->type = ISCSI_KEVENT_RECV_PDU;
1024 1025
	ev->r.recv_req.cid = conn->cid;
	ev->r.recv_req.sid = iscsi_conn_get_sid(conn);
1026 1027 1028
	pdu = (char*)ev + sizeof(*ev);
	memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
	memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
L
Linus Torvalds 已提交
1029

1030
	return iscsi_unicast_skb(skb, priv->daemon_pid);
L
Linus Torvalds 已提交
1031
}
1032
EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
L
Linus Torvalds 已提交
1033

1034
void iscsi_conn_error_event(struct iscsi_cls_conn *conn, enum iscsi_err error)
L
Linus Torvalds 已提交
1035
{
1036 1037 1038
	struct nlmsghdr	*nlh;
	struct sk_buff	*skb;
	struct iscsi_uevent *ev;
1039
	struct iscsi_internal *priv;
1040 1041
	int len = NLMSG_SPACE(sizeof(*ev));

1042 1043 1044 1045
	priv = iscsi_if_transport_lookup(conn->transport);
	if (!priv)
		return;

1046
	skb = alloc_skb(len, GFP_ATOMIC);
1047
	if (!skb) {
1048 1049
		iscsi_cls_conn_printk(KERN_ERR, conn, "gracefully ignored "
				      "conn error (%d)\n", error);
1050 1051 1052
		return;
	}

1053
	nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
1054 1055 1056 1057
	ev = NLMSG_DATA(nlh);
	ev->transport_handle = iscsi_handle(conn->transport);
	ev->type = ISCSI_KEVENT_CONN_ERROR;
	ev->r.connerror.error = error;
1058 1059
	ev->r.connerror.cid = conn->cid;
	ev->r.connerror.sid = iscsi_conn_get_sid(conn);
L
Linus Torvalds 已提交
1060

1061
	iscsi_broadcast_skb(skb, GFP_ATOMIC);
L
Linus Torvalds 已提交
1062

1063 1064
	iscsi_cls_conn_printk(KERN_INFO, conn, "detected conn error (%d)\n",
			      error);
1065
}
1066
EXPORT_SYMBOL_GPL(iscsi_conn_error_event);
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077

static int
iscsi_if_send_reply(int pid, int seq, int type, int done, int multi,
		      void *payload, int size)
{
	struct sk_buff	*skb;
	struct nlmsghdr	*nlh;
	int len = NLMSG_SPACE(size);
	int flags = multi ? NLM_F_MULTI : 0;
	int t = done ? NLMSG_DONE : type;

1078
	skb = alloc_skb(len, GFP_ATOMIC);
1079 1080 1081 1082
	if (!skb) {
		printk(KERN_ERR "Could not allocate skb to send reply.\n");
		return -ENOMEM;
	}
1083 1084 1085 1086

	nlh = __nlmsg_put(skb, pid, seq, t, (len - sizeof(*nlh)), 0);
	nlh->nlmsg_flags = flags;
	memcpy(NLMSG_DATA(nlh), payload, size);
1087
	return iscsi_unicast_skb(skb, pid);
L
Linus Torvalds 已提交
1088 1089
}

1090
static int
1091
iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
1092 1093 1094 1095 1096 1097 1098
{
	struct iscsi_uevent *ev = NLMSG_DATA(nlh);
	struct iscsi_stats *stats;
	struct sk_buff *skbstat;
	struct iscsi_cls_conn *conn;
	struct nlmsghdr	*nlhstat;
	struct iscsi_uevent *evstat;
1099
	struct iscsi_internal *priv;
1100 1101 1102 1103 1104
	int len = NLMSG_SPACE(sizeof(*ev) +
			      sizeof(struct iscsi_stats) +
			      sizeof(struct iscsi_stats_custom) *
			      ISCSI_STATS_CUSTOM_MAX);
	int err = 0;
1105

1106 1107 1108 1109
	priv = iscsi_if_transport_lookup(transport);
	if (!priv)
		return -EINVAL;

1110
	conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid);
1111 1112
	if (!conn)
		return -EEXIST;
1113

1114 1115
	do {
		int actual_size;
1116

1117
		skbstat = alloc_skb(len, GFP_ATOMIC);
1118
		if (!skbstat) {
1119 1120
			iscsi_cls_conn_printk(KERN_ERR, conn, "can not "
					      "deliver stats: OOM\n");
1121 1122 1123
			return -ENOMEM;
		}

1124
		nlhstat = __nlmsg_put(skbstat, priv->daemon_pid, 0, 0,
1125 1126 1127 1128 1129
				      (len - sizeof(*nlhstat)), 0);
		evstat = NLMSG_DATA(nlhstat);
		memset(evstat, 0, sizeof(*evstat));
		evstat->transport_handle = iscsi_handle(conn->transport);
		evstat->type = nlh->nlmsg_type;
1130 1131 1132 1133
		evstat->u.get_stats.cid =
			ev->u.get_stats.cid;
		evstat->u.get_stats.sid =
			ev->u.get_stats.sid;
1134 1135 1136 1137
		stats = (struct iscsi_stats *)
			((char*)evstat + sizeof(*evstat));
		memset(stats, 0, sizeof(*stats));

1138
		transport->get_stats(conn, stats);
1139 1140 1141 1142 1143 1144
		actual_size = NLMSG_SPACE(sizeof(struct iscsi_uevent) +
					  sizeof(struct iscsi_stats) +
					  sizeof(struct iscsi_stats_custom) *
					  stats->custom_length);
		actual_size -= sizeof(*nlhstat);
		actual_size = NLMSG_LENGTH(actual_size);
1145
		skb_trim(skbstat, NLMSG_ALIGN(actual_size));
1146 1147
		nlhstat->nlmsg_len = actual_size;

1148
		err = iscsi_unicast_skb(skbstat, priv->daemon_pid);
1149 1150 1151
	} while (err < 0 && err != -ECONNREFUSED);

	return err;
1152 1153
}

1154
/**
M
Mike Christie 已提交
1155 1156 1157
 * iscsi_session_event - send session destr. completion event
 * @session: iscsi class session
 * @event: type of event
1158
 */
M
Mike Christie 已提交
1159 1160
int iscsi_session_event(struct iscsi_cls_session *session,
			enum iscsi_uevent_e event)
1161 1162 1163 1164 1165 1166 1167 1168
{
	struct iscsi_internal *priv;
	struct Scsi_Host *shost;
	struct iscsi_uevent *ev;
	struct sk_buff  *skb;
	struct nlmsghdr *nlh;
	int rc, len = NLMSG_SPACE(sizeof(*ev));

M
Mike Christie 已提交
1169
	priv = iscsi_if_transport_lookup(session->transport);
1170 1171 1172 1173
	if (!priv)
		return -EINVAL;
	shost = iscsi_session_to_shost(session);

1174
	skb = alloc_skb(len, GFP_KERNEL);
1175
	if (!skb) {
1176 1177 1178
		iscsi_cls_session_printk(KERN_ERR, session,
					 "Cannot notify userspace of session "
					 "event %u\n", event);
1179 1180 1181 1182 1183
		return -ENOMEM;
	}

	nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
	ev = NLMSG_DATA(nlh);
M
Mike Christie 已提交
1184
	ev->transport_handle = iscsi_handle(session->transport);
1185

M
Mike Christie 已提交
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
	ev->type = event;
	switch (event) {
	case ISCSI_KEVENT_DESTROY_SESSION:
		ev->r.d_session.host_no = shost->host_no;
		ev->r.d_session.sid = session->sid;
		break;
	case ISCSI_KEVENT_CREATE_SESSION:
		ev->r.c_session_ret.host_no = shost->host_no;
		ev->r.c_session_ret.sid = session->sid;
		break;
	case ISCSI_KEVENT_UNBIND_SESSION:
		ev->r.unbind_session.host_no = shost->host_no;
		ev->r.unbind_session.sid = session->sid;
		break;
	default:
1201 1202
		iscsi_cls_session_printk(KERN_ERR, session, "Invalid event "
					 "%u.\n", event);
M
Mike Christie 已提交
1203
		kfree_skb(skb);
1204 1205 1206 1207 1208 1209 1210
		return -EINVAL;
	}

	/*
	 * this will occur if the daemon is not up, so we just warn
	 * the user and when the daemon is restarted it will handle it
	 */
1211
	rc = iscsi_broadcast_skb(skb, GFP_KERNEL);
1212
	if (rc < 0)
1213 1214 1215 1216
		iscsi_cls_session_printk(KERN_ERR, session,
					 "Cannot notify userspace of session "
					 "event %u. Check iscsi daemon\n",
					 event);
1217 1218
	return rc;
}
M
Mike Christie 已提交
1219
EXPORT_SYMBOL_GPL(iscsi_session_event);
1220

1221
static int
1222 1223
iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_endpoint *ep,
			struct iscsi_uevent *ev, uint32_t initial_cmdsn,
1224
			uint16_t cmds_max, uint16_t queue_depth)
1225 1226
{
	struct iscsi_transport *transport = priv->iscsi_transport;
1227
	struct iscsi_cls_session *session;
1228
	uint32_t host_no;
1229

1230
	session = transport->create_session(ep, cmds_max, queue_depth,
1231
					    initial_cmdsn, &host_no);
1232
	if (!session)
1233
		return -ENOMEM;
1234

1235
	ev->r.c_session_ret.host_no = host_no;
1236
	ev->r.c_session_ret.sid = session->sid;
1237 1238 1239 1240
	return 0;
}

static int
1241
iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
1242
{
1243
	struct iscsi_cls_conn *conn;
1244
	struct iscsi_cls_session *session;
1245

1246 1247
	session = iscsi_session_lookup(ev->u.c_conn.sid);
	if (!session) {
1248
		printk(KERN_ERR "iscsi: invalid session %d.\n",
1249
		       ev->u.c_conn.sid);
1250
		return -EINVAL;
1251
	}
1252

1253
	conn = transport->create_conn(session, ev->u.c_conn.cid);
1254
	if (!conn) {
1255 1256
		iscsi_cls_session_printk(KERN_ERR, session,
					 "couldn't create a new connection.");
1257
		return -ENOMEM;
1258
	}
1259

1260 1261
	ev->r.c_conn_ret.sid = session->sid;
	ev->r.c_conn_ret.cid = conn->cid;
1262
	return 0;
L
Linus Torvalds 已提交
1263 1264
}

1265 1266 1267
static int
iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
{
1268
	struct iscsi_cls_conn *conn;
1269

1270
	conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid);
1271
	if (!conn)
1272
		return -EINVAL;
1273

1274 1275 1276
	if (transport->destroy_conn)
		transport->destroy_conn(conn);
	return 0;
1277 1278
}

1279 1280 1281 1282 1283 1284
static int
iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev)
{
	char *data = (char*)ev + sizeof(*ev);
	struct iscsi_cls_conn *conn;
	struct iscsi_cls_session *session;
1285
	int err = 0, value = 0;
1286 1287 1288 1289 1290 1291 1292

	session = iscsi_session_lookup(ev->u.set_param.sid);
	conn = iscsi_conn_lookup(ev->u.set_param.sid, ev->u.set_param.cid);
	if (!conn || !session)
		return -EINVAL;

	switch (ev->u.set_param.param) {
M
Mike Christie 已提交
1293
	case ISCSI_PARAM_SESS_RECOVERY_TMO:
1294
		sscanf(data, "%d", &value);
M
Mike Christie 已提交
1295 1296 1297
		if (value != 0)
			session->recovery_tmo = value;
		break;
1298
	default:
1299 1300
		err = transport->set_param(conn, ev->u.set_param.param,
					   data, ev->u.set_param.len);
1301 1302 1303 1304 1305
	}

	return err;
}

1306 1307 1308 1309
static int
iscsi_if_transport_ep(struct iscsi_transport *transport,
		      struct iscsi_uevent *ev, int msg_type)
{
1310
	struct iscsi_endpoint *ep;
1311 1312 1313 1314 1315 1316 1317 1318 1319
	struct sockaddr *dst_addr;
	int rc = 0;

	switch (msg_type) {
	case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
		if (!transport->ep_connect)
			return -EINVAL;

		dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
1320 1321 1322 1323 1324 1325
		ep = transport->ep_connect(dst_addr,
					   ev->u.ep_connect.non_blocking);
		if (IS_ERR(ep))
			return PTR_ERR(ep);

		ev->r.ep_connect_ret.handle = ep->id;
1326 1327 1328 1329 1330
		break;
	case ISCSI_UEVENT_TRANSPORT_EP_POLL:
		if (!transport->ep_poll)
			return -EINVAL;

1331 1332 1333 1334 1335
		ep = iscsi_lookup_endpoint(ev->u.ep_poll.ep_handle);
		if (!ep)
			return -EINVAL;

		ev->r.retcode = transport->ep_poll(ep,
1336 1337 1338 1339 1340 1341
						   ev->u.ep_poll.timeout_ms);
		break;
	case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
		if (!transport->ep_disconnect)
			return -EINVAL;

1342 1343 1344 1345 1346
		ep = iscsi_lookup_endpoint(ev->u.ep_disconnect.ep_handle);
		if (!ep)
			return -EINVAL;

		transport->ep_disconnect(ep);
1347 1348 1349 1350 1351
		break;
	}
	return rc;
}

1352 1353 1354 1355
static int
iscsi_tgt_dscvr(struct iscsi_transport *transport,
		struct iscsi_uevent *ev)
{
1356
	struct Scsi_Host *shost;
1357
	struct sockaddr *dst_addr;
1358
	int err;
1359 1360 1361 1362

	if (!transport->tgt_dscvr)
		return -EINVAL;

1363
	shost = scsi_host_lookup(ev->u.tgt_dscvr.host_no);
1364
	if (!shost) {
1365 1366 1367 1368 1369 1370
		printk(KERN_ERR "target discovery could not find host no %u\n",
		       ev->u.tgt_dscvr.host_no);
		return -ENODEV;
	}


1371
	dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
1372 1373 1374 1375
	err = transport->tgt_dscvr(shost, ev->u.tgt_dscvr.type,
				   ev->u.tgt_dscvr.enable, dst_addr);
	scsi_host_put(shost);
	return err;
1376 1377
}

1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389
static int
iscsi_set_host_param(struct iscsi_transport *transport,
		     struct iscsi_uevent *ev)
{
	char *data = (char*)ev + sizeof(*ev);
	struct Scsi_Host *shost;
	int err;

	if (!transport->set_host_param)
		return -ENOSYS;

	shost = scsi_host_lookup(ev->u.set_host_param.host_no);
1390
	if (!shost) {
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
		printk(KERN_ERR "set_host_param could not find host no %u\n",
		       ev->u.set_host_param.host_no);
		return -ENODEV;
	}

	err = transport->set_host_param(shost, ev->u.set_host_param.param,
					data, ev->u.set_host_param.len);
	scsi_host_put(shost);
	return err;
}

1402 1403 1404 1405 1406 1407 1408
static int
iscsi_if_recv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
{
	int err = 0;
	struct iscsi_uevent *ev = NLMSG_DATA(nlh);
	struct iscsi_transport *transport = NULL;
	struct iscsi_internal *priv;
1409 1410
	struct iscsi_cls_session *session;
	struct iscsi_cls_conn *conn;
1411
	struct iscsi_endpoint *ep = NULL;
1412 1413 1414 1415 1416 1417

	priv = iscsi_if_transport_lookup(iscsi_ptr(ev->transport_handle));
	if (!priv)
		return -EINVAL;
	transport = priv->iscsi_transport;

1418 1419 1420
	if (!try_module_get(transport->owner))
		return -EINVAL;

1421 1422
	priv->daemon_pid = NETLINK_CREDS(skb)->pid;

1423 1424
	switch (nlh->nlmsg_type) {
	case ISCSI_UEVENT_CREATE_SESSION:
1425
		err = iscsi_if_create_session(priv, ep, ev,
1426 1427 1428 1429 1430
					      ev->u.c_session.initial_cmdsn,
					      ev->u.c_session.cmds_max,
					      ev->u.c_session.queue_depth);
		break;
	case ISCSI_UEVENT_CREATE_BOUND_SESSION:
1431
		ep = iscsi_lookup_endpoint(ev->u.c_bound_session.ep_handle);
1432 1433 1434 1435
		if (!ep) {
			err = -EINVAL;
			break;
		}
1436 1437

		err = iscsi_if_create_session(priv, ep, ev,
1438 1439 1440
					ev->u.c_bound_session.initial_cmdsn,
					ev->u.c_bound_session.cmds_max,
					ev->u.c_bound_session.queue_depth);
1441 1442
		break;
	case ISCSI_UEVENT_DESTROY_SESSION:
1443
		session = iscsi_session_lookup(ev->u.d_session.sid);
M
Mike Christie 已提交
1444
		if (session)
1445
			transport->destroy_session(session);
M
Mike Christie 已提交
1446 1447 1448 1449 1450 1451 1452 1453
		else
			err = -EINVAL;
		break;
	case ISCSI_UEVENT_UNBIND_SESSION:
		session = iscsi_session_lookup(ev->u.d_session.sid);
		if (session)
			iscsi_unbind_session(session);
		else
1454
			err = -EINVAL;
1455 1456 1457 1458 1459 1460 1461 1462
		break;
	case ISCSI_UEVENT_CREATE_CONN:
		err = iscsi_if_create_conn(transport, ev);
		break;
	case ISCSI_UEVENT_DESTROY_CONN:
		err = iscsi_if_destroy_conn(transport, ev);
		break;
	case ISCSI_UEVENT_BIND_CONN:
1463 1464
		session = iscsi_session_lookup(ev->u.b_conn.sid);
		conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid);
1465 1466 1467

		if (session && conn)
			ev->r.retcode =	transport->bind_conn(session, conn,
1468
					ev->u.b_conn.transport_eph,
1469 1470 1471
					ev->u.b_conn.is_leading);
		else
			err = -EINVAL;
1472 1473
		break;
	case ISCSI_UEVENT_SET_PARAM:
1474
		err = iscsi_set_param(transport, ev);
1475 1476
		break;
	case ISCSI_UEVENT_START_CONN:
1477
		conn = iscsi_conn_lookup(ev->u.start_conn.sid, ev->u.start_conn.cid);
1478 1479 1480 1481
		if (conn)
			ev->r.retcode = transport->start_conn(conn);
		else
			err = -EINVAL;
1482 1483
		break;
	case ISCSI_UEVENT_STOP_CONN:
1484
		conn = iscsi_conn_lookup(ev->u.stop_conn.sid, ev->u.stop_conn.cid);
1485 1486 1487 1488
		if (conn)
			transport->stop_conn(conn, ev->u.stop_conn.flag);
		else
			err = -EINVAL;
1489 1490
		break;
	case ISCSI_UEVENT_SEND_PDU:
1491
		conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid);
1492 1493 1494 1495 1496 1497 1498
		if (conn)
			ev->r.retcode =	transport->send_pdu(conn,
				(struct iscsi_hdr*)((char*)ev + sizeof(*ev)),
				(char*)ev + sizeof(*ev) + ev->u.send_pdu.hdr_size,
				ev->u.send_pdu.data_size);
		else
			err = -EINVAL;
1499 1500
		break;
	case ISCSI_UEVENT_GET_STATS:
1501
		err = iscsi_if_get_stats(transport, nlh);
1502
		break;
1503 1504 1505 1506 1507
	case ISCSI_UEVENT_TRANSPORT_EP_CONNECT:
	case ISCSI_UEVENT_TRANSPORT_EP_POLL:
	case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
		err = iscsi_if_transport_ep(transport, ev, nlh->nlmsg_type);
		break;
1508 1509 1510
	case ISCSI_UEVENT_TGT_DSCVR:
		err = iscsi_tgt_dscvr(transport, ev);
		break;
1511 1512 1513
	case ISCSI_UEVENT_SET_HOST_PARAM:
		err = iscsi_set_host_param(transport, ev);
		break;
1514
	default:
1515
		err = -ENOSYS;
1516 1517 1518
		break;
	}

1519
	module_put(transport->owner);
1520 1521 1522
	return err;
}

1523
/*
1524 1525
 * Get message from skb.  Each message is processed by iscsi_if_recv_msg.
 * Malformed skbs with wrong lengths or invalid creds are not processed.
1526
 */
1527
static void
1528
iscsi_if_rx(struct sk_buff *skb)
1529
{
1530
	mutex_lock(&rx_queue_mutex);
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540
	while (skb->len >= NLMSG_SPACE(0)) {
		int err;
		uint32_t rlen;
		struct nlmsghdr	*nlh;
		struct iscsi_uevent *ev;

		nlh = nlmsg_hdr(skb);
		if (nlh->nlmsg_len < sizeof(*nlh) ||
		    skb->len < nlh->nlmsg_len) {
			break;
1541 1542
		}

1543 1544 1545 1546
		ev = NLMSG_DATA(nlh);
		rlen = NLMSG_ALIGN(nlh->nlmsg_len);
		if (rlen > skb->len)
			rlen = skb->len;
1547

1548 1549 1550 1551
		err = iscsi_if_recv_msg(skb, nlh);
		if (err) {
			ev->type = ISCSI_KEVENT_IF_ERROR;
			ev->iferror = err;
1552
		}
1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566
		do {
			/*
			 * special case for GET_STATS:
			 * on success - sending reply and stats from
			 * inside of if_recv_msg(),
			 * on error - fall through.
			 */
			if (ev->type == ISCSI_UEVENT_GET_STATS && !err)
				break;
			err = iscsi_if_send_reply(
				NETLINK_CREDS(skb)->pid, nlh->nlmsg_seq,
				nlh->nlmsg_type, 0, 0, ev, sizeof(*ev));
		} while (err < 0 && err != -ECONNREFUSED);
		skb_pull(skb, rlen);
1567
	}
1568
	mutex_unlock(&rx_queue_mutex);
1569
}
L
Linus Torvalds 已提交
1570

1571
#define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store)		\
1572
struct device_attribute dev_attr_##_prefix##_##_name =	\
1573 1574
	__ATTR(_name,_mode,_show,_store)

L
Linus Torvalds 已提交
1575
/*
1576
 * iSCSI connection attrs
L
Linus Torvalds 已提交
1577
 */
1578
#define iscsi_conn_attr_show(param)					\
1579
static ssize_t								\
1580 1581
show_conn_param_##param(struct device *dev, 				\
			struct device_attribute *attr, char *buf)	\
1582
{									\
1583
	struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent);	\
1584
	struct iscsi_transport *t = conn->transport;			\
1585
	return t->get_conn_param(conn, param, buf);			\
1586 1587
}

1588 1589 1590
#define iscsi_conn_attr(field, param)					\
	iscsi_conn_attr_show(param)					\
static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param,	\
1591
			NULL);
1592

1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603
iscsi_conn_attr(max_recv_dlength, ISCSI_PARAM_MAX_RECV_DLENGTH);
iscsi_conn_attr(max_xmit_dlength, ISCSI_PARAM_MAX_XMIT_DLENGTH);
iscsi_conn_attr(header_digest, ISCSI_PARAM_HDRDGST_EN);
iscsi_conn_attr(data_digest, ISCSI_PARAM_DATADGST_EN);
iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN);
iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN);
iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT);
iscsi_conn_attr(port, ISCSI_PARAM_CONN_PORT);
iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN);
iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS);
iscsi_conn_attr(address, ISCSI_PARAM_CONN_ADDRESS);
1604 1605
iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);
iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);
L
Linus Torvalds 已提交
1606 1607

/*
1608
 * iSCSI session attrs
L
Linus Torvalds 已提交
1609
 */
1610
#define iscsi_session_attr_show(param, perm)				\
1611
static ssize_t								\
1612 1613
show_session_param_##param(struct device *dev,				\
			   struct device_attribute *attr, char *buf)	\
1614
{									\
1615 1616
	struct iscsi_cls_session *session = 				\
		iscsi_dev_to_session(dev->parent);			\
1617
	struct iscsi_transport *t = session->transport;			\
1618 1619 1620
									\
	if (perm && !capable(CAP_SYS_ADMIN))				\
		return -EACCES;						\
1621
	return t->get_session_param(session, param, buf);		\
1622 1623
}

1624 1625
#define iscsi_session_attr(field, param, perm)				\
	iscsi_session_attr_show(param, perm)				\
1626
static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
1627 1628
			NULL);

1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642
iscsi_session_attr(targetname, ISCSI_PARAM_TARGET_NAME, 0);
iscsi_session_attr(initial_r2t, ISCSI_PARAM_INITIAL_R2T_EN, 0);
iscsi_session_attr(max_outstanding_r2t, ISCSI_PARAM_MAX_R2T, 0);
iscsi_session_attr(immediate_data, ISCSI_PARAM_IMM_DATA_EN, 0);
iscsi_session_attr(first_burst_len, ISCSI_PARAM_FIRST_BURST, 0);
iscsi_session_attr(max_burst_len, ISCSI_PARAM_MAX_BURST, 0);
iscsi_session_attr(data_pdu_in_order, ISCSI_PARAM_PDU_INORDER_EN, 0);
iscsi_session_attr(data_seq_in_order, ISCSI_PARAM_DATASEQ_INORDER_EN, 0);
iscsi_session_attr(erl, ISCSI_PARAM_ERL, 0);
iscsi_session_attr(tpgt, ISCSI_PARAM_TPGT, 0);
iscsi_session_attr(username, ISCSI_PARAM_USERNAME, 1);
iscsi_session_attr(username_in, ISCSI_PARAM_USERNAME_IN, 1);
iscsi_session_attr(password, ISCSI_PARAM_PASSWORD, 1);
iscsi_session_attr(password_in, ISCSI_PARAM_PASSWORD_IN, 1);
1643 1644 1645
iscsi_session_attr(fast_abort, ISCSI_PARAM_FAST_ABORT, 0);
iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0);
iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0);
1646 1647
iscsi_session_attr(ifacename, ISCSI_PARAM_IFACE_NAME, 0);
iscsi_session_attr(initiatorname, ISCSI_PARAM_INITIATOR_NAME, 0)
L
Linus Torvalds 已提交
1648

1649
static ssize_t
1650 1651
show_priv_session_state(struct device *dev, struct device_attribute *attr,
			char *buf)
1652
{
1653
	struct iscsi_cls_session *session = iscsi_dev_to_session(dev->parent);
1654 1655 1656 1657 1658
	return sprintf(buf, "%s\n", iscsi_session_state_name(session->state));
}
static ISCSI_CLASS_ATTR(priv_sess, state, S_IRUGO, show_priv_session_state,
			NULL);

1659 1660
#define iscsi_priv_session_attr_show(field, format)			\
static ssize_t								\
1661 1662
show_priv_session_##field(struct device *dev, 				\
			  struct device_attribute *attr, char *buf)	\
1663
{									\
1664 1665
	struct iscsi_cls_session *session = 				\
			iscsi_dev_to_session(dev->parent);		\
1666 1667 1668 1669 1670 1671 1672
	return sprintf(buf, format"\n", session->field);		\
}

#define iscsi_priv_session_attr(field, format)				\
	iscsi_priv_session_attr_show(field, format)			\
static ISCSI_CLASS_ATTR(priv_sess, field, S_IRUGO, show_priv_session_##field, \
			NULL)
M
Mike Christie 已提交
1673
iscsi_priv_session_attr(recovery_tmo, "%d");
1674

1675 1676 1677 1678 1679
/*
 * iSCSI host attrs
 */
#define iscsi_host_attr_show(param)					\
static ssize_t								\
1680 1681
show_host_param_##param(struct device *dev, 				\
			struct device_attribute *attr, char *buf)	\
1682
{									\
1683
	struct Scsi_Host *shost = transport_class_to_shost(dev);	\
1684 1685 1686 1687 1688 1689 1690 1691 1692
	struct iscsi_internal *priv = to_iscsi_internal(shost->transportt); \
	return priv->iscsi_transport->get_host_param(shost, param, buf); \
}

#define iscsi_host_attr(field, param)					\
	iscsi_host_attr_show(param)					\
static ISCSI_CLASS_ATTR(host, field, S_IRUGO, show_host_param_##param,	\
			NULL);

1693
iscsi_host_attr(netdev, ISCSI_HOST_PARAM_NETDEV_NAME);
1694
iscsi_host_attr(hwaddress, ISCSI_HOST_PARAM_HWADDRESS);
1695
iscsi_host_attr(ipaddress, ISCSI_HOST_PARAM_IPADDRESS);
1696
iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME);
1697

1698 1699
#define SETUP_PRIV_SESSION_RD_ATTR(field)				\
do {									\
1700
	priv->session_attrs[count] = &dev_attr_priv_sess_##field; \
1701 1702 1703
	count++;							\
} while (0)

1704

1705 1706 1707
#define SETUP_SESSION_RD_ATTR(field, param_flag)			\
do {									\
	if (tt->param_mask & param_flag) {				\
1708
		priv->session_attrs[count] = &dev_attr_sess_##field; \
L
Linus Torvalds 已提交
1709
		count++;						\
1710 1711 1712 1713 1714 1715
	}								\
} while (0)

#define SETUP_CONN_RD_ATTR(field, param_flag)				\
do {									\
	if (tt->param_mask & param_flag) {				\
1716
		priv->conn_attrs[count] = &dev_attr_conn_##field; \
1717 1718 1719
		count++;						\
	}								\
} while (0)
L
Linus Torvalds 已提交
1720

1721 1722 1723
#define SETUP_HOST_RD_ATTR(field, param_flag)				\
do {									\
	if (tt->host_param_mask & param_flag) {				\
1724
		priv->host_attrs[count] = &dev_attr_host_##field; \
1725 1726 1727 1728
		count++;						\
	}								\
} while (0)

1729 1730
static int iscsi_session_match(struct attribute_container *cont,
			   struct device *dev)
L
Linus Torvalds 已提交
1731
{
1732
	struct iscsi_cls_session *session;
L
Linus Torvalds 已提交
1733
	struct Scsi_Host *shost;
1734 1735 1736 1737
	struct iscsi_internal *priv;

	if (!iscsi_is_session_dev(dev))
		return 0;
L
Linus Torvalds 已提交
1738

1739 1740
	session = iscsi_dev_to_session(dev);
	shost = iscsi_session_to_shost(session);
1741
	if (!shost->transportt)
L
Linus Torvalds 已提交
1742 1743
		return 0;

1744 1745
	priv = to_iscsi_internal(shost->transportt);
	if (priv->session_cont.ac.class != &iscsi_session_class.class)
L
Linus Torvalds 已提交
1746 1747
		return 0;

1748
	return &priv->session_cont.ac == cont;
L
Linus Torvalds 已提交
1749 1750
}

1751 1752 1753
static int iscsi_conn_match(struct attribute_container *cont,
			   struct device *dev)
{
1754 1755
	struct iscsi_cls_session *session;
	struct iscsi_cls_conn *conn;
L
Linus Torvalds 已提交
1756
	struct Scsi_Host *shost;
1757
	struct iscsi_internal *priv;
L
Linus Torvalds 已提交
1758

1759
	if (!iscsi_is_conn_dev(dev))
L
Linus Torvalds 已提交
1760 1761
		return 0;

1762 1763 1764 1765
	conn = iscsi_dev_to_conn(dev);
	session = iscsi_dev_to_session(conn->dev.parent);
	shost = iscsi_session_to_shost(session);

1766
	if (!shost->transportt)
L
Linus Torvalds 已提交
1767 1768
		return 0;

1769 1770 1771
	priv = to_iscsi_internal(shost->transportt);
	if (priv->conn_cont.ac.class != &iscsi_connection_class.class)
		return 0;
L
Linus Torvalds 已提交
1772

1773 1774 1775
	return &priv->conn_cont.ac == cont;
}

M
Mike Christie 已提交
1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
static int iscsi_host_match(struct attribute_container *cont,
			    struct device *dev)
{
	struct Scsi_Host *shost;
	struct iscsi_internal *priv;

	if (!scsi_is_host_device(dev))
		return 0;

	shost = dev_to_shost(dev);
	if (!shost->transportt  ||
	    shost->transportt->host_attrs.ac.class != &iscsi_host_class.class)
		return 0;

        priv = to_iscsi_internal(shost->transportt);
        return &priv->t.host_attrs.ac == cont;
}

1794 1795
struct scsi_transport_template *
iscsi_register_transport(struct iscsi_transport *tt)
1796 1797 1798 1799 1800 1801 1802 1803 1804
{
	struct iscsi_internal *priv;
	unsigned long flags;
	int count = 0, err;

	BUG_ON(!tt);

	priv = iscsi_if_transport_lookup(tt);
	if (priv)
1805
		return NULL;
1806

J
Jes Sorensen 已提交
1807
	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1808
	if (!priv)
1809
		return NULL;
1810
	INIT_LIST_HEAD(&priv->list);
1811
	priv->daemon_pid = -1;
1812
	priv->iscsi_transport = tt;
M
Mike Christie 已提交
1813
	priv->t.user_scan = iscsi_user_scan;
1814 1815
	if (!(tt->caps & CAP_DATA_PATH_OFFLOAD))
		priv->t.create_work_queue = 1;
1816

1817 1818 1819
	priv->dev.class = &iscsi_transport_class;
	snprintf(priv->dev.bus_id, BUS_ID_SIZE, "%s", tt->name);
	err = device_register(&priv->dev);
1820 1821 1822
	if (err)
		goto free_priv;

1823
	err = sysfs_create_group(&priv->dev.kobj, &iscsi_transport_group);
1824
	if (err)
1825
		goto unregister_dev;
1826

M
Mike Christie 已提交
1827 1828 1829 1830
	/* host parameters */
	priv->t.host_attrs.ac.attrs = &priv->host_attrs[0];
	priv->t.host_attrs.ac.class = &iscsi_host_class.class;
	priv->t.host_attrs.ac.match = iscsi_host_match;
1831
	priv->t.host_size = sizeof(struct iscsi_cls_host);
M
Mike Christie 已提交
1832 1833
	transport_container_register(&priv->t.host_attrs);

1834
	SETUP_HOST_RD_ATTR(netdev, ISCSI_HOST_NETDEV_NAME);
1835
	SETUP_HOST_RD_ATTR(ipaddress, ISCSI_HOST_IPADDRESS);
1836
	SETUP_HOST_RD_ATTR(hwaddress, ISCSI_HOST_HWADDRESS);
1837
	SETUP_HOST_RD_ATTR(initiatorname, ISCSI_HOST_INITIATOR_NAME);
1838 1839 1840 1841
	BUG_ON(count > ISCSI_HOST_ATTRS);
	priv->host_attrs[count] = NULL;
	count = 0;

1842 1843 1844 1845 1846
	/* connection parameters */
	priv->conn_cont.ac.attrs = &priv->conn_attrs[0];
	priv->conn_cont.ac.class = &iscsi_connection_class.class;
	priv->conn_cont.ac.match = iscsi_conn_match;
	transport_container_register(&priv->conn_cont);
L
Linus Torvalds 已提交
1847

1848 1849 1850 1851 1852 1853 1854 1855
	SETUP_CONN_RD_ATTR(max_recv_dlength, ISCSI_MAX_RECV_DLENGTH);
	SETUP_CONN_RD_ATTR(max_xmit_dlength, ISCSI_MAX_XMIT_DLENGTH);
	SETUP_CONN_RD_ATTR(header_digest, ISCSI_HDRDGST_EN);
	SETUP_CONN_RD_ATTR(data_digest, ISCSI_DATADGST_EN);
	SETUP_CONN_RD_ATTR(ifmarker, ISCSI_IFMARKER_EN);
	SETUP_CONN_RD_ATTR(ofmarker, ISCSI_OFMARKER_EN);
	SETUP_CONN_RD_ATTR(address, ISCSI_CONN_ADDRESS);
	SETUP_CONN_RD_ATTR(port, ISCSI_CONN_PORT);
1856
	SETUP_CONN_RD_ATTR(exp_statsn, ISCSI_EXP_STATSN);
1857 1858
	SETUP_CONN_RD_ATTR(persistent_address, ISCSI_PERSISTENT_ADDRESS);
	SETUP_CONN_RD_ATTR(persistent_port, ISCSI_PERSISTENT_PORT);
1859 1860
	SETUP_CONN_RD_ATTR(ping_tmo, ISCSI_PING_TMO);
	SETUP_CONN_RD_ATTR(recv_tmo, ISCSI_RECV_TMO);
1861 1862 1863

	BUG_ON(count > ISCSI_CONN_ATTRS);
	priv->conn_attrs[count] = NULL;
L
Linus Torvalds 已提交
1864 1865
	count = 0;

1866 1867 1868 1869 1870 1871
	/* session parameters */
	priv->session_cont.ac.attrs = &priv->session_attrs[0];
	priv->session_cont.ac.class = &iscsi_session_class.class;
	priv->session_cont.ac.match = iscsi_session_match;
	transport_container_register(&priv->session_cont);

1872 1873 1874 1875 1876 1877 1878 1879
	SETUP_SESSION_RD_ATTR(initial_r2t, ISCSI_INITIAL_R2T_EN);
	SETUP_SESSION_RD_ATTR(max_outstanding_r2t, ISCSI_MAX_R2T);
	SETUP_SESSION_RD_ATTR(immediate_data, ISCSI_IMM_DATA_EN);
	SETUP_SESSION_RD_ATTR(first_burst_len, ISCSI_FIRST_BURST);
	SETUP_SESSION_RD_ATTR(max_burst_len, ISCSI_MAX_BURST);
	SETUP_SESSION_RD_ATTR(data_pdu_in_order, ISCSI_PDU_INORDER_EN);
	SETUP_SESSION_RD_ATTR(data_seq_in_order, ISCSI_DATASEQ_INORDER_EN);
	SETUP_SESSION_RD_ATTR(erl, ISCSI_ERL);
1880 1881
	SETUP_SESSION_RD_ATTR(targetname, ISCSI_TARGET_NAME);
	SETUP_SESSION_RD_ATTR(tpgt, ISCSI_TPGT);
1882 1883 1884 1885
	SETUP_SESSION_RD_ATTR(password, ISCSI_USERNAME);
	SETUP_SESSION_RD_ATTR(password_in, ISCSI_USERNAME_IN);
	SETUP_SESSION_RD_ATTR(username, ISCSI_PASSWORD);
	SETUP_SESSION_RD_ATTR(username_in, ISCSI_PASSWORD_IN);
1886
	SETUP_SESSION_RD_ATTR(fast_abort, ISCSI_FAST_ABORT);
1887 1888
	SETUP_SESSION_RD_ATTR(abort_tmo, ISCSI_ABORT_TMO);
	SETUP_SESSION_RD_ATTR(lu_reset_tmo,ISCSI_LU_RESET_TMO);
1889 1890
	SETUP_SESSION_RD_ATTR(ifacename, ISCSI_IFACE_NAME);
	SETUP_SESSION_RD_ATTR(initiatorname, ISCSI_INITIATOR_NAME);
M
Mike Christie 已提交
1891
	SETUP_PRIV_SESSION_RD_ATTR(recovery_tmo);
1892
	SETUP_PRIV_SESSION_RD_ATTR(state);
1893

1894 1895 1896 1897 1898 1899 1900 1901
	BUG_ON(count > ISCSI_SESSION_ATTRS);
	priv->session_attrs[count] = NULL;

	spin_lock_irqsave(&iscsi_transport_lock, flags);
	list_add(&priv->list, &iscsi_transports);
	spin_unlock_irqrestore(&iscsi_transport_lock, flags);

	printk(KERN_NOTICE "iscsi: registered transport (%s)\n", tt->name);
1902
	return &priv->t;
L
Linus Torvalds 已提交
1903

1904 1905
unregister_dev:
	device_unregister(&priv->dev);
1906
	return NULL;
1907 1908
free_priv:
	kfree(priv);
1909
	return NULL;
L
Linus Torvalds 已提交
1910
}
1911 1912 1913 1914 1915 1916 1917 1918 1919
EXPORT_SYMBOL_GPL(iscsi_register_transport);

int iscsi_unregister_transport(struct iscsi_transport *tt)
{
	struct iscsi_internal *priv;
	unsigned long flags;

	BUG_ON(!tt);

1920
	mutex_lock(&rx_queue_mutex);
1921 1922 1923 1924 1925 1926 1927 1928 1929 1930

	priv = iscsi_if_transport_lookup(tt);
	BUG_ON (!priv);

	spin_lock_irqsave(&iscsi_transport_lock, flags);
	list_del(&priv->list);
	spin_unlock_irqrestore(&iscsi_transport_lock, flags);

	transport_container_unregister(&priv->conn_cont);
	transport_container_unregister(&priv->session_cont);
M
Mike Christie 已提交
1931
	transport_container_unregister(&priv->t.host_attrs);
1932

1933 1934
	sysfs_remove_group(&priv->dev.kobj, &iscsi_transport_group);
	device_unregister(&priv->dev);
1935
	mutex_unlock(&rx_queue_mutex);
L
Linus Torvalds 已提交
1936

1937 1938 1939
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
L
Linus Torvalds 已提交
1940 1941 1942

static __init int iscsi_transport_init(void)
{
1943
	int err;
L
Linus Torvalds 已提交
1944

M
Meelis Roos 已提交
1945
	printk(KERN_INFO "Loading iSCSI transport class v%s.\n",
1946 1947
		ISCSI_TRANSPORT_VERSION);

1948 1949
	atomic_set(&iscsi_session_nr, 0);

1950
	err = class_register(&iscsi_transport_class);
L
Linus Torvalds 已提交
1951 1952
	if (err)
		return err;
1953

1954
	err = class_register(&iscsi_endpoint_class);
1955 1956 1957
	if (err)
		goto unregister_transport_class;

1958 1959 1960 1961
	err = transport_class_register(&iscsi_host_class);
	if (err)
		goto unregister_endpoint_class;

M
Mike Christie 已提交
1962 1963 1964 1965
	err = transport_class_register(&iscsi_connection_class);
	if (err)
		goto unregister_host_class;

1966 1967 1968 1969
	err = transport_class_register(&iscsi_session_class);
	if (err)
		goto unregister_conn_class;

1970 1971
	nls = netlink_kernel_create(&init_net, NETLINK_ISCSI, 1, iscsi_if_rx,
				    NULL, THIS_MODULE);
1972 1973
	if (!nls) {
		err = -ENOBUFS;
1974
		goto unregister_session_class;
1975 1976
	}

1977 1978 1979 1980
	iscsi_eh_timer_workq = create_singlethread_workqueue("iscsi_eh");
	if (!iscsi_eh_timer_workq)
		goto release_nls;

1981
	return 0;
1982

1983
release_nls:
1984
	netlink_kernel_release(nls);
1985 1986 1987 1988
unregister_session_class:
	transport_class_unregister(&iscsi_session_class);
unregister_conn_class:
	transport_class_unregister(&iscsi_connection_class);
M
Mike Christie 已提交
1989 1990
unregister_host_class:
	transport_class_unregister(&iscsi_host_class);
1991 1992
unregister_endpoint_class:
	class_unregister(&iscsi_endpoint_class);
1993 1994 1995
unregister_transport_class:
	class_unregister(&iscsi_transport_class);
	return err;
L
Linus Torvalds 已提交
1996 1997 1998 1999
}

static void __exit iscsi_transport_exit(void)
{
2000
	destroy_workqueue(iscsi_eh_timer_workq);
2001
	netlink_kernel_release(nls);
2002 2003
	transport_class_unregister(&iscsi_connection_class);
	transport_class_unregister(&iscsi_session_class);
M
Mike Christie 已提交
2004
	transport_class_unregister(&iscsi_host_class);
2005
	class_unregister(&iscsi_endpoint_class);
2006
	class_unregister(&iscsi_transport_class);
L
Linus Torvalds 已提交
2007 2008 2009 2010 2011
}

module_init(iscsi_transport_init);
module_exit(iscsi_transport_exit);

2012 2013 2014 2015
MODULE_AUTHOR("Mike Christie <michaelc@cs.wisc.edu>, "
	      "Dmitry Yusupov <dmitry_yus@yahoo.com>, "
	      "Alex Aizman <itn780@yahoo.com>");
MODULE_DESCRIPTION("iSCSI Transport Interface");
L
Linus Torvalds 已提交
2016
MODULE_LICENSE("GPL");
2017
MODULE_VERSION(ISCSI_TRANSPORT_VERSION);