scsi_transport_iscsi.c 45.9 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 19
34
#define ISCSI_CONN_ATTRS 11
35
#define ISCSI_HOST_ATTRS 4
M
Mike Christie 已提交
36
#define ISCSI_TRANSPORT_VERSION "2.0-867"
L
Linus Torvalds 已提交
37 38

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

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

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

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

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

#define cdev_to_iscsi_internal(_cdev) \
	container_of(_cdev, struct iscsi_internal, cdev)

static void iscsi_transport_release(struct class_device *cdev)
{
	struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
	kfree(priv);
}
L
Linus Torvalds 已提交
74

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

static ssize_t
show_transport_handle(struct class_device *cdev, char *buf)
{
	struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);
88
	return sprintf(buf, "%llu\n", (unsigned long long)iscsi_handle(priv->iscsi_transport));
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
}
static CLASS_DEVICE_ATTR(handle, S_IRUGO, show_transport_handle, NULL);

#define show_transport_attr(name, format)				\
static ssize_t								\
show_transport_##name(struct class_device *cdev, char *buf)		\
{									\
	struct iscsi_internal *priv = cdev_to_iscsi_internal(cdev);	\
	return sprintf(buf, format"\n", priv->iscsi_transport->name);	\
}									\
static CLASS_DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);

show_transport_attr(caps, "0x%x");
show_transport_attr(max_lun, "%d");
show_transport_attr(max_conn, "%d");
show_transport_attr(max_cmd_len, "%d");

static struct attribute *iscsi_transport_attrs[] = {
	&class_device_attr_handle.attr,
	&class_device_attr_caps.attr,
	&class_device_attr_max_lun.attr,
	&class_device_attr_max_conn.attr,
	&class_device_attr_max_cmd_len.attr,
	NULL,
};

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

M
Mike Christie 已提交
119 120


M
Mike Christie 已提交
121 122 123 124 125 126 127 128 129
static int iscsi_setup_host(struct transport_container *tc, struct device *dev,
			    struct class_device *cdev)
{
	struct Scsi_Host *shost = dev_to_shost(dev);
	struct iscsi_host *ihost = shost->shost_data;

	memset(ihost, 0, sizeof(*ihost));
	INIT_LIST_HEAD(&ihost->sessions);
	mutex_init(&ihost->mutex);
M
Mike Christie 已提交
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146

	snprintf(ihost->unbind_workq_name, KOBJ_NAME_LEN, "iscsi_unbind_%d",
		shost->host_no);
	ihost->unbind_workq = create_singlethread_workqueue(
						ihost->unbind_workq_name);
	if (!ihost->unbind_workq)
		return -ENOMEM;
	return 0;
}

static int iscsi_remove_host(struct transport_container *tc, struct device *dev,
			     struct class_device *cdev)
{
	struct Scsi_Host *shost = dev_to_shost(dev);
	struct iscsi_host *ihost = shost->shost_data;

	destroy_workqueue(ihost->unbind_workq);
M
Mike Christie 已提交
147 148 149 150 151 152
	return 0;
}

static DECLARE_TRANSPORT_CLASS(iscsi_host_class,
			       "iscsi_host",
			       iscsi_setup_host,
M
Mike Christie 已提交
153
			       iscsi_remove_host,
M
Mike Christie 已提交
154 155
			       NULL);

156 157
static DECLARE_TRANSPORT_CLASS(iscsi_session_class,
			       "iscsi_session",
L
Linus Torvalds 已提交
158 159 160 161
			       NULL,
			       NULL,
			       NULL);

162 163
static DECLARE_TRANSPORT_CLASS(iscsi_connection_class,
			       "iscsi_connection",
L
Linus Torvalds 已提交
164 165 166
			       NULL,
			       NULL,
			       NULL);
167 168

static struct sock *nls;
169
static DEFINE_MUTEX(rx_queue_mutex);
170

171 172
static LIST_HEAD(sesslist);
static DEFINE_SPINLOCK(sesslock);
173 174
static LIST_HEAD(connlist);
static DEFINE_SPINLOCK(connlock);
175

176 177 178 179 180 181 182 183 184 185
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)
186 187 188 189 190 191
{
	unsigned long flags;
	struct iscsi_cls_session *sess;

	spin_lock_irqsave(&sesslock, flags);
	list_for_each_entry(sess, &sesslist, sess_list) {
192
		if (sess->sid == sid) {
193 194 195 196 197 198 199 200
			spin_unlock_irqrestore(&sesslock, flags);
			return sess;
		}
	}
	spin_unlock_irqrestore(&sesslock, flags);
	return NULL;
}

201 202 203 204
/*
 * Returns the matching connection to a given sid / cid tuple
 */
static struct iscsi_cls_conn *iscsi_conn_lookup(uint32_t sid, uint32_t cid)
205 206 207 208 209 210
{
	unsigned long flags;
	struct iscsi_cls_conn *conn;

	spin_lock_irqsave(&connlock, flags);
	list_for_each_entry(conn, &connlist, conn_list) {
211
		if ((conn->cid == cid) && (iscsi_conn_get_sid(conn) == sid)) {
212 213 214 215 216 217 218 219
			spin_unlock_irqrestore(&connlock, flags);
			return conn;
		}
	}
	spin_unlock_irqrestore(&connlock, flags);
	return NULL;
}

220 221 222 223
/*
 * The following functions can be used by LLDs that allocate
 * their own scsi_hosts or by software iscsi LLDs
 */
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
static struct {
	int value;
	char *name;
} iscsi_session_state_names[] = {
	{ ISCSI_SESSION_LOGGED_IN,	"LOGGED_IN" },
	{ ISCSI_SESSION_FAILED,		"FAILED" },
	{ ISCSI_SESSION_FREE,		"FREE" },
};

const char *iscsi_session_state_name(int state)
{
	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:
		err = DID_IMM_RETRY << 16;
		break;
	case ISCSI_SESSION_FREE:
		err = DID_NO_CONNECT << 16;
		break;
	default:
		err = DID_NO_CONNECT << 16;
		break;
	}
	spin_unlock_irqrestore(&session->lock, flags);
	return err;
}
EXPORT_SYMBOL_GPL(iscsi_session_chkready);

272 273 274 275
static void iscsi_session_release(struct device *dev)
{
	struct iscsi_cls_session *session = iscsi_dev_to_session(dev);
	struct Scsi_Host *shost;
276

277 278 279 280
	shost = iscsi_session_to_shost(session);
	scsi_host_put(shost);
	kfree(session);
}
281

282 283 284 285
static int iscsi_is_session_dev(const struct device *dev)
{
	return dev->release == iscsi_session_release;
}
286

M
Mike Christie 已提交
287 288 289 290 291 292 293 294
static int iscsi_user_scan(struct Scsi_Host *shost, uint channel,
			   uint id, uint lun)
{
	struct iscsi_host *ihost = shost->shost_data;
	struct iscsi_cls_session *session;

	mutex_lock(&ihost->mutex);
	list_for_each_entry(session, &ihost->sessions, host_list) {
295
		if ((channel == SCAN_WILD_CARD || channel == 0) &&
M
Mike Christie 已提交
296
		    (id == SCAN_WILD_CARD || id == session->target_id))
297
			scsi_scan_target(&session->dev, 0,
M
Mike Christie 已提交
298 299 300 301 302 303 304
					 session->target_id, lun, 1);
	}
	mutex_unlock(&ihost->mutex);

	return 0;
}

D
David Howells 已提交
305
static void session_recovery_timedout(struct work_struct *work)
M
Mike Christie 已提交
306
{
D
David Howells 已提交
307 308 309
	struct iscsi_cls_session *session =
		container_of(work, struct iscsi_cls_session,
			     recovery_work.work);
310
	unsigned long flags;
M
Mike Christie 已提交
311

O
Or Gerlitz 已提交
312 313
	dev_printk(KERN_INFO, &session->dev, "iscsi: session recovery timed "
		  "out after %d secs\n", session->recovery_tmo);
M
Mike Christie 已提交
314

315 316 317 318 319 320 321 322 323 324 325 326 327
	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 已提交
328 329 330 331 332 333
	if (session->transport->session_recovery_timedout)
		session->transport->session_recovery_timedout(session);

	scsi_target_unblock(&session->dev);
}

334
void __iscsi_unblock_session(struct iscsi_cls_session *session)
M
Mike Christie 已提交
335 336
{
	if (!cancel_delayed_work(&session->recovery_work))
337
		flush_workqueue(iscsi_eh_timer_workq);
M
Mike Christie 已提交
338 339
	scsi_target_unblock(&session->dev);
}
340 341 342 343 344 345 346 347 348 349 350

void iscsi_unblock_session(struct iscsi_cls_session *session)
{
	unsigned long flags;

	spin_lock_irqsave(&session->lock, flags);
	session->state = ISCSI_SESSION_LOGGED_IN;
	spin_unlock_irqrestore(&session->lock, flags);

	__iscsi_unblock_session(session);
}
M
Mike Christie 已提交
351 352 353 354
EXPORT_SYMBOL_GPL(iscsi_unblock_session);

void iscsi_block_session(struct iscsi_cls_session *session)
{
355 356 357 358 359 360
	unsigned long flags;

	spin_lock_irqsave(&session->lock, flags);
	session->state = ISCSI_SESSION_FAILED;
	spin_unlock_irqrestore(&session->lock, flags);

M
Mike Christie 已提交
361
	scsi_target_block(&session->dev);
362 363
	queue_delayed_work(iscsi_eh_timer_workq, &session->recovery_work,
			   session->recovery_tmo * HZ);
M
Mike Christie 已提交
364 365 366
}
EXPORT_SYMBOL_GPL(iscsi_block_session);

M
Mike Christie 已提交
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
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);
	struct iscsi_host *ihost = shost->shost_data;

	/* Prevent new scans and make sure scanning is not in progress */
	mutex_lock(&ihost->mutex);
	if (list_empty(&session->host_list)) {
		mutex_unlock(&ihost->mutex);
		return;
	}
	list_del_init(&session->host_list);
	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);
	struct iscsi_host *ihost = shost->shost_data;

	return queue_work(ihost->unbind_workq, &session->unbind_work);
}

396
struct iscsi_cls_session *
397 398
iscsi_alloc_session(struct Scsi_Host *shost,
		    struct iscsi_transport *transport)
399 400 401
{
	struct iscsi_cls_session *session;

402 403
	session = kzalloc(sizeof(*session) + transport->sessiondata_size,
			  GFP_KERNEL);
404
	if (!session)
405 406
		return NULL;

407
	session->transport = transport;
M
Mike Christie 已提交
408
	session->recovery_tmo = 120;
409
	session->state = ISCSI_SESSION_FREE;
D
David Howells 已提交
410
	INIT_DELAYED_WORK(&session->recovery_work, session_recovery_timedout);
M
Mike Christie 已提交
411 412
	INIT_LIST_HEAD(&session->host_list);
	INIT_LIST_HEAD(&session->sess_list);
M
Mike Christie 已提交
413
	INIT_WORK(&session->unbind_work, __iscsi_unbind_session);
414
	spin_lock_init(&session->lock);
415

416 417
	/* this is released in the dev's release function */
	scsi_host_get(shost);
418 419 420
	session->dev.parent = &shost->shost_gendev;
	session->dev.release = iscsi_session_release;
	device_initialize(&session->dev);
421 422
	if (transport->sessiondata_size)
		session->dd_data = &session[1];
423 424 425 426
	return session;
}
EXPORT_SYMBOL_GPL(iscsi_alloc_session);

427
int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id)
428 429 430
{
	struct Scsi_Host *shost = iscsi_session_to_shost(session);
	struct iscsi_host *ihost;
M
Mike Christie 已提交
431
	unsigned long flags;
432
	int err;
433

M
Mike Christie 已提交
434
	ihost = shost->shost_data;
435
	session->sid = atomic_add_return(1, &iscsi_session_nr);
436
	session->target_id = target_id;
M
Mike Christie 已提交
437

438 439
	snprintf(session->dev.bus_id, BUS_ID_SIZE, "session%u",
		 session->sid);
440
	err = device_add(&session->dev);
441 442 443
	if (err) {
		dev_printk(KERN_ERR, &session->dev, "iscsi: could not "
			   "register session's dev\n");
444
		goto release_host;
445 446 447
	}
	transport_register_device(&session->dev);

M
Mike Christie 已提交
448 449 450 451
	spin_lock_irqsave(&sesslock, flags);
	list_add(&session->sess_list, &sesslist);
	spin_unlock_irqrestore(&sesslock, flags);

M
Mike Christie 已提交
452 453 454
	mutex_lock(&ihost->mutex);
	list_add(&session->host_list, &ihost->sessions);
	mutex_unlock(&ihost->mutex);
M
Mike Christie 已提交
455 456

	iscsi_session_event(session, ISCSI_KEVENT_CREATE_SESSION);
457
	return 0;
M
Mike Christie 已提交
458

459 460 461
release_host:
	scsi_host_put(shost);
	return err;
462
}
463
EXPORT_SYMBOL_GPL(iscsi_add_session);
464 465

/**
466 467 468
 * iscsi_create_session - create iscsi class session
 * @shost: scsi host
 * @transport: iscsi transport
469
 * @target_id: which target
470
 *
471
 * This can be called from a LLD or iscsi_transport.
472
 */
473 474
struct iscsi_cls_session *
iscsi_create_session(struct Scsi_Host *shost,
475 476
		     struct iscsi_transport *transport,
		     unsigned int target_id)
477 478 479 480 481 482 483
{
	struct iscsi_cls_session *session;

	session = iscsi_alloc_session(shost, transport);
	if (!session)
		return NULL;

484
	if (iscsi_add_session(session, target_id)) {
485 486 487 488 489 490 491
		iscsi_free_session(session);
		return NULL;
	}
	return session;
}
EXPORT_SYMBOL_GPL(iscsi_create_session);

M
Mike Christie 已提交
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
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));
}

513
void iscsi_remove_session(struct iscsi_cls_session *session)
514
{
M
Mike Christie 已提交
515 516
	struct Scsi_Host *shost = iscsi_session_to_shost(session);
	struct iscsi_host *ihost = shost->shost_data;
M
Mike Christie 已提交
517 518 519 520 521 522
	unsigned long flags;
	int err;

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

M
Mike Christie 已提交
524 525 526 527
	/*
	 * If we are blocked let commands flow again. The lld or iscsi
	 * layer should set up the queuecommand to fail commands.
	 */
528 529 530 531
	spin_lock_irqsave(&session->lock, flags);
	session->state = ISCSI_SESSION_FREE;
	spin_unlock_irqrestore(&session->lock, flags);
	__iscsi_unblock_session(session);
M
Mike Christie 已提交
532 533 534 535 536
	iscsi_unbind_session(session);
	/*
	 * If the session dropped while removing devices then we need to make
	 * sure it is not blocked
	 */
M
Mike Christie 已提交
537
	if (!cancel_delayed_work(&session->recovery_work))
538
		flush_workqueue(iscsi_eh_timer_workq);
M
Mike Christie 已提交
539
	flush_workqueue(ihost->unbind_workq);
M
Mike Christie 已提交
540

M
Mike Christie 已提交
541 542 543 544 545 546
	/* 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)
		dev_printk(KERN_ERR, &session->dev, "iscsi: Could not delete "
			   "all connections for session. Error %d.\n", err);
547

548
	transport_unregister_device(&session->dev);
549 550 551 552 553 554
	device_del(&session->dev);
}
EXPORT_SYMBOL_GPL(iscsi_remove_session);

void iscsi_free_session(struct iscsi_cls_session *session)
{
M
Mike Christie 已提交
555
	iscsi_session_event(session, ISCSI_KEVENT_DESTROY_SESSION);
556
	put_device(&session->dev);
557
}
558 559 560 561 562 563 564 565
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.
566
 */
567 568 569 570 571 572
int iscsi_destroy_session(struct iscsi_cls_session *session)
{
	iscsi_remove_session(session);
	iscsi_free_session(session);
	return 0;
}
573 574 575 576 577 578 579 580 581 582
EXPORT_SYMBOL_GPL(iscsi_destroy_session);

/**
 * iscsi_create_conn - create iscsi class connection
 * @session: iscsi cls session
 * @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.
583 584 585 586 587
 *
 * 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.
588
 */
589 590 591 592 593
struct iscsi_cls_conn *
iscsi_create_conn(struct iscsi_cls_session *session, uint32_t cid)
{
	struct iscsi_transport *transport = session->transport;
	struct iscsi_cls_conn *conn;
M
Mike Christie 已提交
594
	unsigned long flags;
595 596 597 598 599 600 601 602 603 604 605
	int err;

	conn = kzalloc(sizeof(*conn) + transport->conndata_size, GFP_KERNEL);
	if (!conn)
		return NULL;

	if (transport->conndata_size)
		conn->dd_data = &conn[1];

	INIT_LIST_HEAD(&conn->conn_list);
	conn->transport = transport;
606
	conn->cid = cid;
607 608 609

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

612
	snprintf(conn->dev.bus_id, BUS_ID_SIZE, "connection%d:%u",
613
		 session->sid, cid);
614 615 616 617 618 619 620 621 622
	conn->dev.parent = &session->dev;
	conn->dev.release = iscsi_conn_release;
	err = device_register(&conn->dev);
	if (err) {
		dev_printk(KERN_ERR, &conn->dev, "iscsi: could not register "
			   "connection's dev\n");
		goto release_parent_ref;
	}
	transport_register_device(&conn->dev);
M
Mike Christie 已提交
623 624 625 626 627

	spin_lock_irqsave(&connlock, flags);
	list_add(&conn->conn_list, &connlist);
	conn->active = 1;
	spin_unlock_irqrestore(&connlock, flags);
628 629 630 631 632 633 634 635 636 637 638 639 640
	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
641
 * @conn: iscsi cls session
642
 *
M
Mike Christie 已提交
643
 * This can be called from a LLD or iscsi_transport.
644
 */
645 646
int iscsi_destroy_conn(struct iscsi_cls_conn *conn)
{
M
Mike Christie 已提交
647 648 649 650 651 652 653
	unsigned long flags;

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

654 655 656 657 658 659 660 661 662
	transport_unregister_device(&conn->dev);
	device_unregister(&conn->dev);
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_destroy_conn);

/*
 * iscsi interface functions
 */
663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
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 已提交
679

680
static int
681
iscsi_broadcast_skb(struct sk_buff *skb, gfp_t gfp)
682 683 684
{
	int rc;

685
	rc = netlink_broadcast(nls, skb, 0, 1, gfp);
686 687 688 689 690 691 692 693
	if (rc < 0) {
		printk(KERN_ERR "iscsi: can not broadcast skb (%d)\n", rc);
		return rc;
	}

	return 0;
}

694
static int
695
iscsi_unicast_skb(struct sk_buff *skb, int pid)
696 697
{
	int rc;
L
Linus Torvalds 已提交
698

699
	rc = netlink_unicast(nls, skb, pid, MSG_DONTWAIT);
700 701 702 703 704 705
	if (rc < 0) {
		printk(KERN_ERR "iscsi: can not unicast skb (%d)\n", rc);
		return rc;
	}

	return 0;
L
Linus Torvalds 已提交
706 707
}

708
int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
709
		   char *data, uint32_t data_size)
L
Linus Torvalds 已提交
710
{
711 712 713 714
	struct nlmsghdr	*nlh;
	struct sk_buff *skb;
	struct iscsi_uevent *ev;
	char *pdu;
715
	struct iscsi_internal *priv;
716 717 718
	int len = NLMSG_SPACE(sizeof(*ev) + sizeof(struct iscsi_hdr) +
			      data_size);

719 720 721 722
	priv = iscsi_if_transport_lookup(conn->transport);
	if (!priv)
		return -EINVAL;

723
	skb = alloc_skb(len, GFP_ATOMIC);
724
	if (!skb) {
725
		iscsi_conn_error(conn, ISCSI_ERR_CONN_FAILED);
726 727
		dev_printk(KERN_ERR, &conn->dev, "iscsi: can not deliver "
			   "control PDU: OOM\n");
728 729
		return -ENOMEM;
	}
L
Linus Torvalds 已提交
730

731
	nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
732 733 734 735
	ev = NLMSG_DATA(nlh);
	memset(ev, 0, sizeof(*ev));
	ev->transport_handle = iscsi_handle(conn->transport);
	ev->type = ISCSI_KEVENT_RECV_PDU;
736 737
	ev->r.recv_req.cid = conn->cid;
	ev->r.recv_req.sid = iscsi_conn_get_sid(conn);
738 739 740
	pdu = (char*)ev + sizeof(*ev);
	memcpy(pdu, hdr, sizeof(struct iscsi_hdr));
	memcpy(pdu + sizeof(struct iscsi_hdr), data, data_size);
L
Linus Torvalds 已提交
741

742
	return iscsi_unicast_skb(skb, priv->daemon_pid);
L
Linus Torvalds 已提交
743
}
744
EXPORT_SYMBOL_GPL(iscsi_recv_pdu);
L
Linus Torvalds 已提交
745

746
void iscsi_conn_error(struct iscsi_cls_conn *conn, enum iscsi_err error)
L
Linus Torvalds 已提交
747
{
748
	struct iscsi_cls_session *session = iscsi_conn_to_session(conn);
749 750 751
	struct nlmsghdr	*nlh;
	struct sk_buff	*skb;
	struct iscsi_uevent *ev;
752
	struct iscsi_internal *priv;
753
	int len = NLMSG_SPACE(sizeof(*ev));
754
	unsigned long flags;
755

756 757 758 759
	priv = iscsi_if_transport_lookup(conn->transport);
	if (!priv)
		return;

760 761 762 763 764
	spin_lock_irqsave(&session->lock, flags);
	if (session->state == ISCSI_SESSION_LOGGED_IN)
		session->state = ISCSI_SESSION_FAILED;
	spin_unlock_irqrestore(&session->lock, flags);

765
	skb = alloc_skb(len, GFP_ATOMIC);
766
	if (!skb) {
767 768
		dev_printk(KERN_ERR, &conn->dev, "iscsi: gracefully ignored "
			  "conn error (%d)\n", error);
769 770 771
		return;
	}

772
	nlh = __nlmsg_put(skb, priv->daemon_pid, 0, 0, (len - sizeof(*nlh)), 0);
773 774 775 776
	ev = NLMSG_DATA(nlh);
	ev->transport_handle = iscsi_handle(conn->transport);
	ev->type = ISCSI_KEVENT_CONN_ERROR;
	ev->r.connerror.error = error;
777 778
	ev->r.connerror.cid = conn->cid;
	ev->r.connerror.sid = iscsi_conn_get_sid(conn);
L
Linus Torvalds 已提交
779

780
	iscsi_broadcast_skb(skb, GFP_ATOMIC);
L
Linus Torvalds 已提交
781

782 783
	dev_printk(KERN_INFO, &conn->dev, "iscsi: detected conn error (%d)\n",
		   error);
784 785 786 787 788 789 790 791 792 793 794 795 796
}
EXPORT_SYMBOL_GPL(iscsi_conn_error);

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;

797
	skb = alloc_skb(len, GFP_ATOMIC);
798 799 800 801
	if (!skb) {
		printk(KERN_ERR "Could not allocate skb to send reply.\n");
		return -ENOMEM;
	}
802 803 804 805

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

809
static int
810
iscsi_if_get_stats(struct iscsi_transport *transport, struct nlmsghdr *nlh)
811 812 813 814 815 816 817
{
	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;
818
	struct iscsi_internal *priv;
819 820 821 822 823
	int len = NLMSG_SPACE(sizeof(*ev) +
			      sizeof(struct iscsi_stats) +
			      sizeof(struct iscsi_stats_custom) *
			      ISCSI_STATS_CUSTOM_MAX);
	int err = 0;
824

825 826 827 828
	priv = iscsi_if_transport_lookup(transport);
	if (!priv)
		return -EINVAL;

829
	conn = iscsi_conn_lookup(ev->u.get_stats.sid, ev->u.get_stats.cid);
830 831
	if (!conn)
		return -EEXIST;
832

833 834
	do {
		int actual_size;
835

836
		skbstat = alloc_skb(len, GFP_ATOMIC);
837 838 839 840 841 842
		if (!skbstat) {
			dev_printk(KERN_ERR, &conn->dev, "iscsi: can not "
				   "deliver stats: OOM\n");
			return -ENOMEM;
		}

843
		nlhstat = __nlmsg_put(skbstat, priv->daemon_pid, 0, 0,
844 845 846 847 848
				      (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;
849 850 851 852
		evstat->u.get_stats.cid =
			ev->u.get_stats.cid;
		evstat->u.get_stats.sid =
			ev->u.get_stats.sid;
853 854 855 856
		stats = (struct iscsi_stats *)
			((char*)evstat + sizeof(*evstat));
		memset(stats, 0, sizeof(*stats));

857
		transport->get_stats(conn, stats);
858 859 860 861 862 863
		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);
864
		skb_trim(skbstat, NLMSG_ALIGN(actual_size));
865 866
		nlhstat->nlmsg_len = actual_size;

867
		err = iscsi_unicast_skb(skbstat, priv->daemon_pid);
868 869 870
	} while (err < 0 && err != -ECONNREFUSED);

	return err;
871 872
}

873
/**
M
Mike Christie 已提交
874 875 876
 * iscsi_session_event - send session destr. completion event
 * @session: iscsi class session
 * @event: type of event
877
 */
M
Mike Christie 已提交
878 879
int iscsi_session_event(struct iscsi_cls_session *session,
			enum iscsi_uevent_e event)
880 881 882 883 884 885 886 887
{
	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 已提交
888
	priv = iscsi_if_transport_lookup(session->transport);
889 890 891 892
	if (!priv)
		return -EINVAL;
	shost = iscsi_session_to_shost(session);

893
	skb = alloc_skb(len, GFP_KERNEL);
894
	if (!skb) {
M
Mike Christie 已提交
895 896
		dev_printk(KERN_ERR, &session->dev, "Cannot notify userspace "
			  "of session event %u\n", event);
897 898 899 900 901
		return -ENOMEM;
	}

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

M
Mike Christie 已提交
904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921
	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:
		dev_printk(KERN_ERR, &session->dev, "Invalid event %u.\n",
			   event);
		kfree_skb(skb);
922 923 924 925 926 927 928
		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
	 */
929
	rc = iscsi_broadcast_skb(skb, GFP_KERNEL);
930
	if (rc < 0)
M
Mike Christie 已提交
931 932
		dev_printk(KERN_ERR, &session->dev, "Cannot notify userspace "
			  "of session event %u. Check iscsi daemon\n", event);
933 934
	return rc;
}
M
Mike Christie 已提交
935
EXPORT_SYMBOL_GPL(iscsi_session_event);
936

937 938 939 940
static int
iscsi_if_create_session(struct iscsi_internal *priv, struct iscsi_uevent *ev)
{
	struct iscsi_transport *transport = priv->iscsi_transport;
941
	struct iscsi_cls_session *session;
942
	uint32_t hostno;
943

M
Mike Christie 已提交
944
	session = transport->create_session(transport, &priv->t,
945 946
					    ev->u.c_session.cmds_max,
					    ev->u.c_session.queue_depth,
947
					    ev->u.c_session.initial_cmdsn,
948
					    &hostno);
949
	if (!session)
950
		return -ENOMEM;
951

952 953
	ev->r.c_session_ret.host_no = hostno;
	ev->r.c_session_ret.sid = session->sid;
954 955 956 957
	return 0;
}

static int
958
iscsi_if_create_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
959
{
960
	struct iscsi_cls_conn *conn;
961
	struct iscsi_cls_session *session;
962

963 964 965 966
	session = iscsi_session_lookup(ev->u.c_conn.sid);
	if (!session) {
		printk(KERN_ERR "iscsi: invalid session %d\n",
		       ev->u.c_conn.sid);
967
		return -EINVAL;
968
	}
969

970
	conn = transport->create_conn(session, ev->u.c_conn.cid);
971 972 973 974
	if (!conn) {
		printk(KERN_ERR "iscsi: couldn't create a new "
			   "connection for session %d\n",
			   session->sid);
975
		return -ENOMEM;
976
	}
977

978 979
	ev->r.c_conn_ret.sid = session->sid;
	ev->r.c_conn_ret.cid = conn->cid;
980
	return 0;
L
Linus Torvalds 已提交
981 982
}

983 984 985
static int
iscsi_if_destroy_conn(struct iscsi_transport *transport, struct iscsi_uevent *ev)
{
986
	struct iscsi_cls_conn *conn;
987

988
	conn = iscsi_conn_lookup(ev->u.d_conn.sid, ev->u.d_conn.cid);
989
	if (!conn)
990
		return -EINVAL;
991

992 993 994
	if (transport->destroy_conn)
		transport->destroy_conn(conn);
	return 0;
995 996
}

997 998 999 1000 1001 1002
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;
1003
	int err = 0, value = 0;
1004 1005 1006 1007 1008 1009 1010

	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 已提交
1011
	case ISCSI_PARAM_SESS_RECOVERY_TMO:
1012
		sscanf(data, "%d", &value);
M
Mike Christie 已提交
1013 1014 1015
		if (value != 0)
			session->recovery_tmo = value;
		break;
1016
	default:
1017 1018
		err = transport->set_param(conn, ev->u.set_param.param,
					   data, ev->u.set_param.len);
1019 1020 1021 1022 1023
	}

	return err;
}

1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
static int
iscsi_if_transport_ep(struct iscsi_transport *transport,
		      struct iscsi_uevent *ev, int msg_type)
{
	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));
		rc = transport->ep_connect(dst_addr,
					   ev->u.ep_connect.non_blocking,
					   &ev->r.ep_connect_ret.handle);
		break;
	case ISCSI_UEVENT_TRANSPORT_EP_POLL:
		if (!transport->ep_poll)
			return -EINVAL;

		ev->r.retcode = transport->ep_poll(ev->u.ep_poll.ep_handle,
						   ev->u.ep_poll.timeout_ms);
		break;
	case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
		if (!transport->ep_disconnect)
			return -EINVAL;

		transport->ep_disconnect(ev->u.ep_disconnect.ep_handle);
		break;
	}
	return rc;
}

1058 1059 1060 1061
static int
iscsi_tgt_dscvr(struct iscsi_transport *transport,
		struct iscsi_uevent *ev)
{
1062
	struct Scsi_Host *shost;
1063
	struct sockaddr *dst_addr;
1064
	int err;
1065 1066 1067 1068

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

1069 1070 1071 1072 1073 1074 1075 1076
	shost = scsi_host_lookup(ev->u.tgt_dscvr.host_no);
	if (IS_ERR(shost)) {
		printk(KERN_ERR "target discovery could not find host no %u\n",
		       ev->u.tgt_dscvr.host_no);
		return -ENODEV;
	}


1077
	dst_addr = (struct sockaddr *)((char*)ev + sizeof(*ev));
1078 1079 1080 1081
	err = transport->tgt_dscvr(shost, ev->u.tgt_dscvr.type,
				   ev->u.tgt_dscvr.enable, dst_addr);
	scsi_host_put(shost);
	return err;
1082 1083
}

1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
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);
	if (IS_ERR(shost)) {
		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;
}

1108 1109 1110 1111 1112 1113 1114
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;
1115 1116
	struct iscsi_cls_session *session;
	struct iscsi_cls_conn *conn;
1117 1118 1119 1120 1121 1122

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

1123 1124 1125
	if (!try_module_get(transport->owner))
		return -EINVAL;

1126 1127
	priv->daemon_pid = NETLINK_CREDS(skb)->pid;

1128 1129 1130 1131 1132
	switch (nlh->nlmsg_type) {
	case ISCSI_UEVENT_CREATE_SESSION:
		err = iscsi_if_create_session(priv, ev);
		break;
	case ISCSI_UEVENT_DESTROY_SESSION:
1133
		session = iscsi_session_lookup(ev->u.d_session.sid);
M
Mike Christie 已提交
1134
		if (session)
1135
			transport->destroy_session(session);
M
Mike Christie 已提交
1136 1137 1138 1139 1140 1141 1142 1143
		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
1144
			err = -EINVAL;
1145 1146 1147 1148 1149 1150 1151 1152
		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:
1153 1154
		session = iscsi_session_lookup(ev->u.b_conn.sid);
		conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid);
1155 1156 1157

		if (session && conn)
			ev->r.retcode =	transport->bind_conn(session, conn,
1158
					ev->u.b_conn.transport_eph,
1159 1160 1161
					ev->u.b_conn.is_leading);
		else
			err = -EINVAL;
1162 1163
		break;
	case ISCSI_UEVENT_SET_PARAM:
1164
		err = iscsi_set_param(transport, ev);
1165 1166
		break;
	case ISCSI_UEVENT_START_CONN:
1167
		conn = iscsi_conn_lookup(ev->u.start_conn.sid, ev->u.start_conn.cid);
1168 1169 1170 1171
		if (conn)
			ev->r.retcode = transport->start_conn(conn);
		else
			err = -EINVAL;
1172 1173
		break;
	case ISCSI_UEVENT_STOP_CONN:
1174
		conn = iscsi_conn_lookup(ev->u.stop_conn.sid, ev->u.stop_conn.cid);
1175 1176 1177 1178
		if (conn)
			transport->stop_conn(conn, ev->u.stop_conn.flag);
		else
			err = -EINVAL;
1179 1180
		break;
	case ISCSI_UEVENT_SEND_PDU:
1181
		conn = iscsi_conn_lookup(ev->u.send_pdu.sid, ev->u.send_pdu.cid);
1182 1183 1184 1185 1186 1187 1188
		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;
1189 1190
		break;
	case ISCSI_UEVENT_GET_STATS:
1191
		err = iscsi_if_get_stats(transport, nlh);
1192
		break;
1193 1194 1195 1196 1197
	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;
1198 1199 1200
	case ISCSI_UEVENT_TGT_DSCVR:
		err = iscsi_tgt_dscvr(transport, ev);
		break;
1201 1202 1203
	case ISCSI_UEVENT_SET_HOST_PARAM:
		err = iscsi_set_host_param(transport, ev);
		break;
1204
	default:
1205
		err = -ENOSYS;
1206 1207 1208
		break;
	}

1209
	module_put(transport->owner);
1210 1211 1212
	return err;
}

1213
/*
1214 1215
 * Get message from skb.  Each message is processed by iscsi_if_recv_msg.
 * Malformed skbs with wrong lengths or invalid creds are not processed.
1216
 */
1217
static void
1218
iscsi_if_rx(struct sk_buff *skb)
1219
{
1220
	mutex_lock(&rx_queue_mutex);
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
	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;
1231 1232
		}

1233 1234 1235 1236
		ev = NLMSG_DATA(nlh);
		rlen = NLMSG_ALIGN(nlh->nlmsg_len);
		if (rlen > skb->len)
			rlen = skb->len;
1237

1238 1239 1240 1241
		err = iscsi_if_recv_msg(skb, nlh);
		if (err) {
			ev->type = ISCSI_KEVENT_IF_ERROR;
			ev->iferror = err;
1242
		}
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
		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);
1257
	}
1258
	mutex_unlock(&rx_queue_mutex);
1259
}
L
Linus Torvalds 已提交
1260

1261 1262 1263
#define iscsi_cdev_to_conn(_cdev) \
	iscsi_dev_to_conn(_cdev->dev)

1264 1265 1266 1267
#define ISCSI_CLASS_ATTR(_prefix,_name,_mode,_show,_store)		\
struct class_device_attribute class_device_attr_##_prefix##_##_name =	\
	__ATTR(_name,_mode,_show,_store)

L
Linus Torvalds 已提交
1268
/*
1269
 * iSCSI connection attrs
L
Linus Torvalds 已提交
1270
 */
1271
#define iscsi_conn_attr_show(param)					\
1272
static ssize_t								\
1273
show_conn_param_##param(struct class_device *cdev, char *buf)		\
1274
{									\
1275 1276
	struct iscsi_cls_conn *conn = iscsi_cdev_to_conn(cdev);		\
	struct iscsi_transport *t = conn->transport;			\
1277
	return t->get_conn_param(conn, param, buf);			\
1278 1279
}

1280 1281 1282
#define iscsi_conn_attr(field, param)					\
	iscsi_conn_attr_show(param)					\
static ISCSI_CLASS_ATTR(conn, field, S_IRUGO, show_conn_param_##param,	\
1283
			NULL);
1284

1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
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);
1296 1297
iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);
iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);
L
Linus Torvalds 已提交
1298

1299 1300 1301
#define iscsi_cdev_to_session(_cdev) \
	iscsi_dev_to_session(_cdev->dev)

L
Linus Torvalds 已提交
1302
/*
1303
 * iSCSI session attrs
L
Linus Torvalds 已提交
1304
 */
1305
#define iscsi_session_attr_show(param, perm)				\
1306
static ssize_t								\
1307
show_session_param_##param(struct class_device *cdev, char *buf)	\
1308 1309 1310
{									\
	struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev); \
	struct iscsi_transport *t = session->transport;			\
1311 1312 1313
									\
	if (perm && !capable(CAP_SYS_ADMIN))				\
		return -EACCES;						\
1314
	return t->get_session_param(session, param, buf);		\
1315 1316
}

1317 1318
#define iscsi_session_attr(field, param, perm)				\
	iscsi_session_attr_show(param, perm)				\
1319
static ISCSI_CLASS_ATTR(sess, field, S_IRUGO, show_session_param_##param, \
1320 1321
			NULL);

1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335
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);
1336 1337 1338
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);
L
Linus Torvalds 已提交
1339

1340 1341 1342 1343 1344 1345 1346 1347 1348
static ssize_t
show_priv_session_state(struct class_device *cdev, char *buf)
{
	struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);
	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);

1349 1350
#define iscsi_priv_session_attr_show(field, format)			\
static ssize_t								\
1351
show_priv_session_##field(struct class_device *cdev, char *buf)		\
1352
{									\
1353
	struct iscsi_cls_session *session = iscsi_cdev_to_session(cdev);\
1354 1355 1356 1357 1358 1359 1360
	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 已提交
1361
iscsi_priv_session_attr(recovery_tmo, "%d");
1362

1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379
/*
 * iSCSI host attrs
 */
#define iscsi_host_attr_show(param)					\
static ssize_t								\
show_host_param_##param(struct class_device *cdev, char *buf)		\
{									\
	struct Scsi_Host *shost = transport_class_to_shost(cdev);	\
	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);

1380
iscsi_host_attr(netdev, ISCSI_HOST_PARAM_NETDEV_NAME);
1381
iscsi_host_attr(hwaddress, ISCSI_HOST_PARAM_HWADDRESS);
1382
iscsi_host_attr(ipaddress, ISCSI_HOST_PARAM_IPADDRESS);
1383
iscsi_host_attr(initiatorname, ISCSI_HOST_PARAM_INITIATOR_NAME);
1384

1385 1386 1387 1388 1389 1390
#define SETUP_PRIV_SESSION_RD_ATTR(field)				\
do {									\
	priv->session_attrs[count] = &class_device_attr_priv_sess_##field; \
	count++;							\
} while (0)

1391

1392 1393 1394 1395
#define SETUP_SESSION_RD_ATTR(field, param_flag)			\
do {									\
	if (tt->param_mask & param_flag) {				\
		priv->session_attrs[count] = &class_device_attr_sess_##field; \
L
Linus Torvalds 已提交
1396
		count++;						\
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
	}								\
} while (0)

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

1408 1409 1410 1411 1412 1413 1414 1415
#define SETUP_HOST_RD_ATTR(field, param_flag)				\
do {									\
	if (tt->host_param_mask & param_flag) {				\
		priv->host_attrs[count] = &class_device_attr_host_##field; \
		count++;						\
	}								\
} while (0)

1416 1417
static int iscsi_session_match(struct attribute_container *cont,
			   struct device *dev)
L
Linus Torvalds 已提交
1418
{
1419
	struct iscsi_cls_session *session;
L
Linus Torvalds 已提交
1420
	struct Scsi_Host *shost;
1421 1422 1423 1424
	struct iscsi_internal *priv;

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

1426 1427
	session = iscsi_dev_to_session(dev);
	shost = iscsi_session_to_shost(session);
1428
	if (!shost->transportt)
L
Linus Torvalds 已提交
1429 1430
		return 0;

1431 1432
	priv = to_iscsi_internal(shost->transportt);
	if (priv->session_cont.ac.class != &iscsi_session_class.class)
L
Linus Torvalds 已提交
1433 1434
		return 0;

1435
	return &priv->session_cont.ac == cont;
L
Linus Torvalds 已提交
1436 1437
}

1438 1439 1440
static int iscsi_conn_match(struct attribute_container *cont,
			   struct device *dev)
{
1441 1442
	struct iscsi_cls_session *session;
	struct iscsi_cls_conn *conn;
L
Linus Torvalds 已提交
1443
	struct Scsi_Host *shost;
1444
	struct iscsi_internal *priv;
L
Linus Torvalds 已提交
1445

1446
	if (!iscsi_is_conn_dev(dev))
L
Linus Torvalds 已提交
1447 1448
		return 0;

1449 1450 1451 1452
	conn = iscsi_dev_to_conn(dev);
	session = iscsi_dev_to_session(conn->dev.parent);
	shost = iscsi_session_to_shost(session);

1453
	if (!shost->transportt)
L
Linus Torvalds 已提交
1454 1455
		return 0;

1456 1457 1458
	priv = to_iscsi_internal(shost->transportt);
	if (priv->conn_cont.ac.class != &iscsi_connection_class.class)
		return 0;
L
Linus Torvalds 已提交
1459

1460 1461 1462
	return &priv->conn_cont.ac == cont;
}

M
Mike Christie 已提交
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
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;
}

1481 1482
struct scsi_transport_template *
iscsi_register_transport(struct iscsi_transport *tt)
1483 1484 1485 1486 1487 1488 1489 1490 1491
{
	struct iscsi_internal *priv;
	unsigned long flags;
	int count = 0, err;

	BUG_ON(!tt);

	priv = iscsi_if_transport_lookup(tt);
	if (priv)
1492
		return NULL;
1493

J
Jes Sorensen 已提交
1494
	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1495
	if (!priv)
1496
		return NULL;
1497
	INIT_LIST_HEAD(&priv->list);
1498
	priv->daemon_pid = -1;
1499
	priv->iscsi_transport = tt;
M
Mike Christie 已提交
1500
	priv->t.user_scan = iscsi_user_scan;
1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511

	priv->cdev.class = &iscsi_transport_class;
	snprintf(priv->cdev.class_id, BUS_ID_SIZE, "%s", tt->name);
	err = class_device_register(&priv->cdev);
	if (err)
		goto free_priv;

	err = sysfs_create_group(&priv->cdev.kobj, &iscsi_transport_group);
	if (err)
		goto unregister_cdev;

M
Mike Christie 已提交
1512 1513 1514 1515 1516 1517 1518
	/* 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;
	priv->t.host_size = sizeof(struct iscsi_host);
	transport_container_register(&priv->t.host_attrs);

1519
	SETUP_HOST_RD_ATTR(netdev, ISCSI_HOST_NETDEV_NAME);
1520
	SETUP_HOST_RD_ATTR(ipaddress, ISCSI_HOST_IPADDRESS);
1521
	SETUP_HOST_RD_ATTR(hwaddress, ISCSI_HOST_HWADDRESS);
1522
	SETUP_HOST_RD_ATTR(initiatorname, ISCSI_HOST_INITIATOR_NAME);
1523 1524 1525 1526
	BUG_ON(count > ISCSI_HOST_ATTRS);
	priv->host_attrs[count] = NULL;
	count = 0;

1527 1528 1529 1530 1531
	/* 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 已提交
1532

1533 1534 1535 1536 1537 1538 1539 1540
	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);
1541
	SETUP_CONN_RD_ATTR(exp_statsn, ISCSI_EXP_STATSN);
1542 1543
	SETUP_CONN_RD_ATTR(persistent_address, ISCSI_PERSISTENT_ADDRESS);
	SETUP_CONN_RD_ATTR(persistent_port, ISCSI_PERSISTENT_PORT);
1544 1545
	SETUP_CONN_RD_ATTR(ping_tmo, ISCSI_PING_TMO);
	SETUP_CONN_RD_ATTR(recv_tmo, ISCSI_RECV_TMO);
1546 1547 1548

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

1551 1552 1553 1554 1555 1556
	/* 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);

1557 1558 1559 1560 1561 1562 1563 1564
	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);
1565 1566
	SETUP_SESSION_RD_ATTR(targetname, ISCSI_TARGET_NAME);
	SETUP_SESSION_RD_ATTR(tpgt, ISCSI_TPGT);
1567 1568 1569 1570
	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);
1571
	SETUP_SESSION_RD_ATTR(fast_abort, ISCSI_FAST_ABORT);
1572 1573
	SETUP_SESSION_RD_ATTR(abort_tmo, ISCSI_ABORT_TMO);
	SETUP_SESSION_RD_ATTR(lu_reset_tmo,ISCSI_LU_RESET_TMO);
M
Mike Christie 已提交
1574
	SETUP_PRIV_SESSION_RD_ATTR(recovery_tmo);
1575
	SETUP_PRIV_SESSION_RD_ATTR(state);
1576

1577 1578 1579 1580 1581 1582 1583 1584
	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);
1585
	return &priv->t;
L
Linus Torvalds 已提交
1586

1587 1588 1589 1590
unregister_cdev:
	class_device_unregister(&priv->cdev);
free_priv:
	kfree(priv);
1591
	return NULL;
L
Linus Torvalds 已提交
1592
}
1593 1594 1595 1596 1597 1598 1599 1600 1601
EXPORT_SYMBOL_GPL(iscsi_register_transport);

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

	BUG_ON(!tt);

1602
	mutex_lock(&rx_queue_mutex);
1603 1604 1605 1606 1607 1608 1609 1610 1611 1612

	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 已提交
1613
	transport_container_unregister(&priv->t.host_attrs);
1614 1615 1616

	sysfs_remove_group(&priv->cdev.kobj, &iscsi_transport_group);
	class_device_unregister(&priv->cdev);
1617
	mutex_unlock(&rx_queue_mutex);
L
Linus Torvalds 已提交
1618

1619 1620 1621
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_unregister_transport);
L
Linus Torvalds 已提交
1622 1623 1624

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

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

1630 1631
	atomic_set(&iscsi_session_nr, 0);

1632
	err = class_register(&iscsi_transport_class);
L
Linus Torvalds 已提交
1633 1634
	if (err)
		return err;
1635

M
Mike Christie 已提交
1636
	err = transport_class_register(&iscsi_host_class);
1637 1638 1639
	if (err)
		goto unregister_transport_class;

M
Mike Christie 已提交
1640 1641 1642 1643
	err = transport_class_register(&iscsi_connection_class);
	if (err)
		goto unregister_host_class;

1644 1645 1646 1647
	err = transport_class_register(&iscsi_session_class);
	if (err)
		goto unregister_conn_class;

1648
	nls = netlink_kernel_create(&init_net, NETLINK_ISCSI, 1, iscsi_if_rx, NULL,
1649
			THIS_MODULE);
1650 1651
	if (!nls) {
		err = -ENOBUFS;
1652
		goto unregister_session_class;
1653 1654
	}

1655 1656 1657 1658
	iscsi_eh_timer_workq = create_singlethread_workqueue("iscsi_eh");
	if (!iscsi_eh_timer_workq)
		goto release_nls;

1659
	return 0;
1660

1661
release_nls:
1662
	netlink_kernel_release(nls);
1663 1664 1665 1666
unregister_session_class:
	transport_class_unregister(&iscsi_session_class);
unregister_conn_class:
	transport_class_unregister(&iscsi_connection_class);
M
Mike Christie 已提交
1667 1668
unregister_host_class:
	transport_class_unregister(&iscsi_host_class);
1669 1670 1671
unregister_transport_class:
	class_unregister(&iscsi_transport_class);
	return err;
L
Linus Torvalds 已提交
1672 1673 1674 1675
}

static void __exit iscsi_transport_exit(void)
{
1676
	destroy_workqueue(iscsi_eh_timer_workq);
1677
	netlink_kernel_release(nls);
1678 1679
	transport_class_unregister(&iscsi_connection_class);
	transport_class_unregister(&iscsi_session_class);
M
Mike Christie 已提交
1680
	transport_class_unregister(&iscsi_host_class);
1681
	class_unregister(&iscsi_transport_class);
L
Linus Torvalds 已提交
1682 1683 1684 1685 1686
}

module_init(iscsi_transport_init);
module_exit(iscsi_transport_exit);

1687 1688 1689 1690
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 已提交
1691
MODULE_LICENSE("GPL");
1692
MODULE_VERSION(ISCSI_TRANSPORT_VERSION);