[linux-2.6-block.git] / drivers / hwtracing / stm / policy.c

/*
 * System Trace Module (STM) master/channel allocation policy management
 * Copyright (c) 2014, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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.
 *
 * A master/channel allocation policy allows mapping string identifiers to
 * master and channel ranges, where allocation can be done.
 */

#define pr_fmt(fmt)	KBUILD_MODNAME ": " fmt

#include <linux/types.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/configfs.h>
#include <linux/slab.h>
#include <linux/stm.h>
#include "stm.h"

/*
 * STP Master/Channel allocation policy configfs layout.
 */

struct stp_policy {
	struct config_group	group;
	struct stm_device	*stm;
};

struct stp_policy_node {
	struct config_group	group;
	struct stp_policy	*policy;
	unsigned int		first_master;
	unsigned int		last_master;
	unsigned int		first_channel;
	unsigned int		last_channel;
};

static struct configfs_subsystem stp_policy_subsys;

void stp_policy_node_get_ranges(struct stp_policy_node *policy_node,
				unsigned int *mstart, unsigned int *mend,
				unsigned int *cstart, unsigned int *cend)
{
	*mstart	= policy_node->first_master;
	*mend	= policy_node->last_master;
	*cstart	= policy_node->first_channel;
	*cend	= policy_node->last_channel;
}

static inline char *stp_policy_node_name(struct stp_policy_node *policy_node)
{
	return policy_node->group.cg_item.ci_name ? : "<none>";
}

static inline struct stp_policy *to_stp_policy(struct config_item *item)
{
	return item ?
		container_of(to_config_group(item), struct stp_policy, group) :
		NULL;
}

static inline struct stp_policy_node *
to_stp_policy_node(struct config_item *item)
{
	return item ?
		container_of(to_config_group(item), struct stp_policy_node,
			     group) :
		NULL;
}

static ssize_t
stp_policy_node_masters_show(struct config_item *item, char *page)
{
	struct stp_policy_node *policy_node = to_stp_policy_node(item);
	ssize_t count;

	count = sprintf(page, "%u %u\n", policy_node->first_master,
			policy_node->last_master);

	return count;
}

static ssize_t
stp_policy_node_masters_store(struct config_item *item, const char *page,
			      size_t count)
{
	struct stp_policy_node *policy_node = to_stp_policy_node(item);
	unsigned int first, last;
	struct stm_device *stm;
	char *p = (char *)page;
	ssize_t ret = -ENODEV;

	if (sscanf(p, "%u %u", &first, &last) != 2)
		return -EINVAL;

	mutex_lock(&stp_policy_subsys.su_mutex);
	stm = policy_node->policy->stm;
	if (!stm)
		goto unlock;

	/* must be within [sw_start..sw_end], which is an inclusive range */
	if (first > INT_MAX || last > INT_MAX || first > last ||
	    first < stm->data->sw_start ||
	    last > stm->data->sw_end) {
		ret = -ERANGE;
		goto unlock;
	}

	ret = count;
	policy_node->first_master = first;
	policy_node->last_master = last;

unlock:
	mutex_unlock(&stp_policy_subsys.su_mutex);

	return ret;
}

static ssize_t
stp_policy_node_channels_show(struct config_item *item, char *page)
{
	struct stp_policy_node *policy_node = to_stp_policy_node(item);
	ssize_t count;

	count = sprintf(page, "%u %u\n", policy_node->first_channel,
			policy_node->last_channel);

	return count;
}

static ssize_t
stp_policy_node_channels_store(struct config_item *item, const char *page,
			       size_t count)
{
	struct stp_policy_node *policy_node = to_stp_policy_node(item);
	unsigned int first, last;
	struct stm_device *stm;
	char *p = (char *)page;
	ssize_t ret = -ENODEV;

	if (sscanf(p, "%u %u", &first, &last) != 2)
		return -EINVAL;

	mutex_lock(&stp_policy_subsys.su_mutex);
	stm = policy_node->policy->stm;
	if (!stm)
		goto unlock;

	if (first > INT_MAX || last > INT_MAX || first > last ||
	    last >= stm->data->sw_nchannels) {
		ret = -ERANGE;
		goto unlock;
	}

	ret = count;
	policy_node->first_channel = first;
	policy_node->last_channel = last;

unlock:
	mutex_unlock(&stp_policy_subsys.su_mutex);

	return ret;
}

static void stp_policy_node_release(struct config_item *item)
{
	kfree(to_stp_policy_node(item));
}

static struct configfs_item_operations stp_policy_node_item_ops = {
	.release		= stp_policy_node_release,
};

CONFIGFS_ATTR(stp_policy_node_, masters);
CONFIGFS_ATTR(stp_policy_node_, channels);

static struct configfs_attribute *stp_policy_node_attrs[] = {
	&stp_policy_node_attr_masters,
	&stp_policy_node_attr_channels,
	NULL,
};

static struct config_item_type stp_policy_type;
static struct config_item_type stp_policy_node_type;

static struct config_group *
stp_policy_node_make(struct config_group *group, const char *name)
{
	struct stp_policy_node *policy_node, *parent_node;
	struct stp_policy *policy;

	if (group->cg_item.ci_type == &stp_policy_type) {
		policy = container_of(group, struct stp_policy, group);
	} else {
		parent_node = container_of(group, struct stp_policy_node,
					   group);
		policy = parent_node->policy;
	}

	if (!policy->stm)
		return ERR_PTR(-ENODEV);

	policy_node = kzalloc(sizeof(struct stp_policy_node), GFP_KERNEL);
	if (!policy_node)
		return ERR_PTR(-ENOMEM);

	config_group_init_type_name(&policy_node->group, name,
				    &stp_policy_node_type);

	policy_node->policy = policy;

	/* default values for the attributes */
	policy_node->first_master = policy->stm->data->sw_start;
	policy_node->last_master = policy->stm->data->sw_end;
	policy_node->first_channel = 0;
	policy_node->last_channel = policy->stm->data->sw_nchannels - 1;

	return &policy_node->group;
}

static void
stp_policy_node_drop(struct config_group *group, struct config_item *item)
{
	config_item_put(item);
}

static struct configfs_group_operations stp_policy_node_group_ops = {
	.make_group	= stp_policy_node_make,
	.drop_item	= stp_policy_node_drop,
};

static struct config_item_type stp_policy_node_type = {
	.ct_item_ops	= &stp_policy_node_item_ops,
	.ct_group_ops	= &stp_policy_node_group_ops,
	.ct_attrs	= stp_policy_node_attrs,
	.ct_owner	= THIS_MODULE,
};

/*
 * Root group: policies.
 */
static ssize_t stp_policy_device_show(struct config_item *item,
				      char *page)
{
	struct stp_policy *policy = to_stp_policy(item);
	ssize_t count;

	count = sprintf(page, "%s\n",
			(policy && policy->stm) ?
			policy->stm->data->name :
			"<none>");

	return count;
}

CONFIGFS_ATTR_RO(stp_policy_, device);

static struct configfs_attribute *stp_policy_attrs[] = {
	&stp_policy_attr_device,
	NULL,
};

void stp_policy_unbind(struct stp_policy *policy)
{
	struct stm_device *stm = policy->stm;

	/*
	 * stp_policy_release() will not call here if the policy is already
	 * unbound; other users should not either, as no link exists between
	 * this policy and anything else in that case
	 */
	if (WARN_ON_ONCE(!policy->stm))
		return;

	lockdep_assert_held(&stm->policy_mutex);

	stm->policy = NULL;
	policy->stm = NULL;

	stm_put_device(stm);
}

static void stp_policy_release(struct config_item *item)
{
	struct stp_policy *policy = to_stp_policy(item);
	struct stm_device *stm = policy->stm;

	/* a policy *can* be unbound and still exist in configfs tree */
	if (!stm)
		return;

	mutex_lock(&stm->policy_mutex);
	stp_policy_unbind(policy);
	mutex_unlock(&stm->policy_mutex);

	kfree(policy);
}

static struct configfs_item_operations stp_policy_item_ops = {
	.release		= stp_policy_release,
};

static struct configfs_group_operations stp_policy_group_ops = {
	.make_group	= stp_policy_node_make,
};

static struct config_item_type stp_policy_type = {
	.ct_item_ops	= &stp_policy_item_ops,
	.ct_group_ops	= &stp_policy_group_ops,
	.ct_attrs	= stp_policy_attrs,
	.ct_owner	= THIS_MODULE,
};

static struct config_group *
stp_policies_make(struct config_group *group, const char *name)
{
	struct config_group *ret;
	struct stm_device *stm;
	char *devname, *p;

	devname = kasprintf(GFP_KERNEL, "%s", name);
	if (!devname)
		return ERR_PTR(-ENOMEM);

	/*
	 * node must look like <device_name>.<policy_name>, where
	 * <device_name> is the name of an existing stm device; may
	 *               contain dots;
	 * <policy_name> is an arbitrary string; may not contain dots
	 */
	p = strrchr(devname, '.');
	if (!p) {
		kfree(devname);
		return ERR_PTR(-EINVAL);
	}

	*p++ = '\0';

	stm = stm_find_device(devname);
	kfree(devname);

	if (!stm)
		return ERR_PTR(-ENODEV);

	mutex_lock(&stm->policy_mutex);
	if (stm->policy) {
		ret = ERR_PTR(-EBUSY);
		goto unlock_policy;
	}

	stm->policy = kzalloc(sizeof(*stm->policy), GFP_KERNEL);
	if (!stm->policy) {
		ret = ERR_PTR(-ENOMEM);
		goto unlock_policy;
	}

	config_group_init_type_name(&stm->policy->group, name,
				    &stp_policy_type);
	stm->policy->stm = stm;

	ret = &stm->policy->group;

unlock_policy:
	mutex_unlock(&stm->policy_mutex);

	if (IS_ERR(ret))
		stm_put_device(stm);

	return ret;
}

static struct configfs_group_operations stp_policies_group_ops = {
	.make_group	= stp_policies_make,
};

static struct config_item_type stp_policies_type = {
	.ct_group_ops	= &stp_policies_group_ops,
	.ct_owner	= THIS_MODULE,
};

static struct configfs_subsystem stp_policy_subsys = {
	.su_group = {
		.cg_item = {
			.ci_namebuf	= "stp-policy",
			.ci_type	= &stp_policies_type,
		},
	},
};

/*
 * Lock the policy mutex from the outside
 */
static struct stp_policy_node *
__stp_policy_node_lookup(struct stp_policy *policy, char *s)
{
	struct stp_policy_node *policy_node, *ret;
	struct list_head *head = &policy->group.cg_children;
	struct config_item *item;
	char *start, *end = s;

	if (list_empty(head))
		return NULL;

	/* return the first entry if everything else fails */
	item = list_entry(head->next, struct config_item, ci_entry);
	ret = to_stp_policy_node(item);

next:
	for (;;) {
		start = strsep(&end, "/");
		if (!start)
			break;

		if (!*start)
			continue;

		list_for_each_entry(item, head, ci_entry) {
			policy_node = to_stp_policy_node(item);

			if (!strcmp(start,
				    policy_node->group.cg_item.ci_name)) {
				ret = policy_node;

				if (!end)
					goto out;

				head = &policy_node->group.cg_children;
				goto next;
			}
		}
		break;
	}

out:
	return ret;
}


struct stp_policy_node *
stp_policy_node_lookup(struct stm_device *stm, char *s)
{
	struct stp_policy_node *policy_node = NULL;

	mutex_lock(&stp_policy_subsys.su_mutex);

	mutex_lock(&stm->policy_mutex);
	if (stm->policy)
		policy_node = __stp_policy_node_lookup(stm->policy, s);
	mutex_unlock(&stm->policy_mutex);

	if (policy_node)
		config_item_get(&policy_node->group.cg_item);
	mutex_unlock(&stp_policy_subsys.su_mutex);

	return policy_node;
}

void stp_policy_node_put(struct stp_policy_node *policy_node)
{
	config_item_put(&policy_node->group.cg_item);
}

int __init stp_configfs_init(void)
{
	int err;

	config_group_init(&stp_policy_subsys.su_group);
	mutex_init(&stp_policy_subsys.su_mutex);
	err = configfs_register_subsystem(&stp_policy_subsys);

	return err;
}

void __exit stp_configfs_exit(void)
{
	configfs_unregister_subsystem(&stp_policy_subsys);
}
Commit	Line	Data
7bd1d409 AS	1	/*
	2	* System Trace Module (STM) master/channel allocation policy management
	3	* Copyright (c) 2014, Intel Corporation.
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms and conditions of the GNU General Public License,
	7	* version 2, as published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* A master/channel allocation policy allows mapping string identifiers to
	15	* master and channel ranges, where allocation can be done.
	16	*/
	17
	18	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	19
	20	#include <linux/types.h>
	21	#include <linux/module.h>
	22	#include <linux/device.h>
	23	#include <linux/configfs.h>
	24	#include <linux/slab.h>
	25	#include <linux/stm.h>
	26	#include "stm.h"
	27
	28	/*
	29	* STP Master/Channel allocation policy configfs layout.
	30	*/
	31
	32	struct stp_policy {
	33	struct config_group group;
	34	struct stm_device *stm;
	35	};
	36
	37	struct stp_policy_node {
	38	struct config_group group;
	39	struct stp_policy *policy;
	40	unsigned int first_master;
	41	unsigned int last_master;
	42	unsigned int first_channel;
	43	unsigned int last_channel;
	44	};
	45
	46	static struct configfs_subsystem stp_policy_subsys;
	47
	48	void stp_policy_node_get_ranges(struct stp_policy_node *policy_node,
	49	unsigned int mstart, unsigned int mend,
	50	unsigned int cstart, unsigned int cend)
	51	{
	52	*mstart = policy_node->first_master;
	53	*mend = policy_node->last_master;
	54	*cstart = policy_node->first_channel;
	55	*cend = policy_node->last_channel;
	56	}
	57
	58	static inline char stp_policy_node_name(struct stp_policy_node policy_node)
	59	{
	60	return policy_node->group.cg_item.ci_name ? : "<none>";
	61	}
	62
	63	static inline struct stp_policy to_stp_policy(struct config_item item)
	64	{
65	return item ?
66	container_of(to_config_group(item), struct stp_policy, group) :
67	NULL;
68	}
69
70	static inline struct stp_policy_node *
71	to_stp_policy_node(struct config_item *item)
72	{
73	return item ?
74	container_of(to_config_group(item), struct stp_policy_node,
75	group) :
76	NULL;
77	}
78
9aa3d651 LT	79	static ssize_t
9aa3d651 LT	80	stp_policy_node_masters_show(struct config_item item, char page)
7bd1d409	81	{
9aa3d651	82	struct stp_policy_node *policy_node = to_stp_policy_node(item);
7bd1d409 AS	83	ssize_t count;
	84
	85	count = sprintf(page, "%u %u\n", policy_node->first_master,
	86	policy_node->last_master);
	87
	88	return count;
	89	}
	90
	91	static ssize_t
9aa3d651 LT	92	stp_policy_node_masters_store(struct config_item item, const char page,
9aa3d651 LT	93	size_t count)
7bd1d409	94	{
9aa3d651	95	struct stp_policy_node *policy_node = to_stp_policy_node(item);
7bd1d409 AS	96	unsigned int first, last;
	97	struct stm_device *stm;
	98	char p = (char )page;
	99	ssize_t ret = -ENODEV;
	100
	101	if (sscanf(p, "%u %u", &first, &last) != 2)
	102	return -EINVAL;
	103
	104	mutex_lock(&stp_policy_subsys.su_mutex);
	105	stm = policy_node->policy->stm;
	106	if (!stm)
	107	goto unlock;
	108
	109	/* must be within [sw_start..sw_end], which is an inclusive range */
	110	if (first > INT_MAX \|\| last > INT_MAX \|\| first > last \|\|
	111	first < stm->data->sw_start \|\|
	112	last > stm->data->sw_end) {
	113	ret = -ERANGE;
	114	goto unlock;
	115	}
	116
	117	ret = count;
	118	policy_node->first_master = first;
	119	policy_node->last_master = last;
	120
	121	unlock:
	122	mutex_unlock(&stp_policy_subsys.su_mutex);
	123
	124	return ret;
	125	}
	126
	127	static ssize_t
9aa3d651	128	stp_policy_node_channels_show(struct config_item item, char page)
7bd1d409	129	{
9aa3d651	130	struct stp_policy_node *policy_node = to_stp_policy_node(item);
7bd1d409 AS	131	ssize_t count;
	132
	133	count = sprintf(page, "%u %u\n", policy_node->first_channel,
	134	policy_node->last_channel);
	135
	136	return count;
	137	}
	138
	139	static ssize_t
9aa3d651 LT	140	stp_policy_node_channels_store(struct config_item item, const char page,
9aa3d651 LT	141	size_t count)
7bd1d409	142	{
9aa3d651	143	struct stp_policy_node *policy_node = to_stp_policy_node(item);
7bd1d409 AS	144	unsigned int first, last;
	145	struct stm_device *stm;
	146	char p = (char )page;
	147	ssize_t ret = -ENODEV;
	148
	149	if (sscanf(p, "%u %u", &first, &last) != 2)
	150	return -EINVAL;
	151
	152	mutex_lock(&stp_policy_subsys.su_mutex);
	153	stm = policy_node->policy->stm;
	154	if (!stm)
	155	goto unlock;
	156
	157	if (first > INT_MAX \|\| last > INT_MAX \|\| first > last \|\|
	158	last >= stm->data->sw_nchannels) {
	159	ret = -ERANGE;
	160	goto unlock;
	161	}
	162
	163	ret = count;
	164	policy_node->first_channel = first;
	165	policy_node->last_channel = last;
	166
	167	unlock:
	168	mutex_unlock(&stp_policy_subsys.su_mutex);
	169
	170	return ret;
	171	}
	172
	173	static void stp_policy_node_release(struct config_item *item)
	174	{
	175	kfree(to_stp_policy_node(item));
	176	}
	177
7bd1d409 AS	178	static struct configfs_item_operations stp_policy_node_item_ops = {
7bd1d409 AS	179	.release = stp_policy_node_release,
7bd1d409 AS	180	};
7bd1d409 AS	181
9aa3d651 LT	182	CONFIGFS_ATTR(stp_policy_node_, masters);
9aa3d651 LT	183	CONFIGFS_ATTR(stp_policy_node_, channels);
7bd1d409 AS	184
7bd1d409 AS	185	static struct configfs_attribute *stp_policy_node_attrs[] = {
9aa3d651 LT	186	&stp_policy_node_attr_masters,
9aa3d651 LT	187	&stp_policy_node_attr_channels,
7bd1d409 AS	188	NULL,
	189	};
	190
	191	static struct config_item_type stp_policy_type;
	192	static struct config_item_type stp_policy_node_type;
	193
	194	static struct config_group *
	195	stp_policy_node_make(struct config_group group, const char name)
	196	{
	197	struct stp_policy_node policy_node, parent_node;
	198	struct stp_policy *policy;
	199
	200	if (group->cg_item.ci_type == &stp_policy_type) {
	201	policy = container_of(group, struct stp_policy, group);
	202	} else {
	203	parent_node = container_of(group, struct stp_policy_node,
	204	group);
	205	policy = parent_node->policy;
	206	}
	207
	208	if (!policy->stm)
	209	return ERR_PTR(-ENODEV);
	210
	211	policy_node = kzalloc(sizeof(struct stp_policy_node), GFP_KERNEL);
	212	if (!policy_node)
	213	return ERR_PTR(-ENOMEM);
	214
	215	config_group_init_type_name(&policy_node->group, name,
	216	&stp_policy_node_type);
	217
	218	policy_node->policy = policy;
	219
	220	/* default values for the attributes */
	221	policy_node->first_master = policy->stm->data->sw_start;
	222	policy_node->last_master = policy->stm->data->sw_end;
	223	policy_node->first_channel = 0;
	224	policy_node->last_channel = policy->stm->data->sw_nchannels - 1;
	225
	226	return &policy_node->group;
	227	}
	228
	229	static void
	230	stp_policy_node_drop(struct config_group group, struct config_item item)
	231	{
	232	config_item_put(item);
	233	}
	234
	235	static struct configfs_group_operations stp_policy_node_group_ops = {
	236	.make_group = stp_policy_node_make,
	237	.drop_item = stp_policy_node_drop,
	238	};
	239
	240	static struct config_item_type stp_policy_node_type = {
	241	.ct_item_ops = &stp_policy_node_item_ops,
	242	.ct_group_ops = &stp_policy_node_group_ops,
	243	.ct_attrs = stp_policy_node_attrs,
	244	.ct_owner = THIS_MODULE,
	245	};
	246
	247	/*
	248	* Root group: policies.
	249	*/
9aa3d651 LT	250	static ssize_t stp_policy_device_show(struct config_item *item,
9aa3d651 LT	251	char *page)
7bd1d409 AS	252	{
	253	struct stp_policy *policy = to_stp_policy(item);
	254	ssize_t count;
	255
	256	count = sprintf(page, "%s\n",
	257	(policy && policy->stm) ?
	258	policy->stm->data->name :
	259	"<none>");
	260
	261	return count;
	262	}
	263
9aa3d651 LT	264	CONFIGFS_ATTR_RO(stp_policy_, device);
	265
	266	static struct configfs_attribute *stp_policy_attrs[] = {
	267	&stp_policy_attr_device,
	268	NULL,
	269	};
	270
7bd1d409 AS	271	void stp_policy_unbind(struct stp_policy *policy)
	272	{
	273	struct stm_device *stm = policy->stm;
	274
4c127fd1 AS	275	/*
	276	* stp_policy_release() will not call here if the policy is already
	277	* unbound; other users should not either, as no link exists between
	278	* this policy and anything else in that case
	279	*/
7bd1d409 AS	280	if (WARN_ON_ONCE(!policy->stm))
	281	return;
	282
4c127fd1	283	lockdep_assert_held(&stm->policy_mutex);
7bd1d409	284
4c127fd1	285	stm->policy = NULL;
7bd1d409 AS	286	policy->stm = NULL;
	287
	288	stm_put_device(stm);
	289	}
	290
	291	static void stp_policy_release(struct config_item *item)
	292	{
	293	struct stp_policy *policy = to_stp_policy(item);
4c127fd1	294	struct stm_device *stm = policy->stm;
7bd1d409	295
4c127fd1 AS	296	/* a policy can be unbound and still exist in configfs tree */
	297	if (!stm)
	298	return;
	299
	300	mutex_lock(&stm->policy_mutex);
7bd1d409	301	stp_policy_unbind(policy);
4c127fd1 AS	302	mutex_unlock(&stm->policy_mutex);
4c127fd1 AS	303
7bd1d409 AS	304	kfree(policy);
	305	}
	306
	307	static struct configfs_item_operations stp_policy_item_ops = {
	308	.release = stp_policy_release,
7bd1d409 AS	309	};
	310
	311	static struct configfs_group_operations stp_policy_group_ops = {
	312	.make_group = stp_policy_node_make,
	313	};
	314
	315	static struct config_item_type stp_policy_type = {
	316	.ct_item_ops = &stp_policy_item_ops,
	317	.ct_group_ops = &stp_policy_group_ops,
	318	.ct_attrs = stp_policy_attrs,
	319	.ct_owner = THIS_MODULE,
	320	};
	321
	322	static struct config_group *
	323	stp_policies_make(struct config_group group, const char name)
	324	{
	325	struct config_group *ret;
	326	struct stm_device *stm;
	327	char devname, p;
	328
	329	devname = kasprintf(GFP_KERNEL, "%s", name);
	330	if (!devname)
	331	return ERR_PTR(-ENOMEM);
	332
	333	/*
	334	* node must look like <device_name>.<policy_name>, where
59be422e AS	335	* <device_name> is the name of an existing stm device; may
	336	* contain dots;
	337	* <policy_name> is an arbitrary string; may not contain dots
7bd1d409	338	*/
59be422e	339	p = strrchr(devname, '.');
7bd1d409 AS	340	if (!p) {
	341	kfree(devname);
	342	return ERR_PTR(-EINVAL);
	343	}
	344
	345	*p++ = '\0';
	346
	347	stm = stm_find_device(devname);
	348	kfree(devname);
	349
	350	if (!stm)
	351	return ERR_PTR(-ENODEV);
	352
	353	mutex_lock(&stm->policy_mutex);
	354	if (stm->policy) {
	355	ret = ERR_PTR(-EBUSY);
	356	goto unlock_policy;
	357	}
	358
	359	stm->policy = kzalloc(sizeof(*stm->policy), GFP_KERNEL);
	360	if (!stm->policy) {
	361	ret = ERR_PTR(-ENOMEM);
	362	goto unlock_policy;
	363	}
	364
	365	config_group_init_type_name(&stm->policy->group, name,
	366	&stp_policy_type);
	367	stm->policy->stm = stm;
	368
	369	ret = &stm->policy->group;
	370
	371	unlock_policy:
	372	mutex_unlock(&stm->policy_mutex);
	373
	374	if (IS_ERR(ret))
	375	stm_put_device(stm);
	376
	377	return ret;
	378	}
	379
	380	static struct configfs_group_operations stp_policies_group_ops = {
	381	.make_group = stp_policies_make,
	382	};
	383
	384	static struct config_item_type stp_policies_type = {
	385	.ct_group_ops = &stp_policies_group_ops,
	386	.ct_owner = THIS_MODULE,
	387	};
	388
	389	static struct configfs_subsystem stp_policy_subsys = {
	390	.su_group = {
	391	.cg_item = {
	392	.ci_namebuf = "stp-policy",
	393	.ci_type = &stp_policies_type,
	394	},
	395	},
	396	};
	397
	398	/*
	399	* Lock the policy mutex from the outside
	400	*/
	401	static struct stp_policy_node *
	402	__stp_policy_node_lookup(struct stp_policy policy, char s)
	403	{
404	struct stp_policy_node policy_node, ret;
405	struct list_head *head = &policy->group.cg_children;
406	struct config_item *item;
407	char start, end = s;
408
409	if (list_empty(head))
410	return NULL;
411
412	/* return the first entry if everything else fails */
413	item = list_entry(head->next, struct config_item, ci_entry);
414	ret = to_stp_policy_node(item);
415
416	next:
417	for (;;) {
418	start = strsep(&end, "/");
419	if (!start)
420	break;
421
422	if (!*start)
423	continue;
424
425	list_for_each_entry(item, head, ci_entry) {
426	policy_node = to_stp_policy_node(item);
427
428	if (!strcmp(start,
429	policy_node->group.cg_item.ci_name)) {
430	ret = policy_node;
431
432	if (!end)
433	goto out;
434
435	head = &policy_node->group.cg_children;
436	goto next;
437	}
438	}
439	break;
440	}
441
442	out:
443	return ret;
444	}
445
446
447	struct stp_policy_node *
448	stp_policy_node_lookup(struct stm_device stm, char s)
449	{
450	struct stp_policy_node *policy_node = NULL;
451
452	mutex_lock(&stp_policy_subsys.su_mutex);
453
454	mutex_lock(&stm->policy_mutex);
455	if (stm->policy)
456	policy_node = __stp_policy_node_lookup(stm->policy, s);
457	mutex_unlock(&stm->policy_mutex);
458
459	if (policy_node)
460	config_item_get(&policy_node->group.cg_item);
461	mutex_unlock(&stp_policy_subsys.su_mutex);
462
463	return policy_node;
464	}
465
466	void stp_policy_node_put(struct stp_policy_node *policy_node)
467	{
468	config_item_put(&policy_node->group.cg_item);
469	}
470
471	int __init stp_configfs_init(void)
472	{
473	int err;
474
475	config_group_init(&stp_policy_subsys.su_group);
476	mutex_init(&stp_policy_subsys.su_mutex);
477	err = configfs_register_subsystem(&stp_policy_subsys);
478
479	return err;
480	}
481
482	void __exit stp_configfs_exit(void)
483	{
484	configfs_unregister_subsystem(&stp_policy_subsys);
485	}