[thirdparty/kernel/stable.git] / drivers / target / tcm_fc / tfc_conf.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*******************************************************************************
 * Filename:  tcm_fc.c
 *
 * This file contains the configfs implementation for TCM_fc fabric node.
 * Based on tcm_loop_configfs.c
 *
 * Copyright (c) 2010 Cisco Systems, Inc.
 * Copyright (c) 2009,2010 Rising Tide, Inc.
 * Copyright (c) 2009,2010 Linux-iSCSI.org
 *
 * Copyright (c) 2009,2010 Nicholas A. Bellinger <nab@linux-iscsi.org>
 *
 ****************************************************************************/

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <generated/utsrelease.h>
#include <linux/utsname.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/kthread.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/configfs.h>
#include <linux/kernel.h>
#include <linux/ctype.h>
#include <asm/unaligned.h>
#include <scsi/libfc.h>

#include <target/target_core_base.h>
#include <target/target_core_fabric.h>

#include "tcm_fc.h"

static LIST_HEAD(ft_wwn_list);
DEFINE_MUTEX(ft_lport_lock);

unsigned int ft_debug_logging;
module_param_named(debug_logging, ft_debug_logging, int, S_IRUGO|S_IWUSR);
MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");

/*
 * Parse WWN.
 * If strict, we require lower-case hex and colon separators to be sure
 * the name is the same as what would be generated by ft_format_wwn()
 * so the name and wwn are mapped one-to-one.
 */
static ssize_t ft_parse_wwn(const char *name, u64 *wwn, int strict)
{
	const char *cp;
	char c;
	u32 byte = 0;
	u32 pos = 0;
	u32 err;
	int val;

	*wwn = 0;
	for (cp = name; cp < &name[FT_NAMELEN - 1]; cp++) {
		c = *cp;
		if (c == '\n' && cp[1] == '\0')
			continue;
		if (strict && pos++ == 2 && byte++ < 7) {
			pos = 0;
			if (c == ':')
				continue;
			err = 1;
			goto fail;
		}
		if (c == '\0') {
			err = 2;
			if (strict && byte != 8)
				goto fail;
			return cp - name;
		}
		err = 3;
		val = hex_to_bin(c);
		if (val < 0 || (strict && isupper(c)))
			goto fail;
		*wwn = (*wwn << 4) | val;
	}
	err = 4;
fail:
	pr_debug("err %u len %zu pos %u byte %u\n",
		    err, cp - name, pos, byte);
	return -1;
}

ssize_t ft_format_wwn(char *buf, size_t len, u64 wwn)
{
	u8 b[8];

	put_unaligned_be64(wwn, b);
	return snprintf(buf, len,
		 "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x",
		 b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]);
}

static ssize_t ft_wwn_show(void *arg, char *buf)
{
	u64 *wwn = arg;
	ssize_t len;

	len = ft_format_wwn(buf, PAGE_SIZE - 2, *wwn);
	buf[len++] = '\n';
	return len;
}

static ssize_t ft_wwn_store(void *arg, const char *buf, size_t len)
{
	ssize_t ret;
	u64 wwn;

	ret = ft_parse_wwn(buf, &wwn, 0);
	if (ret > 0)
		*(u64 *)arg = wwn;
	return ret;
}

/*
 * ACL auth ops.
 */

static ssize_t ft_nacl_port_name_show(struct config_item *item, char *page)
{
	struct se_node_acl *se_nacl = acl_to_nacl(item);
	struct ft_node_acl *acl = container_of(se_nacl,
			struct ft_node_acl, se_node_acl);

	return ft_wwn_show(&acl->node_auth.port_name, page);
}

static ssize_t ft_nacl_port_name_store(struct config_item *item,
		const char *page, size_t count)
{
	struct se_node_acl *se_nacl = acl_to_nacl(item);
	struct ft_node_acl *acl = container_of(se_nacl,
			struct ft_node_acl, se_node_acl);

	return ft_wwn_store(&acl->node_auth.port_name, page, count);
}

static ssize_t ft_nacl_node_name_show(struct config_item *item,
		char *page)
{
	struct se_node_acl *se_nacl = acl_to_nacl(item);
	struct ft_node_acl *acl = container_of(se_nacl,
			struct ft_node_acl, se_node_acl);

	return ft_wwn_show(&acl->node_auth.node_name, page);
}

static ssize_t ft_nacl_node_name_store(struct config_item *item,
		const char *page, size_t count)
{
	struct se_node_acl *se_nacl = acl_to_nacl(item);
	struct ft_node_acl *acl = container_of(se_nacl,
			struct ft_node_acl, se_node_acl);

	return ft_wwn_store(&acl->node_auth.node_name, page, count);
}

CONFIGFS_ATTR(ft_nacl_, node_name);
CONFIGFS_ATTR(ft_nacl_, port_name);

static ssize_t ft_nacl_tag_show(struct config_item *item,
		char *page)
{
	return snprintf(page, PAGE_SIZE, "%s", acl_to_nacl(item)->acl_tag);
}

static ssize_t ft_nacl_tag_store(struct config_item *item,
		const char *page, size_t count)
{
	struct se_node_acl *se_nacl = acl_to_nacl(item);
	int ret;

	ret = core_tpg_set_initiator_node_tag(se_nacl->se_tpg, se_nacl, page);

	if (ret < 0)
		return ret;
	return count;
}

CONFIGFS_ATTR(ft_nacl_, tag);

static struct configfs_attribute *ft_nacl_base_attrs[] = {
	&ft_nacl_attr_port_name,
	&ft_nacl_attr_node_name,
	&ft_nacl_attr_tag,
	NULL,
};

/*
 * ACL ops.
 */

/*
 * Add ACL for an initiator.  The ACL is named arbitrarily.
 * The port_name and/or node_name are attributes.
 */
static int ft_init_nodeacl(struct se_node_acl *nacl, const char *name)
{
	struct ft_node_acl *acl =
		container_of(nacl, struct ft_node_acl, se_node_acl);
	u64 wwpn;

	if (ft_parse_wwn(name, &wwpn, 1) < 0)
		return -EINVAL;

	acl->node_auth.port_name = wwpn;
	return 0;
}

/*
 * local_port port_group (tpg) ops.
 */
static struct se_portal_group *ft_add_tpg(struct se_wwn *wwn, const char *name)
{
	struct ft_lport_wwn *ft_wwn;
	struct ft_tpg *tpg;
	struct workqueue_struct *wq;
	unsigned long index;
	int ret;

	pr_debug("tcm_fc: add tpg %s\n", name);

	/*
	 * Name must be "tpgt_" followed by the index.
	 */
	if (strstr(name, "tpgt_") != name)
		return NULL;

	ret = kstrtoul(name + 5, 10, &index);
	if (ret)
		return NULL;
	if (index > UINT_MAX)
		return NULL;

	if ((index != 1)) {
		pr_err("Error, a single TPG=1 is used for HW port mappings\n");
		return ERR_PTR(-ENOSYS);
	}

	ft_wwn = container_of(wwn, struct ft_lport_wwn, se_wwn);
	tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);
	if (!tpg)
		return NULL;
	tpg->index = index;
	tpg->lport_wwn = ft_wwn;
	INIT_LIST_HEAD(&tpg->lun_list);

	wq = alloc_workqueue("tcm_fc", 0, 1);
	if (!wq) {
		kfree(tpg);
		return NULL;
	}

	ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_FCP);
	if (ret < 0) {
		destroy_workqueue(wq);
		kfree(tpg);
		return NULL;
	}
	tpg->workqueue = wq;

	mutex_lock(&ft_lport_lock);
	ft_wwn->tpg = tpg;
	mutex_unlock(&ft_lport_lock);

	return &tpg->se_tpg;
}

static void ft_del_tpg(struct se_portal_group *se_tpg)
{
	struct ft_tpg *tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
	struct ft_lport_wwn *ft_wwn = tpg->lport_wwn;

	pr_debug("del tpg %s\n",
		    config_item_name(&tpg->se_tpg.tpg_group.cg_item));

	destroy_workqueue(tpg->workqueue);

	/* Wait for sessions to be freed thru RCU, for BUG_ON below */
	synchronize_rcu();

	mutex_lock(&ft_lport_lock);
	ft_wwn->tpg = NULL;
	if (tpg->tport) {
		tpg->tport->tpg = NULL;
		tpg->tport = NULL;
	}
	mutex_unlock(&ft_lport_lock);

	core_tpg_deregister(se_tpg);
	kfree(tpg);
}

/*
 * Verify that an lport is configured to use the tcm_fc module, and return
 * the target port group that should be used.
 *
 * The caller holds ft_lport_lock.
 */
struct ft_tpg *ft_lport_find_tpg(struct fc_lport *lport)
{
	struct ft_lport_wwn *ft_wwn;

	list_for_each_entry(ft_wwn, &ft_wwn_list, ft_wwn_node) {
		if (ft_wwn->wwpn == lport->wwpn)
			return ft_wwn->tpg;
	}
	return NULL;
}

/*
 * target config instance ops.
 */

/*
 * Add lport to allowed config.
 * The name is the WWPN in lower-case ASCII, colon-separated bytes.
 */
static struct se_wwn *ft_add_wwn(
	struct target_fabric_configfs *tf,
	struct config_group *group,
	const char *name)
{
	struct ft_lport_wwn *ft_wwn;
	struct ft_lport_wwn *old_ft_wwn;
	u64 wwpn;

	pr_debug("add wwn %s\n", name);
	if (ft_parse_wwn(name, &wwpn, 1) < 0)
		return NULL;
	ft_wwn = kzalloc(sizeof(*ft_wwn), GFP_KERNEL);
	if (!ft_wwn)
		return NULL;
	ft_wwn->wwpn = wwpn;

	mutex_lock(&ft_lport_lock);
	list_for_each_entry(old_ft_wwn, &ft_wwn_list, ft_wwn_node) {
		if (old_ft_wwn->wwpn == wwpn) {
			mutex_unlock(&ft_lport_lock);
			kfree(ft_wwn);
			return NULL;
		}
	}
	list_add_tail(&ft_wwn->ft_wwn_node, &ft_wwn_list);
	ft_format_wwn(ft_wwn->name, sizeof(ft_wwn->name), wwpn);
	mutex_unlock(&ft_lport_lock);

	return &ft_wwn->se_wwn;
}

static void ft_del_wwn(struct se_wwn *wwn)
{
	struct ft_lport_wwn *ft_wwn = container_of(wwn,
				struct ft_lport_wwn, se_wwn);

	pr_debug("del wwn %s\n", ft_wwn->name);
	mutex_lock(&ft_lport_lock);
	list_del(&ft_wwn->ft_wwn_node);
	mutex_unlock(&ft_lport_lock);

	kfree(ft_wwn);
}

static ssize_t ft_wwn_version_show(struct config_item *item, char *page)
{
	return sprintf(page, "TCM FC " FT_VERSION " on %s/%s on "
		""UTS_RELEASE"\n",  utsname()->sysname, utsname()->machine);
}

CONFIGFS_ATTR_RO(ft_wwn_, version);

static struct configfs_attribute *ft_wwn_attrs[] = {
	&ft_wwn_attr_version,
	NULL,
};

static inline struct ft_tpg *ft_tpg(struct se_portal_group *se_tpg)
{
	return container_of(se_tpg, struct ft_tpg, se_tpg);
}

static char *ft_get_fabric_wwn(struct se_portal_group *se_tpg)
{
	return ft_tpg(se_tpg)->lport_wwn->name;
}

static u16 ft_get_tag(struct se_portal_group *se_tpg)
{
	/*
	 * This tag is used when forming SCSI Name identifier in EVPD=1 0x83
	 * to represent the SCSI Target Port.
	 */
	return ft_tpg(se_tpg)->index;
}

static int ft_check_false(struct se_portal_group *se_tpg)
{
	return 0;
}

static void ft_set_default_node_attr(struct se_node_acl *se_nacl)
{
}

static u32 ft_tpg_get_inst_index(struct se_portal_group *se_tpg)
{
	return ft_tpg(se_tpg)->index;
}

static const struct target_core_fabric_ops ft_fabric_ops = {
	.module =			THIS_MODULE,
	.fabric_name =			"fc",
	.node_acl_size =		sizeof(struct ft_node_acl),
	.tpg_get_wwn =			ft_get_fabric_wwn,
	.tpg_get_tag =			ft_get_tag,
	.tpg_check_demo_mode =		ft_check_false,
	.tpg_check_demo_mode_cache =	ft_check_false,
	.tpg_check_demo_mode_write_protect = ft_check_false,
	.tpg_check_prod_mode_write_protect = ft_check_false,
	.tpg_get_inst_index =		ft_tpg_get_inst_index,
	.check_stop_free =		ft_check_stop_free,
	.release_cmd =			ft_release_cmd,
	.close_session =		ft_sess_close,
	.sess_get_index =		ft_sess_get_index,
	.sess_get_initiator_sid =	NULL,
	.write_pending =		ft_write_pending,
	.set_default_node_attributes =	ft_set_default_node_attr,
	.get_cmd_state =		ft_get_cmd_state,
	.queue_data_in =		ft_queue_data_in,
	.queue_status =			ft_queue_status,
	.queue_tm_rsp =			ft_queue_tm_resp,
	.aborted_task =			ft_aborted_task,
	/*
	 * Setup function pointers for generic logic in
	 * target_core_fabric_configfs.c
	 */
	.fabric_make_wwn =		&ft_add_wwn,
	.fabric_drop_wwn =		&ft_del_wwn,
	.fabric_make_tpg =		&ft_add_tpg,
	.fabric_drop_tpg =		&ft_del_tpg,
	.fabric_init_nodeacl =		&ft_init_nodeacl,

	.tfc_wwn_attrs			= ft_wwn_attrs,
	.tfc_tpg_nacl_base_attrs	= ft_nacl_base_attrs,
};

static struct notifier_block ft_notifier = {
	.notifier_call = ft_lport_notify
};

static int __init ft_init(void)
{
	int ret;

	ret = target_register_template(&ft_fabric_ops);
	if (ret)
		goto out;

	ret = fc_fc4_register_provider(FC_TYPE_FCP, &ft_prov);
	if (ret)
		goto out_unregister_template;

	blocking_notifier_chain_register(&fc_lport_notifier_head, &ft_notifier);
	fc_lport_iterate(ft_lport_add, NULL);
	return 0;

out_unregister_template:
	target_unregister_template(&ft_fabric_ops);
out:
	return ret;
}

static void __exit ft_exit(void)
{
	blocking_notifier_chain_unregister(&fc_lport_notifier_head,
					   &ft_notifier);
	fc_fc4_deregister_provider(FC_TYPE_FCP, &ft_prov);
	fc_lport_iterate(ft_lport_del, NULL);
	target_unregister_template(&ft_fabric_ops);
	synchronize_rcu();
}

MODULE_DESCRIPTION("FC TCM fabric driver " FT_VERSION);
MODULE_LICENSE("GPL");
module_init(ft_init);
module_exit(ft_exit);
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
3699d92a KP	2	/*******************************************************************************
	3	* Filename: tcm_fc.c
	4	*
	5	* This file contains the configfs implementation for TCM_fc fabric node.
	6	* Based on tcm_loop_configfs.c
	7	*
	8	* Copyright (c) 2010 Cisco Systems, Inc.
	9	* Copyright (c) 2009,2010 Rising Tide, Inc.
	10	* Copyright (c) 2009,2010 Linux-iSCSI.org
	11	*
	12	* Copyright (c) 2009,2010 Nicholas A. Bellinger <nab@linux-iscsi.org>
	13	*
3699d92a KP	14	****************************************************************************/
	15
	16	#include <linux/module.h>
	17	#include <linux/moduleparam.h>
3699d92a KP	18	#include <generated/utsrelease.h>
	19	#include <linux/utsname.h>
	20	#include <linux/init.h>
	21	#include <linux/slab.h>
	22	#include <linux/kthread.h>
	23	#include <linux/types.h>
	24	#include <linux/string.h>
	25	#include <linux/configfs.h>
635a2b3f	26	#include <linux/kernel.h>
3699d92a KP	27	#include <linux/ctype.h>
3699d92a KP	28	#include <asm/unaligned.h>
3699d92a KP	29	#include <scsi/libfc.h>
	30
	31	#include <target/target_core_base.h>
c4795fb2	32	#include <target/target_core_fabric.h>
3699d92a KP	33
	34	#include "tcm_fc.h"
	35
705665da	36	static LIST_HEAD(ft_wwn_list);
3699d92a KP	37	DEFINE_MUTEX(ft_lport_lock);
	38
	39	unsigned int ft_debug_logging;
	40	module_param_named(debug_logging, ft_debug_logging, int, S_IRUGO\|S_IWUSR);
	41	MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
	42
	43	/*
	44	* Parse WWN.
	45	* If strict, we require lower-case hex and colon separators to be sure
	46	* the name is the same as what would be generated by ft_format_wwn()
	47	* so the name and wwn are mapped one-to-one.
	48	*/
	49	static ssize_t ft_parse_wwn(const char name, u64 wwn, int strict)
	50	{
	51	const char *cp;
	52	char c;
3699d92a KP	53	u32 byte = 0;
	54	u32 pos = 0;
	55	u32 err;
635a2b3f	56	int val;
3699d92a KP	57
	58	*wwn = 0;
	59	for (cp = name; cp < &name[FT_NAMELEN - 1]; cp++) {
	60	c = *cp;
	61	if (c == '\n' && cp[1] == '\0')
	62	continue;
	63	if (strict && pos++ == 2 && byte++ < 7) {
	64	pos = 0;
	65	if (c == ':')
	66	continue;
	67	err = 1;
	68	goto fail;
	69	}
	70	if (c == '\0') {
	71	err = 2;
	72	if (strict && byte != 8)
	73	goto fail;
	74	return cp - name;
	75	}
	76	err = 3;
635a2b3f AS	77	val = hex_to_bin(c);
635a2b3f AS	78	if (val < 0 \|\| (strict && isupper(c)))
3699d92a	79	goto fail;
635a2b3f	80	wwn = (wwn << 4) \| val;
3699d92a KP	81	}
	82	err = 4;
	83	fail:
6708bb27	84	pr_debug("err %u len %zu pos %u byte %u\n",
3699d92a KP	85	err, cp - name, pos, byte);
	86	return -1;
	87	}
	88
	89	ssize_t ft_format_wwn(char *buf, size_t len, u64 wwn)
	90	{
	91	u8 b[8];
	92
	93	put_unaligned_be64(wwn, b);
	94	return snprintf(buf, len,
	95	"%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x",
	96	b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]);
	97	}
	98
	99	static ssize_t ft_wwn_show(void arg, char buf)
	100	{
	101	u64 *wwn = arg;
	102	ssize_t len;
	103
	104	len = ft_format_wwn(buf, PAGE_SIZE - 2, *wwn);
	105	buf[len++] = '\n';
	106	return len;
	107	}
	108
	109	static ssize_t ft_wwn_store(void arg, const char buf, size_t len)
	110	{
	111	ssize_t ret;
	112	u64 wwn;
	113
	114	ret = ft_parse_wwn(buf, &wwn, 0);
	115	if (ret > 0)
	116	(u64 )arg = wwn;
	117	return ret;
	118	}
	119
	120	/*
	121	* ACL auth ops.
	122	*/
	123
2eafd729	124	static ssize_t ft_nacl_port_name_show(struct config_item item, char page)
3699d92a	125	{
2eafd729	126	struct se_node_acl *se_nacl = acl_to_nacl(item);
3699d92a KP	127	struct ft_node_acl *acl = container_of(se_nacl,
	128	struct ft_node_acl, se_node_acl);
	129
	130	return ft_wwn_show(&acl->node_auth.port_name, page);
	131	}
	132
2eafd729 CH	133	static ssize_t ft_nacl_port_name_store(struct config_item *item,
2eafd729 CH	134	const char *page, size_t count)
3699d92a	135	{
2eafd729	136	struct se_node_acl *se_nacl = acl_to_nacl(item);
3699d92a KP	137	struct ft_node_acl *acl = container_of(se_nacl,
	138	struct ft_node_acl, se_node_acl);
	139
	140	return ft_wwn_store(&acl->node_auth.port_name, page, count);
	141	}
	142
2eafd729 CH	143	static ssize_t ft_nacl_node_name_show(struct config_item *item,
2eafd729 CH	144	char *page)
3699d92a	145	{
2eafd729	146	struct se_node_acl *se_nacl = acl_to_nacl(item);
3699d92a KP	147	struct ft_node_acl *acl = container_of(se_nacl,
	148	struct ft_node_acl, se_node_acl);
	149
	150	return ft_wwn_show(&acl->node_auth.node_name, page);
	151	}
	152
2eafd729 CH	153	static ssize_t ft_nacl_node_name_store(struct config_item *item,
2eafd729 CH	154	const char *page, size_t count)
3699d92a	155	{
2eafd729	156	struct se_node_acl *se_nacl = acl_to_nacl(item);
3699d92a KP	157	struct ft_node_acl *acl = container_of(se_nacl,
	158	struct ft_node_acl, se_node_acl);
	159
	160	return ft_wwn_store(&acl->node_auth.node_name, page, count);
	161	}
	162
2eafd729 CH	163	CONFIGFS_ATTR(ft_nacl_, node_name);
2eafd729 CH	164	CONFIGFS_ATTR(ft_nacl_, port_name);
3699d92a	165
091b7062 AG	166	static ssize_t ft_nacl_tag_show(struct config_item *item,
	167	char *page)
	168	{
	169	return snprintf(page, PAGE_SIZE, "%s", acl_to_nacl(item)->acl_tag);
	170	}
	171
	172	static ssize_t ft_nacl_tag_store(struct config_item *item,
	173	const char *page, size_t count)
	174	{
	175	struct se_node_acl *se_nacl = acl_to_nacl(item);
	176	int ret;
	177
	178	ret = core_tpg_set_initiator_node_tag(se_nacl->se_tpg, se_nacl, page);
	179
	180	if (ret < 0)
	181	return ret;
	182	return count;
	183	}
	184
	185	CONFIGFS_ATTR(ft_nacl_, tag);
	186
3699d92a	187	static struct configfs_attribute *ft_nacl_base_attrs[] = {
2eafd729 CH	188	&ft_nacl_attr_port_name,
2eafd729 CH	189	&ft_nacl_attr_node_name,
091b7062	190	&ft_nacl_attr_tag,
3699d92a KP	191	NULL,
	192	};
	193
	194	/*
	195	* ACL ops.
	196	*/
	197
	198	/*
	199	* Add ACL for an initiator. The ACL is named arbitrarily.
	200	* The port_name and/or node_name are attributes.
	201	*/
c7d6a803	202	static int ft_init_nodeacl(struct se_node_acl nacl, const char name)
3699d92a	203	{
c7d6a803 CH	204	struct ft_node_acl *acl =
c7d6a803 CH	205	container_of(nacl, struct ft_node_acl, se_node_acl);
3699d92a	206	u64 wwpn;
3699d92a KP	207
3699d92a KP	208	if (ft_parse_wwn(name, &wwpn, 1) < 0)
c7d6a803	209	return -EINVAL;
3699d92a	210
3699d92a	211	acl->node_auth.port_name = wwpn;
c7d6a803	212	return 0;
3699d92a KP	213	}
3699d92a KP	214
3699d92a KP	215	/*
	216	* local_port port_group (tpg) ops.
	217	*/
aa090eab	218	static struct se_portal_group ft_add_tpg(struct se_wwn wwn, const char *name)
3699d92a	219	{
705665da	220	struct ft_lport_wwn *ft_wwn;
3699d92a	221	struct ft_tpg *tpg;
06383f10	222	struct workqueue_struct *wq;
3699d92a KP	223	unsigned long index;
	224	int ret;
	225
6708bb27	226	pr_debug("tcm_fc: add tpg %s\n", name);
3699d92a KP	227
	228	/*
	229	* Name must be "tpgt_" followed by the index.
	230	*/
	231	if (strstr(name, "tpgt_") != name)
	232	return NULL;
57103d7f JH	233
	234	ret = kstrtoul(name + 5, 10, &index);
	235	if (ret)
	236	return NULL;
	237	if (index > UINT_MAX)
3699d92a KP	238	return NULL;
3699d92a KP	239
d242c1d7 AG	240	if ((index != 1)) {
	241	pr_err("Error, a single TPG=1 is used for HW port mappings\n");
	242	return ERR_PTR(-ENOSYS);
	243	}
	244
705665da	245	ft_wwn = container_of(wwn, struct ft_lport_wwn, se_wwn);
3699d92a KP	246	tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);
	247	if (!tpg)
	248	return NULL;
	249	tpg->index = index;
705665da	250	tpg->lport_wwn = ft_wwn;
3699d92a	251	INIT_LIST_HEAD(&tpg->lun_list);
3699d92a	252
06383f10 MR	253	wq = alloc_workqueue("tcm_fc", 0, 1);
06383f10 MR	254	if (!wq) {
3699d92a KP	255	kfree(tpg);
	256	return NULL;
	257	}
	258
bc0c94b1	259	ret = core_tpg_register(wwn, &tpg->se_tpg, SCSI_PROTOCOL_FCP);
06383f10 MR	260	if (ret < 0) {
06383f10 MR	261	destroy_workqueue(wq);
3699d92a KP	262	kfree(tpg);
	263	return NULL;
	264	}
06383f10	265	tpg->workqueue = wq;
3699d92a KP	266
3699d92a KP	267	mutex_lock(&ft_lport_lock);
705665da	268	ft_wwn->tpg = tpg;
3699d92a KP	269	mutex_unlock(&ft_lport_lock);
	270
	271	return &tpg->se_tpg;
	272	}
	273
	274	static void ft_del_tpg(struct se_portal_group *se_tpg)
	275	{
	276	struct ft_tpg *tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
705665da	277	struct ft_lport_wwn *ft_wwn = tpg->lport_wwn;
3699d92a	278
6708bb27	279	pr_debug("del tpg %s\n",
3699d92a KP	280	config_item_name(&tpg->se_tpg.tpg_group.cg_item));
3699d92a KP	281
58fc73d1	282	destroy_workqueue(tpg->workqueue);
3699d92a KP	283
	284	/* Wait for sessions to be freed thru RCU, for BUG_ON below */
	285	synchronize_rcu();
	286
	287	mutex_lock(&ft_lport_lock);
705665da	288	ft_wwn->tpg = NULL;
3699d92a KP	289	if (tpg->tport) {
	290	tpg->tport->tpg = NULL;
	291	tpg->tport = NULL;
	292	}
	293	mutex_unlock(&ft_lport_lock);
	294
	295	core_tpg_deregister(se_tpg);
	296	kfree(tpg);
	297	}
	298
	299	/*
	300	* Verify that an lport is configured to use the tcm_fc module, and return
	301	* the target port group that should be used.
	302	*
	303	* The caller holds ft_lport_lock.
	304	*/
	305	struct ft_tpg ft_lport_find_tpg(struct fc_lport lport)
	306	{
705665da	307	struct ft_lport_wwn *ft_wwn;
3699d92a	308
705665da AG	309	list_for_each_entry(ft_wwn, &ft_wwn_list, ft_wwn_node) {
	310	if (ft_wwn->wwpn == lport->wwpn)
	311	return ft_wwn->tpg;
3699d92a KP	312	}
	313	return NULL;
	314	}
	315
	316	/*
	317	* target config instance ops.
	318	*/
	319
	320	/*
	321	* Add lport to allowed config.
	322	* The name is the WWPN in lower-case ASCII, colon-separated bytes.
	323	*/
0d7cb932	324	static struct se_wwn *ft_add_wwn(
3699d92a KP	325	struct target_fabric_configfs *tf,
	326	struct config_group *group,
	327	const char *name)
	328	{
705665da AG	329	struct ft_lport_wwn *ft_wwn;
705665da AG	330	struct ft_lport_wwn *old_ft_wwn;
3699d92a KP	331	u64 wwpn;
3699d92a KP	332
0d7cb932	333	pr_debug("add wwn %s\n", name);
3699d92a KP	334	if (ft_parse_wwn(name, &wwpn, 1) < 0)
3699d92a KP	335	return NULL;
705665da AG	336	ft_wwn = kzalloc(sizeof(*ft_wwn), GFP_KERNEL);
705665da AG	337	if (!ft_wwn)
3699d92a	338	return NULL;
705665da	339	ft_wwn->wwpn = wwpn;
3699d92a KP	340
3699d92a KP	341	mutex_lock(&ft_lport_lock);
705665da AG	342	list_for_each_entry(old_ft_wwn, &ft_wwn_list, ft_wwn_node) {
705665da AG	343	if (old_ft_wwn->wwpn == wwpn) {
3699d92a	344	mutex_unlock(&ft_lport_lock);
705665da	345	kfree(ft_wwn);
3699d92a KP	346	return NULL;
	347	}
	348	}
705665da AG	349	list_add_tail(&ft_wwn->ft_wwn_node, &ft_wwn_list);
705665da AG	350	ft_format_wwn(ft_wwn->name, sizeof(ft_wwn->name), wwpn);
3699d92a KP	351	mutex_unlock(&ft_lport_lock);
3699d92a KP	352
705665da	353	return &ft_wwn->se_wwn;
3699d92a KP	354	}
3699d92a KP	355
0d7cb932	356	static void ft_del_wwn(struct se_wwn *wwn)
3699d92a	357	{
705665da AG	358	struct ft_lport_wwn *ft_wwn = container_of(wwn,
705665da AG	359	struct ft_lport_wwn, se_wwn);
3699d92a	360
0d7cb932	361	pr_debug("del wwn %s\n", ft_wwn->name);
3699d92a	362	mutex_lock(&ft_lport_lock);
705665da	363	list_del(&ft_wwn->ft_wwn_node);
3699d92a KP	364	mutex_unlock(&ft_lport_lock);
3699d92a KP	365
705665da	366	kfree(ft_wwn);
3699d92a KP	367	}
3699d92a KP	368
2eafd729	369	static ssize_t ft_wwn_version_show(struct config_item item, char page)
3699d92a KP	370	{
	371	return sprintf(page, "TCM FC " FT_VERSION " on %s/%s on "
	372	""UTS_RELEASE"\n", utsname()->sysname, utsname()->machine);
	373	}
	374
2eafd729	375	CONFIGFS_ATTR_RO(ft_wwn_, version);
3699d92a KP	376
3699d92a KP	377	static struct configfs_attribute *ft_wwn_attrs[] = {
2eafd729	378	&ft_wwn_attr_version,
3699d92a KP	379	NULL,
	380	};
	381
3868e436 CH	382	static inline struct ft_tpg ft_tpg(struct se_portal_group se_tpg)
	383	{
	384	return container_of(se_tpg, struct ft_tpg, se_tpg);
	385	}
	386
3699d92a KP	387	static char ft_get_fabric_wwn(struct se_portal_group se_tpg)
3699d92a KP	388	{
3868e436	389	return ft_tpg(se_tpg)->lport_wwn->name;
3699d92a KP	390	}
	391
	392	static u16 ft_get_tag(struct se_portal_group *se_tpg)
	393	{
3699d92a KP	394	/*
	395	* This tag is used when forming SCSI Name identifier in EVPD=1 0x83
	396	* to represent the SCSI Target Port.
	397	*/
3868e436	398	return ft_tpg(se_tpg)->index;
3699d92a KP	399	}
	400
	401	static int ft_check_false(struct se_portal_group *se_tpg)
	402	{
	403	return 0;
	404	}
	405
	406	static void ft_set_default_node_attr(struct se_node_acl *se_nacl)
	407	{
	408	}
	409
3699d92a KP	410	static u32 ft_tpg_get_inst_index(struct se_portal_group *se_tpg)
3699d92a KP	411	{
3868e436	412	return ft_tpg(se_tpg)->index;
3699d92a KP	413	}
3699d92a KP	414
9ac8928e CH	415	static const struct target_core_fabric_ops ft_fabric_ops = {
9ac8928e CH	416	.module = THIS_MODULE,
30c7ca93	417	.fabric_name = "fc",
144bc4c2	418	.node_acl_size = sizeof(struct ft_node_acl),
3699d92a KP	419	.tpg_get_wwn = ft_get_fabric_wwn,
3699d92a KP	420	.tpg_get_tag = ft_get_tag,
3699d92a KP	421	.tpg_check_demo_mode = ft_check_false,
	422	.tpg_check_demo_mode_cache = ft_check_false,
	423	.tpg_check_demo_mode_write_protect = ft_check_false,
	424	.tpg_check_prod_mode_write_protect = ft_check_false,
3699d92a KP	425	.tpg_get_inst_index = ft_tpg_get_inst_index,
3699d92a KP	426	.check_stop_free = ft_check_stop_free,
35462975	427	.release_cmd = ft_release_cmd,
3699d92a	428	.close_session = ft_sess_close,
3699d92a KP	429	.sess_get_index = ft_sess_get_index,
	430	.sess_get_initiator_sid = NULL,
	431	.write_pending = ft_write_pending,
3699d92a	432	.set_default_node_attributes = ft_set_default_node_attr,
3699d92a	433	.get_cmd_state = ft_get_cmd_state,
3699d92a KP	434	.queue_data_in = ft_queue_data_in,
	435	.queue_status = ft_queue_status,
	436	.queue_tm_rsp = ft_queue_tm_resp,
131e6abc	437	.aborted_task = ft_aborted_task,
3699d92a KP	438	/*
	439	* Setup function pointers for generic logic in
	440	* target_core_fabric_configfs.c
	441	*/
0d7cb932 AG	442	.fabric_make_wwn = &ft_add_wwn,
0d7cb932 AG	443	.fabric_drop_wwn = &ft_del_wwn,
3699d92a KP	444	.fabric_make_tpg = &ft_add_tpg,
3699d92a KP	445	.fabric_drop_tpg = &ft_del_tpg,
c7d6a803	446	.fabric_init_nodeacl = &ft_init_nodeacl,
3699d92a	447
9ac8928e CH	448	.tfc_wwn_attrs = ft_wwn_attrs,
	449	.tfc_tpg_nacl_base_attrs = ft_nacl_base_attrs,
	450	};
3699d92a KP	451
	452	static struct notifier_block ft_notifier = {
	453	.notifier_call = ft_lport_notify
	454	};
	455
	456	static int __init ft_init(void)
	457	{
9ac8928e CH	458	int ret;
	459
	460	ret = target_register_template(&ft_fabric_ops);
	461	if (ret)
	462	goto out;
	463
	464	ret = fc_fc4_register_provider(FC_TYPE_FCP, &ft_prov);
	465	if (ret)
	466	goto out_unregister_template;
	467
3699d92a KP	468	blocking_notifier_chain_register(&fc_lport_notifier_head, &ft_notifier);
	469	fc_lport_iterate(ft_lport_add, NULL);
	470	return 0;
9ac8928e CH	471
	472	out_unregister_template:
	473	target_unregister_template(&ft_fabric_ops);
	474	out:
	475	return ret;
3699d92a KP	476	}
	477
	478	static void __exit ft_exit(void)
	479	{
	480	blocking_notifier_chain_unregister(&fc_lport_notifier_head,
	481	&ft_notifier);
	482	fc_fc4_deregister_provider(FC_TYPE_FCP, &ft_prov);
	483	fc_lport_iterate(ft_lport_del, NULL);
9ac8928e	484	target_unregister_template(&ft_fabric_ops);
3699d92a KP	485	synchronize_rcu();
	486	}
	487
3699d92a KP	488	MODULE_DESCRIPTION("FC TCM fabric driver " FT_VERSION);
	489	MODULE_LICENSE("GPL");
	490	module_init(ft_init);
	491	module_exit(ft_exit);