Commit c7fd62bc authored by Alexander Shishkin's avatar Alexander Shishkin Committed by Greg Kroah-Hartman
Browse files

stm class: Introduce framing protocol drivers 



At the moment, the stm class applies a certain STP framing pattern to
the data as it is written to the underlying STM device. In order to
allow different framing patterns (aka protocols), this patch introduces
the concept of STP protocol drivers, defines data structures and APIs
for the protocol drivers to use.

Signed-off-by: default avatarAlexander Shishkin <alexander.shishkin@linux.intel.com>
Tested-by: default avatarMathieu Poirier <mathieu.poirier@linaro.org>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent e967b8bd

drivers/hwtracing/stm/core.c

+140 −0
Original line number Diff line number Diff line
@@ -316,11 +316,26 @@ static int stm_output_assign(struct stm_device *stm, unsigned int width, 
	output->master = midx;

	output->channel = cidx;

	output->nr_chans = width;

	if (stm->pdrv->output_open) {

		void *priv = stp_policy_node_priv(policy_node);



		if (WARN_ON_ONCE(!priv))

			goto unlock;



		/* configfs subsys mutex is held by the caller */

		ret = stm->pdrv->output_open(priv, output);

		if (ret)

			goto unlock;

	}



	stm_output_claim(stm, output);

	dev_dbg(&stm->dev, "assigned %u:%u (+%u)\n", midx, cidx, width);



	ret = 0;

unlock:

	if (ret)

		output->nr_chans = 0;



	spin_unlock(&output->lock);

	spin_unlock(&stm->mc_lock);
@@ -333,6 +348,8 @@ static void stm_output_free(struct stm_device *stm, struct stm_output *output) 
	spin_lock(&output->lock);

	if (output->nr_chans)

		stm_output_disclaim(stm, output);

	if (stm->pdrv && stm->pdrv->output_close)

		stm->pdrv->output_close(output);

	spin_unlock(&output->lock);

	spin_unlock(&stm->mc_lock);

}
@@ -349,6 +366,127 @@ static int major_match(struct device *dev, const void *data) 
	return MAJOR(dev->devt) == major;

}



/*

 * Framing protocol management

 * Modules can implement STM protocol drivers and (un-)register them

 * with the STM class framework.

 */

static struct list_head stm_pdrv_head;

static struct mutex stm_pdrv_mutex;



struct stm_pdrv_entry {

	struct list_head			entry;

	const struct stm_protocol_driver	*pdrv;

	const struct config_item_type		*node_type;

};



static const struct stm_pdrv_entry *

__stm_lookup_protocol(const char *name)

{

	struct stm_pdrv_entry *pe;



	/*

	 * If no name is given (NULL or ""), fall back to "p_basic".

	 */

	if (!name || !*name)

		name = "p_basic";



	list_for_each_entry(pe, &stm_pdrv_head, entry) {

		if (!strcmp(name, pe->pdrv->name))

			return pe;

	}



	return NULL;

}



int stm_register_protocol(const struct stm_protocol_driver *pdrv)

{

	struct stm_pdrv_entry *pe = NULL;

	int ret = -ENOMEM;



	mutex_lock(&stm_pdrv_mutex);



	if (__stm_lookup_protocol(pdrv->name)) {

		ret = -EEXIST;

		goto unlock;

	}



	pe = kzalloc(sizeof(*pe), GFP_KERNEL);

	if (!pe)

		goto unlock;



	if (pdrv->policy_attr) {

		pe->node_type = get_policy_node_type(pdrv->policy_attr);

		if (!pe->node_type)

			goto unlock;

	}



	list_add_tail(&pe->entry, &stm_pdrv_head);

	pe->pdrv = pdrv;



	ret = 0;

unlock:

	mutex_unlock(&stm_pdrv_mutex);



	if (ret)

		kfree(pe);



	return ret;

}

EXPORT_SYMBOL_GPL(stm_register_protocol);



void stm_unregister_protocol(const struct stm_protocol_driver *pdrv)

{

	struct stm_pdrv_entry *pe, *iter;



	mutex_lock(&stm_pdrv_mutex);



	list_for_each_entry_safe(pe, iter, &stm_pdrv_head, entry) {

		if (pe->pdrv == pdrv) {

			list_del(&pe->entry);



			if (pe->node_type) {

				kfree(pe->node_type->ct_attrs);

				kfree(pe->node_type);

			}

			kfree(pe);

			break;

		}

	}



	mutex_unlock(&stm_pdrv_mutex);

}

EXPORT_SYMBOL_GPL(stm_unregister_protocol);



static bool stm_get_protocol(const struct stm_protocol_driver *pdrv)

{

	return try_module_get(pdrv->owner);

}



void stm_put_protocol(const struct stm_protocol_driver *pdrv)

{

	module_put(pdrv->owner);

}



int stm_lookup_protocol(const char *name,

			const struct stm_protocol_driver **pdrv,

			const struct config_item_type **node_type)

{

	const struct stm_pdrv_entry *pe;



	mutex_lock(&stm_pdrv_mutex);



	pe = __stm_lookup_protocol(name);

	if (pe && pe->pdrv && stm_get_protocol(pe->pdrv)) {

		*pdrv = pe->pdrv;

		*node_type = pe->node_type;

	}



	mutex_unlock(&stm_pdrv_mutex);



	return pe ? 0 : -ENOENT;

}



static int stm_char_open(struct inode *inode, struct file *file)

{

	struct stm_file *stmf;
@@ -1176,6 +1314,8 @@ static int __init stm_core_init(void) 
		goto err_src;



	init_srcu_struct(&stm_source_srcu);

	INIT_LIST_HEAD(&stm_pdrv_head);

	mutex_init(&stm_pdrv_mutex);



	stm_core_up++;

drivers/hwtracing/stm/policy.c

+135 −10
Original line number Diff line number Diff line
@@ -33,8 +33,18 @@ struct stp_policy_node { 
	unsigned int		last_master;

	unsigned int		first_channel;

	unsigned int		last_channel;

	/* this is the one that's exposed to the attributes */

	unsigned char		priv[0];

};



void *stp_policy_node_priv(struct stp_policy_node *pn)

{

	if (!pn)

		return NULL;



	return pn->priv;

}



static struct configfs_subsystem stp_policy_subsys;



void stp_policy_node_get_ranges(struct stp_policy_node *policy_node,
@@ -68,6 +78,14 @@ to_stp_policy_node(struct config_item *item) 
		NULL;

}



void *to_pdrv_policy_node(struct config_item *item)

{

	struct stp_policy_node *node = to_stp_policy_node(item);



	return stp_policy_node_priv(node);

}

EXPORT_SYMBOL_GPL(to_pdrv_policy_node);



static ssize_t

stp_policy_node_masters_show(struct config_item *item, char *page)

{
@@ -163,7 +181,9 @@ unlock: 


static void stp_policy_node_release(struct config_item *item)

{

	kfree(to_stp_policy_node(item));

	struct stp_policy_node *node = to_stp_policy_node(item);



	kfree(node);

}



static struct configfs_item_operations stp_policy_node_item_ops = {
@@ -182,10 +202,61 @@ static struct configfs_attribute *stp_policy_node_attrs[] = { 
static const struct config_item_type stp_policy_type;

static const struct config_item_type stp_policy_node_type;



/* lifted from arch/x86/events/core.c */

static struct configfs_attribute **merge_attr(struct configfs_attribute **a, struct configfs_attribute **b)

{

	struct configfs_attribute **new;

	int j, i;



	for (j = 0; a[j]; j++)

		;

	for (i = 0; b[i]; i++)

		j++;

	j++;



	new = kmalloc_array(j, sizeof(struct configfs_attribute *),

			    GFP_KERNEL);

	if (!new)

		return NULL;



	j = 0;

	for (i = 0; a[i]; i++)

		new[j++] = a[i];

	for (i = 0; b[i]; i++)

		new[j++] = b[i];

	new[j] = NULL;



	return new;

}



const struct config_item_type *

get_policy_node_type(struct configfs_attribute **attrs)

{

	struct config_item_type *type;

	struct configfs_attribute **merged;



	type = kmemdup(&stp_policy_node_type, sizeof(stp_policy_node_type),

		       GFP_KERNEL);

	if (!type)

		return NULL;



	merged = merge_attr(stp_policy_node_attrs, attrs);

	if (!merged) {

		kfree(type);

		return NULL;

	}



	type->ct_attrs = merged;



	return type;

}



static struct config_group *

stp_policy_node_make(struct config_group *group, const char *name)

{

	const struct config_item_type *type = &stp_policy_node_type;

	struct stp_policy_node *policy_node, *parent_node;

	const struct stm_protocol_driver *pdrv;

	struct stp_policy *policy;



	if (group->cg_item.ci_type == &stp_policy_type) {
@@ -199,12 +270,20 @@ stp_policy_node_make(struct config_group *group, const char *name) 
	if (!policy->stm)

		return ERR_PTR(-ENODEV);



	policy_node = kzalloc(sizeof(struct stp_policy_node), GFP_KERNEL);

	pdrv = policy->stm->pdrv;

	policy_node =

		kzalloc(offsetof(struct stp_policy_node, priv[pdrv->priv_sz]),

			GFP_KERNEL);

	if (!policy_node)

		return ERR_PTR(-ENOMEM);



	config_group_init_type_name(&policy_node->group, name,

				    &stp_policy_node_type);

	if (pdrv->policy_node_init)

		pdrv->policy_node_init((void *)policy_node->priv);



	if (policy->stm->pdrv_node_type)

		type = policy->stm->pdrv_node_type;



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



	policy_node->policy = policy;
@@ -254,8 +333,25 @@ static ssize_t stp_policy_device_show(struct config_item *item, 


CONFIGFS_ATTR_RO(stp_policy_, device);



static ssize_t stp_policy_protocol_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->pdrv->name :

			"<none>");



	return count;

}



CONFIGFS_ATTR_RO(stp_policy_, protocol);



static struct configfs_attribute *stp_policy_attrs[] = {

	&stp_policy_attr_device,

	&stp_policy_attr_protocol,

	NULL,

};
@@ -276,6 +372,7 @@ void stp_policy_unbind(struct stp_policy *policy) 
	stm->policy = NULL;

	policy->stm = NULL;



	stm_put_protocol(stm->pdrv);

	stm_put_device(stm);

}
@@ -313,9 +410,12 @@ static const struct config_item_type stp_policy_type = { 
static struct config_group *

stp_policy_make(struct config_group *group, const char *name)

{

	const struct config_item_type *pdrv_node_type;

	const struct stm_protocol_driver *pdrv;

	char *devname, *proto, *p;

	struct config_group *ret;

	struct stm_device *stm;

	char *devname, *p;

	int err;



	devname = kasprintf(GFP_KERNEL, "%s", name);

	if (!devname)
@@ -326,6 +426,7 @@ stp_policy_make(struct config_group *group, const char *name) 
	 * <device_name> is the name of an existing stm device; may

	 *               contain dots;

	 * <policy_name> is an arbitrary string; may not contain dots

	 * <device_name>:<protocol_name>.<policy_name>

	 */

	p = strrchr(devname, '.');

	if (!p) {
@@ -335,11 +436,29 @@ stp_policy_make(struct config_group *group, const char *name) 


	*p = '\0';



	/*

	 * look for ":<protocol_name>":

	 *  + no protocol suffix: fall back to whatever is available;

	 *  + unknown protocol: fail the whole thing

	 */

	proto = strrchr(devname, ':');

	if (proto)

		*proto++ = '\0';



	stm = stm_find_device(devname);

	if (!stm) {

		kfree(devname);

		return ERR_PTR(-ENODEV);

	}



	if (!stm)

	err = stm_lookup_protocol(proto, &pdrv, &pdrv_node_type);

	kfree(devname);



	/* We don't have any protocol drivers yet */

	if (err != -ENOENT) {

		stm_put_device(stm);

		return ERR_PTR(-ENODEV);

	}



	mutex_lock(&stm->policy_mutex);

	if (stm->policy) {
@@ -349,21 +468,27 @@ stp_policy_make(struct config_group *group, const char *name) 


	stm->policy = kzalloc(sizeof(*stm->policy), GFP_KERNEL);

	if (!stm->policy) {

		ret = ERR_PTR(-ENOMEM);

		goto unlock_policy;

		mutex_unlock(&stm->policy_mutex);

		stm_put_protocol(pdrv);

		stm_put_device(stm);

		return ERR_PTR(-ENOMEM);

	}



	config_group_init_type_name(&stm->policy->group, name,

				    &stp_policy_type);

	stm->policy->stm = stm;



	stm->pdrv = pdrv;

	stm->pdrv_node_type = pdrv_node_type;

	stm->policy->stm = stm;

	ret = &stm->policy->group;



unlock_policy:

	mutex_unlock(&stm->policy_mutex);



	if (IS_ERR(ret))

	if (IS_ERR(ret)) {

		stm_put_protocol(stm->pdrv);

		stm_put_device(stm);

	}



	return ret;

}

drivers/hwtracing/stm/stm.h

+43 −8
Original line number Diff line number Diff line
@@ -10,20 +10,17 @@ 
#ifndef _STM_STM_H_

#define _STM_STM_H_



#include <linux/configfs.h>



struct stp_policy;

struct stp_policy_node;

struct stm_protocol_driver;



struct stp_policy_node *

stp_policy_node_lookup(struct stm_device *stm, char *s);

void stp_policy_node_put(struct stp_policy_node *policy_node);

void stp_policy_unbind(struct stp_policy *policy);



void stp_policy_node_get_ranges(struct stp_policy_node *policy_node,

				unsigned int *mstart, unsigned int *mend,

				unsigned int *cstart, unsigned int *cend);

int stp_configfs_init(void);

void stp_configfs_exit(void);



void *stp_policy_node_priv(struct stp_policy_node *pn);



struct stp_master {

	unsigned int	nr_free;

	unsigned long	chan_map[0];
@@ -40,6 +37,9 @@ struct stm_device { 
	struct mutex		link_mutex;

	spinlock_t		link_lock;

	struct list_head	link_list;

	/* framing protocol in use */

	const struct stm_protocol_driver	*pdrv;

	const struct config_item_type		*pdrv_node_type;

	/* master allocation */

	spinlock_t		mc_lock;

	struct stp_master	*masters[0];
@@ -48,11 +48,24 @@ struct stm_device { 
#define to_stm_device(_d)				\

	container_of((_d), struct stm_device, dev)



struct stp_policy_node *

stp_policy_node_lookup(struct stm_device *stm, char *s);

void stp_policy_node_put(struct stp_policy_node *policy_node);

void stp_policy_unbind(struct stp_policy *policy);



void stp_policy_node_get_ranges(struct stp_policy_node *policy_node,

				unsigned int *mstart, unsigned int *mend,

				unsigned int *cstart, unsigned int *cend);



const struct config_item_type *

get_policy_node_type(struct configfs_attribute **attrs);



struct stm_output {

	spinlock_t		lock;

	unsigned int		master;

	unsigned int		channel;

	unsigned int		nr_chans;

	void			*pdrv_private;

};



struct stm_file {
@@ -76,4 +89,26 @@ struct stm_source_device { 
#define to_stm_source_device(_d)				\

	container_of((_d), struct stm_source_device, dev)



void *to_pdrv_policy_node(struct config_item *item);



struct stm_protocol_driver {

	struct module	*owner;

	const char	*name;

	ssize_t		(*write)(struct stm_data *data,

				 struct stm_output *output, unsigned int chan,

				 const char *buf, size_t count);

	void		(*policy_node_init)(void *arg);

	int		(*output_open)(void *priv, struct stm_output *output);

	void		(*output_close)(struct stm_output *output);

	ssize_t		priv_sz;

	struct configfs_attribute	**policy_attr;

};



int stm_register_protocol(const struct stm_protocol_driver *pdrv);

void stm_unregister_protocol(const struct stm_protocol_driver *pdrv);

int stm_lookup_protocol(const char *name,

			const struct stm_protocol_driver **pdrv,

			const struct config_item_type **type);

void stm_put_protocol(const struct stm_protocol_driver *pdrv);



#endif /* _STM_STM_H_ */

CRA Git | Maintained and supported by SUSTech CRA and CCSE