[SCSI] iscsi: remove session and host binding in libiscsi (75613521) · Commits · 戴 / test

drivers/infiniband/ulp/iser/iscsi_iser.c

+54 −20

Original line number	Diff line number	Diff line
		@@ -74,6 +74,10 @@

		#include "iscsi_iser.h"

		static struct scsi_host_template iscsi_iser_sht;
		static struct iscsi_transport iscsi_iser_transport;
		static struct scsi_transport_template *iscsi_iser_scsi_transport;

		static unsigned int iscsi_max_lun = 512;
		module_param_named(max_lun, iscsi_max_lun, uint, S_IRUGO);

		@@ -363,40 +367,64 @@ iscsi_iser_conn_start(struct iscsi_cls_conn *cls_conn)
		return iscsi_conn_start(cls_conn);
		}

		static struct iscsi_transport iscsi_iser_transport;
		static void iscsi_iser_session_destroy(struct iscsi_cls_session *cls_session)
		{
		struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);

		iscsi_session_teardown(cls_session);
		scsi_remove_host(shost);
		iscsi_host_teardown(shost);
		scsi_host_put(shost);
		}

		static struct iscsi_cls_session *
		iscsi_iser_session_create(struct iscsi_transport *iscsit,
		struct scsi_transport_template *scsit,
		struct Scsi_Host *shost,
		iscsi_iser_session_create(struct Scsi_Host *shost,
		uint16_t cmds_max, uint16_t qdepth,
		uint32_t initial_cmdsn, uint32_t *hostno)
		{
		struct iscsi_cls_session *cls_session;
		struct iscsi_session *session;
		int i;
		uint32_t hn;
		struct iscsi_cmd_task *ctask;
		struct iscsi_mgmt_task *mtask;
		struct iscsi_iser_cmd_task *iser_ctask;
		struct iser_desc *desc;

		if (shost) {
		printk(KERN_ERR "iscsi_tcp: invalid shost %d.\n",
		shost->host_no);
		return NULL;
		}

		shost = scsi_host_alloc(&iscsi_iser_sht, 0);
		if (!shost)
		return NULL;
		shost->transportt = iscsi_iser_scsi_transport;
		shost->max_lun = iscsi_max_lun;
		shost->max_id = 0;
		shost->max_channel = 0;
		shost->max_cmd_len = 16;

		iscsi_host_setup(shost, qdepth);

		if (scsi_add_host(shost, NULL))
		goto free_host;
		*hostno = shost->host_no;

		/*
		* we do not support setting can_queue cmd_per_lun from userspace yet
		* because we preallocate so many resources
		*/
		cls_session = iscsi_session_setup(iscsit, scsit,
		cls_session = iscsi_session_setup(&iscsi_iser_transport, shost,
		ISCSI_DEF_XMIT_CMDS_MAX,
		ISCSI_MAX_CMD_PER_LUN,
		sizeof(struct iscsi_iser_cmd_task),
		sizeof(struct iser_desc),
		initial_cmdsn, &hn);
		initial_cmdsn);
		if (!cls_session)
		return NULL;

		*hostno = hn;
		session = class_to_transport_session(cls_session);
		goto remove_host;
		session = cls_session->dd_data;

		shost->can_queue = session->cmds_max;
		/* libiscsi setup itts, data and pool so just set desc fields */
		for (i = 0; i < session->cmds_max; i++) {
		ctask = session->cmds[i];
		@@ -413,6 +441,13 @@ iscsi_iser_session_create(struct iscsi_transport *iscsit,
		}

		return cls_session;

		remove_host:
		scsi_remove_host(shost);
		free_host:
		iscsi_host_teardown(shost);
		scsi_host_put(shost);
		return NULL;
		}

		static int
		@@ -589,12 +624,11 @@ static struct iscsi_transport iscsi_iser_transport = {
		.host_param_mask = ISCSI_HOST_HWADDRESS \|
		ISCSI_HOST_NETDEV_NAME \|
		ISCSI_HOST_INITIATOR_NAME,
		.host_template = &iscsi_iser_sht,
		.conndata_size = sizeof(struct iscsi_conn),
		.max_lun = ISCSI_ISER_MAX_LUN,
		.sessiondata_size = sizeof(struct iscsi_session),
		/* session management */
		.create_session = iscsi_iser_session_create,
		.destroy_session = iscsi_session_teardown,
		.destroy_session = iscsi_iser_session_destroy,
		/* connection management */
		.create_conn = iscsi_iser_conn_create,
		.bind_conn = iscsi_iser_conn_bind,
		@@ -633,8 +667,6 @@ static int __init iser_init(void)
		return -EINVAL;
		}

		iscsi_iser_transport.max_lun = iscsi_max_lun;

		memset(&ig, 0, sizeof(struct iser_global));

		ig.desc_cache = kmem_cache_create("iser_descriptors",
		@@ -650,7 +682,9 @@ static int __init iser_init(void)
		mutex_init(&ig.connlist_mutex);
		INIT_LIST_HEAD(&ig.connlist);

		if (!iscsi_register_transport(&iscsi_iser_transport)) {
		iscsi_iser_scsi_transport = iscsi_register_transport(
		&iscsi_iser_transport);
		if (!iscsi_iser_scsi_transport) {
		iser_err("iscsi_register_transport failed\n");
		err = -EINVAL;
		goto register_transport_failure;

drivers/scsi/iscsi_tcp.c

+57 −45

Original line number	Diff line number	Diff line
		@@ -64,6 +64,10 @@ MODULE_LICENSE("GPL");
		#define BUG_ON(expr)
		#endif

		static struct scsi_transport_template *iscsi_tcp_scsi_transport;
		static struct scsi_host_template iscsi_sht;
		static struct iscsi_transport iscsi_tcp_transport;

		static unsigned int iscsi_max_lun = 512;
		module_param_named(max_lun, iscsi_max_lun, uint, S_IRUGO);

		@@ -1623,6 +1627,8 @@ iscsi_tcp_conn_bind(struct iscsi_cls_session *cls_session,
		struct iscsi_cls_conn *cls_conn, uint64_t transport_eph,
		int is_leading)
		{
		struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
		struct iscsi_host *ihost = shost_priv(shost);
		struct iscsi_conn *conn = cls_conn->dd_data;
		struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
		struct sock *sk;
		@@ -1646,8 +1652,8 @@ iscsi_tcp_conn_bind(struct iscsi_cls_session *cls_session,
		if (err)
		goto free_socket;

		err = iscsi_tcp_get_addr(conn, sock, conn->local_address,
		&conn->local_port, kernel_getsockname);
		err = iscsi_tcp_get_addr(conn, sock, ihost->local_address,
		&ihost->local_port, kernel_getsockname);
		if (err)
		goto free_socket;

		@@ -1821,29 +1827,6 @@ iscsi_tcp_conn_get_param(struct iscsi_cls_conn *cls_conn,
		return len;
		}

		static int
		iscsi_tcp_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param,
		char *buf)
		{
		struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
		int len;

		switch (param) {
		case ISCSI_HOST_PARAM_IPADDRESS:
		spin_lock_bh(&session->lock);
		if (!session->leadconn)
		len = -ENODEV;
		else
		len = sprintf(buf, "%s\n",
		session->leadconn->local_address);
		spin_unlock_bh(&session->lock);
		break;
		default:
		return iscsi_host_get_param(shost, param, buf);
		}
		return len;
		}

		static void
		iscsi_conn_get_stats(struct iscsi_cls_conn cls_conn, struct iscsi_stats stats)
		{
		@@ -1869,26 +1852,44 @@ iscsi_conn_get_stats(struct iscsi_cls_conn cls_conn, struct iscsi_stats stats)
		}

		static struct iscsi_cls_session *
		iscsi_tcp_session_create(struct iscsi_transport *iscsit,
		struct scsi_transport_template *scsit,
		struct Scsi_Host *shost, uint16_t cmds_max,
		iscsi_tcp_session_create(struct Scsi_Host *shost, uint16_t cmds_max,
		uint16_t qdepth, uint32_t initial_cmdsn,
		uint32_t *hostno)
		{
		struct iscsi_cls_session *cls_session;
		struct iscsi_session *session;
		uint32_t hn;
		int cmd_i;

		cls_session = iscsi_session_setup(iscsit, scsit, cmds_max, qdepth,
		if (shost) {
		printk(KERN_ERR "iscsi_tcp: invalid shost %d.\n",
		shost->host_no);
		return NULL;
		}

		shost = scsi_host_alloc(&iscsi_sht, sizeof(struct iscsi_host));
		if (!shost)
		return NULL;
		shost->transportt = iscsi_tcp_scsi_transport;
		shost->max_lun = iscsi_max_lun;
		shost->max_id = 0;
		shost->max_channel = 0;
		shost->max_cmd_len = 16;

		iscsi_host_setup(shost, qdepth);

		if (scsi_add_host(shost, NULL))
		goto free_host;
		*hostno = shost->host_no;

		cls_session = iscsi_session_setup(&iscsi_tcp_transport, shost, cmds_max,
		sizeof(struct iscsi_tcp_cmd_task),
		sizeof(struct iscsi_tcp_mgmt_task),
		initial_cmdsn, &hn);
		initial_cmdsn);
		if (!cls_session)
		return NULL;
		*hostno = hn;
		goto remove_host;
		session = cls_session->dd_data;

		session = class_to_transport_session(cls_session);
		shost->can_queue = session->cmds_max;
		for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) {
		struct iscsi_cmd_task *ctask = session->cmds[cmd_i];
		struct iscsi_tcp_cmd_task *tcp_ctask = ctask->dd_data;
		@@ -1904,20 +1905,30 @@ iscsi_tcp_session_create(struct iscsi_transport *iscsit,
		mtask->hdr = (struct iscsi_hdr *) &tcp_mtask->hdr;
		}

		if (iscsi_r2tpool_alloc(class_to_transport_session(cls_session)))
		goto r2tpool_alloc_fail;

		if (iscsi_r2tpool_alloc(session))
		goto remove_session;
		return cls_session;

		r2tpool_alloc_fail:
		remove_session:
		iscsi_session_teardown(cls_session);
		remove_host:
		scsi_remove_host(shost);
		free_host:
		iscsi_host_teardown(shost);
		scsi_host_put(shost);
		return NULL;
		}

		static void iscsi_tcp_session_destroy(struct iscsi_cls_session *cls_session)
		{
		iscsi_r2tpool_free(class_to_transport_session(cls_session));
		struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);

		iscsi_r2tpool_free(cls_session->dd_data);
		iscsi_session_teardown(cls_session);

		scsi_remove_host(shost);
		iscsi_host_teardown(shost);
		scsi_host_put(shost);
		}

		static int iscsi_tcp_slave_configure(struct scsi_device *sdev)
		@@ -1976,8 +1987,8 @@ static struct iscsi_transport iscsi_tcp_transport = {
		.host_param_mask = ISCSI_HOST_HWADDRESS \| ISCSI_HOST_IPADDRESS \|
		ISCSI_HOST_INITIATOR_NAME \|
		ISCSI_HOST_NETDEV_NAME,
		.host_template = &iscsi_sht,
		.conndata_size = sizeof(struct iscsi_conn),
		.sessiondata_size = sizeof(struct iscsi_session),
		/* session management */
		.create_session = iscsi_tcp_session_create,
		.destroy_session = iscsi_tcp_session_destroy,
		@@ -1991,7 +2002,7 @@ static struct iscsi_transport iscsi_tcp_transport = {
		.start_conn = iscsi_conn_start,
		.stop_conn = iscsi_tcp_conn_stop,
		/* iscsi host params */
		.get_host_param = iscsi_tcp_host_get_param,
		.get_host_param = iscsi_host_get_param,
		.set_host_param = iscsi_host_set_param,
		/* IO */
		.send_pdu = iscsi_conn_send_pdu,
		@@ -2013,9 +2024,10 @@ iscsi_tcp_init(void)
		iscsi_max_lun);
		return -EINVAL;
		}
		iscsi_tcp_transport.max_lun = iscsi_max_lun;

		if (!iscsi_register_transport(&iscsi_tcp_transport))
		iscsi_tcp_scsi_transport = iscsi_register_transport(
		&iscsi_tcp_transport);
		if (!iscsi_tcp_scsi_transport)
		return -ENODEV;

		return 0;

drivers/scsi/libiscsi.c

+94 −119

Original line number	Diff line number	Diff line
		@@ -38,14 +38,6 @@
		#include <scsi/scsi_transport_iscsi.h>
		#include <scsi/libiscsi.h>

		struct iscsi_session *
		class_to_transport_session(struct iscsi_cls_session *cls_session)
		{
		struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
		return iscsi_hostdata(shost->hostdata);
		}
		EXPORT_SYMBOL_GPL(class_to_transport_session);

		/* Serial Number Arithmetic, 32 bits, less than, RFC1982 */
		#define SNA32_CHECK 2147483648UL

		@@ -1096,6 +1088,7 @@ enum {

		int iscsi_queuecommand(struct scsi_cmnd sc, void (done)(struct scsi_cmnd *))
		{
		struct iscsi_cls_session *cls_session;
		struct Scsi_Host *host;
		int reason = 0;
		struct iscsi_session *session;
		@@ -1109,10 +1102,11 @@ int iscsi_queuecommand(struct scsi_cmnd sc, void (done)(struct scsi_cmnd *))
		host = sc->device->host;
		spin_unlock(host->host_lock);

		session = iscsi_hostdata(host->hostdata);
		cls_session = starget_to_session(scsi_target(sc->device));
		session = cls_session->dd_data;
		spin_lock(&session->lock);

		reason = iscsi_session_chkready(session_to_cls(session));
		reason = iscsi_session_chkready(cls_session);
		if (reason) {
		sc->result = reason;
		goto fault;
		@@ -1222,7 +1216,7 @@ EXPORT_SYMBOL_GPL(iscsi_change_queue_depth);

		void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session)
		{
		struct iscsi_session *session = class_to_transport_session(cls_session);
		struct iscsi_session *session = cls_session->dd_data;

		spin_lock_bh(&session->lock);
		if (session->state != ISCSI_STATE_LOGGED_IN) {
		@@ -1236,9 +1230,13 @@ EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout);

		int iscsi_eh_host_reset(struct scsi_cmnd *sc)
		{
		struct Scsi_Host *host = sc->device->host;
		struct iscsi_session *session = iscsi_hostdata(host->hostdata);
		struct iscsi_conn *conn = session->leadconn;
		struct iscsi_cls_session *cls_session;
		struct iscsi_session *session;
		struct iscsi_conn *conn;

		cls_session = starget_to_session(scsi_target(sc->device));
		session = cls_session->dd_data;
		conn = session->leadconn;

		mutex_lock(&session->eh_mutex);
		spin_lock_bh(&session->lock);
		@@ -1405,7 +1403,7 @@ static enum scsi_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd)
		enum scsi_eh_timer_return rc = EH_NOT_HANDLED;

		cls_session = starget_to_session(scsi_target(scmd->device));
		session = class_to_transport_session(cls_session);
		session = cls_session->dd_data;

		debug_scsi("scsi cmd %p timedout\n", scmd);

		@@ -1507,13 +1505,16 @@ static void iscsi_prep_abort_task_pdu(struct iscsi_cmd_task *ctask,

		int iscsi_eh_abort(struct scsi_cmnd *sc)
		{
		struct Scsi_Host *host = sc->device->host;
		struct iscsi_session *session = iscsi_hostdata(host->hostdata);
		struct iscsi_cls_session *cls_session;
		struct iscsi_session *session;
		struct iscsi_conn *conn;
		struct iscsi_cmd_task *ctask;
		struct iscsi_tm *hdr;
		int rc, age;

		cls_session = starget_to_session(scsi_target(sc->device));
		session = cls_session->dd_data;

		mutex_lock(&session->eh_mutex);
		spin_lock_bh(&session->lock);
		/*
		@@ -1630,12 +1631,15 @@ static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd sc, struct iscsi_tm hdr)

		int iscsi_eh_device_reset(struct scsi_cmnd *sc)
		{
		struct Scsi_Host *host = sc->device->host;
		struct iscsi_session *session = iscsi_hostdata(host->hostdata);
		struct iscsi_cls_session *cls_session;
		struct iscsi_session *session;
		struct iscsi_conn *conn;
		struct iscsi_tm *hdr;
		int rc = FAILED;

		cls_session = starget_to_session(scsi_target(sc->device));
		session = cls_session->dd_data;

		debug_scsi("LU Reset [sc %p lun %u]\n", sc, sc->device->lun);

		mutex_lock(&session->eh_mutex);
		@@ -1760,55 +1764,53 @@ void iscsi_pool_free(struct iscsi_pool *q)
		}
		EXPORT_SYMBOL_GPL(iscsi_pool_free);

		/*
		* iSCSI Session's hostdata organization:
		*
		* ------------------ <== hostdata_session(host->hostdata)
		* \| ptr to class sess\|
		* \|------------------\| <== iscsi_hostdata(host->hostdata)
		* \| iscsi_session \|
		* ------------------
		*/
		void iscsi_host_setup(struct Scsi_Host *shost, uint16_t qdepth)
		{
		if (qdepth > ISCSI_MAX_CMD_PER_LUN \|\| qdepth < 1) {
		if (qdepth != 0)
		printk(KERN_ERR "iscsi: invalid queue depth of %d. "
		"Queue depth must be between 1 and %d.\n",
		qdepth, ISCSI_MAX_CMD_PER_LUN);
		qdepth = ISCSI_DEF_CMD_PER_LUN;
		}

		#define hostdata_privsize(_sz) (sizeof(unsigned long) + _sz + \
		_sz % sizeof(unsigned long))
		shost->transportt->create_work_queue = 1;
		shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out;
		shost->cmd_per_lun = qdepth;
		}
		EXPORT_SYMBOL_GPL(iscsi_host_setup);

		void iscsi_host_teardown(struct Scsi_Host *shost)
		{
		struct iscsi_host *ihost = shost_priv(shost);

		#define hostdata_session(_hostdata) (iscsi_ptr((unsigned long )_hostdata))
		kfree(ihost->netdev);
		kfree(ihost->hwaddress);
		kfree(ihost->initiatorname);
		}
		EXPORT_SYMBOL_GPL(iscsi_host_teardown);

		/**
		* iscsi_session_setup - create iscsi cls session and host and session
		* @scsit: scsi transport template
		* @iscsit: iscsi transport template
		* @cmds_max: scsi host can queue
		* @qdepth: scsi host cmds per lun
		* @shost: scsi host
		* @cmds_max: session can queue
		* @cmd_task_size: LLD ctask private data size
		* @mgmt_task_size: LLD mtask private data size
		* @initial_cmdsn: initial CmdSN
		* @hostno: host no allocated
		*
		* This can be used by software iscsi_transports that allocate
		* a session per scsi host.
		**/
		*/
		struct iscsi_cls_session *
		iscsi_session_setup(struct iscsi_transport *iscsit,
		struct scsi_transport_template *scsit,
		uint16_t cmds_max, uint16_t qdepth,
		int cmd_task_size, int mgmt_task_size,
		uint32_t initial_cmdsn, uint32_t *hostno)
		iscsi_session_setup(struct iscsi_transport iscsit, struct Scsi_Host shost,
		uint16_t cmds_max, int cmd_task_size, int mgmt_task_size,
		uint32_t initial_cmdsn)
		{
		struct Scsi_Host *shost;
		struct iscsi_session *session;
		struct iscsi_cls_session *cls_session;
		int cmd_i;

		if (qdepth > ISCSI_MAX_CMD_PER_LUN \|\| qdepth < 1) {
		if (qdepth != 0)
		printk(KERN_ERR "iscsi: invalid queue depth of %d. "
		"Queue depth must be between 1 and %d.\n",
		qdepth, ISCSI_MAX_CMD_PER_LUN);
		qdepth = ISCSI_DEF_CMD_PER_LUN;
		}

		if (!is_power_of_2(cmds_max) \|\| cmds_max >= ISCSI_MGMT_ITT_OFFSET \|\|
		cmds_max < 2) {
		if (cmds_max != 0)
		@@ -1819,25 +1821,11 @@ iscsi_session_setup(struct iscsi_transport *iscsit,
		cmds_max = ISCSI_DEF_XMIT_CMDS_MAX;
		}

		shost = scsi_host_alloc(iscsit->host_template,
		hostdata_privsize(sizeof(*session)));
		if (!shost)
		cls_session = iscsi_alloc_session(shost, iscsit);
		if (!cls_session)
		return NULL;

		/* the iscsi layer takes one task for reserve */
		shost->can_queue = cmds_max - 1;
		shost->cmd_per_lun = qdepth;
		shost->max_id = 1;
		shost->max_channel = 0;
		shost->max_lun = iscsit->max_lun;
		shost->max_cmd_len = 16;
		shost->transportt = scsit;
		shost->transportt->create_work_queue = 1;
		shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out;
		*hostno = shost->host_no;

		session = iscsi_hostdata(shost->hostdata);
		memset(session, 0, sizeof(struct iscsi_session));
		session = cls_session->dd_data;
		session->cls_session = cls_session;
		session->host = shost;
		session->state = ISCSI_STATE_FREE;
		session->fast_abort = 1;
		@@ -1851,6 +1839,7 @@ iscsi_session_setup(struct iscsi_transport *iscsit,
		session->max_r2t = 1;
		session->tt = iscsit;
		mutex_init(&session->eh_mutex);
		spin_lock_init(&session->lock);

		/* initialize SCSI PDU commands pool */
		if (iscsi_pool_init(&session->cmdpool, session->cmds_max,
		@@ -1868,8 +1857,6 @@ iscsi_session_setup(struct iscsi_transport *iscsit,
		INIT_LIST_HEAD(&ctask->running);
		}

		spin_lock_init(&session->lock);

		/* initialize immediate command pool */
		if (iscsi_pool_init(&session->mgmtpool, session->mgmtpool_max,
		(void***)&session->mgmt_cmds,
		@@ -1887,49 +1874,37 @@ iscsi_session_setup(struct iscsi_transport *iscsit,
		INIT_LIST_HEAD(&mtask->running);
		}

		if (scsi_add_host(shost, NULL))
		goto add_host_fail;

		if (!try_module_get(iscsit->owner))
		goto cls_session_fail;

		cls_session = iscsi_create_session(shost, iscsit, 0);
		if (!cls_session)
		goto module_put;
		(unsigned long)shost->hostdata = (unsigned long)cls_session;
		goto module_get_fail;

		if (iscsi_add_session(cls_session, 0))
		goto cls_session_fail;
		return cls_session;

		module_put:
		module_put(iscsit->owner);
		cls_session_fail:
		scsi_remove_host(shost);
		add_host_fail:
		module_put(iscsit->owner);
		module_get_fail:
		iscsi_pool_free(&session->mgmtpool);
		mgmtpool_alloc_fail:
		iscsi_pool_free(&session->cmdpool);
		cmdpool_alloc_fail:
		scsi_host_put(shost);
		iscsi_free_session(cls_session);
		return NULL;
		}
		EXPORT_SYMBOL_GPL(iscsi_session_setup);

		/**
		* iscsi_session_teardown - destroy session, host, and cls_session
		* shost: scsi host
		* @cls_session: iscsi session
		*
		* This can be used by software iscsi_transports that allocate
		* a session per scsi host.
		**/
		* The driver must have called iscsi_remove_session before
		* calling this.
		*/
		void iscsi_session_teardown(struct iscsi_cls_session *cls_session)
		{
		struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
		struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
		struct iscsi_session *session = cls_session->dd_data;
		struct module *owner = cls_session->transport->owner;

		iscsi_remove_session(cls_session);
		scsi_remove_host(shost);

		iscsi_pool_free(&session->mgmtpool);
		iscsi_pool_free(&session->cmdpool);

		@@ -1938,12 +1913,8 @@ void iscsi_session_teardown(struct iscsi_cls_session *cls_session)
		kfree(session->username);
		kfree(session->username_in);
		kfree(session->targetname);
		kfree(session->netdev);
		kfree(session->hwaddress);
		kfree(session->initiatorname);

		iscsi_free_session(cls_session);
		scsi_host_put(shost);
		iscsi_destroy_session(cls_session);
		module_put(owner);
		}
		EXPORT_SYMBOL_GPL(iscsi_session_teardown);
		@@ -1956,7 +1927,7 @@ EXPORT_SYMBOL_GPL(iscsi_session_teardown);
		struct iscsi_cls_conn *
		iscsi_conn_setup(struct iscsi_cls_session *cls_session, uint32_t conn_idx)
		{
		struct iscsi_session *session = class_to_transport_session(cls_session);
		struct iscsi_session *session = cls_session->dd_data;
		struct iscsi_conn *conn;
		struct iscsi_cls_conn *cls_conn;
		char *data;
		@@ -2140,7 +2111,7 @@ int iscsi_conn_start(struct iscsi_cls_conn *cls_conn)
		}
		spin_unlock_bh(&session->lock);

		iscsi_unblock_session(session_to_cls(session));
		iscsi_unblock_session(session->cls_session);
		wake_up(&conn->ehwait);
		return 0;
		}
		@@ -2225,7 +2196,7 @@ static void iscsi_start_session_recovery(struct iscsi_session *session,
		if (session->state == ISCSI_STATE_IN_RECOVERY &&
		old_stop_stage != STOP_CONN_RECOVER) {
		debug_scsi("blocking session\n");
		iscsi_block_session(session_to_cls(session));
		iscsi_block_session(session->cls_session);
		}
		}

		@@ -2260,7 +2231,7 @@ EXPORT_SYMBOL_GPL(iscsi_conn_stop);
		int iscsi_conn_bind(struct iscsi_cls_session *cls_session,
		struct iscsi_cls_conn *cls_conn, int is_leading)
		{
		struct iscsi_session *session = class_to_transport_session(cls_session);
		struct iscsi_session *session = cls_session->dd_data;
		struct iscsi_conn *conn = cls_conn->dd_data;

		spin_lock_bh(&session->lock);
		@@ -2410,8 +2381,7 @@ EXPORT_SYMBOL_GPL(iscsi_set_param);
		int iscsi_session_get_param(struct iscsi_cls_session *cls_session,
		enum iscsi_param param, char *buf)
		{
		struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
		struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
		struct iscsi_session *session = cls_session->dd_data;
		int len;

		switch(param) {
		@@ -2525,29 +2495,34 @@ EXPORT_SYMBOL_GPL(iscsi_conn_get_param);
		int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param,
		char *buf)
		{
		struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
		struct iscsi_host *ihost = shost_priv(shost);
		int len;

		switch (param) {
		case ISCSI_HOST_PARAM_NETDEV_NAME:
		if (!session->netdev)
		if (!ihost->netdev)
		len = sprintf(buf, "%s\n", "default");
		else
		len = sprintf(buf, "%s\n", session->netdev);
		len = sprintf(buf, "%s\n", ihost->netdev);
		break;
		case ISCSI_HOST_PARAM_HWADDRESS:
		if (!session->hwaddress)
		if (!ihost->hwaddress)
		len = sprintf(buf, "%s\n", "default");
		else
		len = sprintf(buf, "%s\n", session->hwaddress);
		len = sprintf(buf, "%s\n", ihost->hwaddress);
		break;
		case ISCSI_HOST_PARAM_INITIATOR_NAME:
		if (!session->initiatorname)
		if (!ihost->initiatorname)
		len = sprintf(buf, "%s\n", "unknown");
		else
		len = sprintf(buf, "%s\n", session->initiatorname);
		len = sprintf(buf, "%s\n", ihost->initiatorname);
		break;

		case ISCSI_HOST_PARAM_IPADDRESS:
		if (!strlen(ihost->local_address))
		len = sprintf(buf, "%s\n", "unknown");
		else
		len = sprintf(buf, "%s\n",
		ihost->local_address);
		default:
		return -ENOSYS;
		}
		@@ -2559,20 +2534,20 @@ EXPORT_SYMBOL_GPL(iscsi_host_get_param);
		int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param,
		char *buf, int buflen)
		{
		struct iscsi_session *session = iscsi_hostdata(shost->hostdata);
		struct iscsi_host *ihost = shost_priv(shost);

		switch (param) {
		case ISCSI_HOST_PARAM_NETDEV_NAME:
		if (!session->netdev)
		session->netdev = kstrdup(buf, GFP_KERNEL);
		if (!ihost->netdev)
		ihost->netdev = kstrdup(buf, GFP_KERNEL);
		break;
		case ISCSI_HOST_PARAM_HWADDRESS:
		if (!session->hwaddress)
		session->hwaddress = kstrdup(buf, GFP_KERNEL);
		if (!ihost->hwaddress)
		ihost->hwaddress = kstrdup(buf, GFP_KERNEL);
		break;
		case ISCSI_HOST_PARAM_INITIATOR_NAME:
		if (!session->initiatorname)
		session->initiatorname = kstrdup(buf, GFP_KERNEL);
		if (!ihost->initiatorname)
		ihost->initiatorname = kstrdup(buf, GFP_KERNEL);
		break;
		default:
		return -ENOSYS;

drivers/scsi/qla4xxx/ql4_os.c

+0 −1

Original line number	Diff line number	Diff line
		@@ -114,7 +114,6 @@ static struct iscsi_transport qla4xxx_iscsi_transport = {
		ISCSI_HOST_IPADDRESS \|
		ISCSI_HOST_INITIATOR_NAME,
		.sessiondata_size = sizeof(struct ddb_entry),
		.host_template = &qla4xxx_driver_template,

		.tgt_dscvr = qla4xxx_tgt_dscvr,
		.get_conn_param = qla4xxx_conn_get_param,

drivers/scsi/scsi_transport_iscsi.c

+1 −4

Original line number	Diff line number	Diff line
		@@ -101,12 +101,10 @@ show_transport_##name(struct device *dev, \
		static DEVICE_ATTR(name, S_IRUGO, show_transport_##name, NULL);

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

		static struct attribute *iscsi_transport_attrs[] = {
		&dev_attr_handle.attr,
		&dev_attr_caps.attr,
		&dev_attr_max_lun.attr,
		NULL,
		};

		@@ -1034,8 +1032,7 @@ iscsi_if_create_session(struct iscsi_internal priv, struct iscsi_uevent ev,
		}
		}

		session = transport->create_session(transport, &priv->t, shost,
		cmds_max, queue_depth,
		session = transport->create_session(shost, cmds_max, queue_depth,
		initial_cmdsn, &host_no);
		if (shost)
		scsi_host_put(shost);

Admin message