Quelle  policy.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * System Trace Module (STM) master/channel allocation policy management
 * Copyright (c) 2014, Intel Corporation.
 *
 * 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;
 /* this is the one that's exposed to the attributes */
 unsigned char  priv[];
};

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,
    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 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;
}

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)
{
 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 > 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)
{
 struct stp_policy_node *node = to_stp_policy_node(item);

 kfree(node);
}

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 const struct config_item_type stp_policy_type;
static const struct config_item_type stp_policy_node_type;

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 = memcat_p(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) {
  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);

 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);

 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;

 /* 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 const 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 :
   "");

 return count;
}

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 :
   "");

 return count;
}

CONFIGFS_ATTR_RO(stp_policy_, protocol);

static struct configfs_attribute *stp_policy_attrs[] = {
 &stp_policy_attr_device,
 &stp_policy_attr_protocol,
 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;

 /*
 * Drop the reference on the protocol driver and lose the link.
 */
 stm_put_protocol(stm->pdrv);
 stm->pdrv = 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 const 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_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;
 int err;

 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
 * <device_name>:<protocol_name>.<policy_name>
 */
 p = strrchr(devname, '.');
 if (!p) {
  kfree(devname);
  return ERR_PTR(-EINVAL);
 }

 *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);
 }

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

 if (err) {
  stm_put_device(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->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)) {
  /*
 * pdrv and stm->pdrv at this point can be quite different,
 * and only one of them needs to be 'put'
 */
  stm_put_protocol(pdrv);
  stm_put_device(stm);
 }

 return ret;
}

static struct configfs_group_operations stp_policy_root_group_ops = {
 .make_group = stp_policy_make,
};

static const struct config_item_type stp_policy_root_type = {
 .ct_group_ops = &stp_policy_root_group_ops,
 .ct_owner = THIS_MODULE,
};

static struct configfs_subsystem stp_policy_subsys = {
 .su_group = {
  .cg_item = {
   .ci_namebuf = "stp-policy",
   .ci_type = &stp_policy_root_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 = NULL;
 struct list_head *head = &policy->group.cg_children;
 struct config_item *item;
 char *start, *end = s;

 if (list_empty(head))
  return NULL;

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);
 else
  mutex_unlock(&stp_policy_subsys.su_mutex);

 return policy_node;
}

void stp_policy_node_put(struct stp_policy_node *policy_node)
{
 lockdep_assert_held(&stp_policy_subsys.su_mutex);

 mutex_unlock(&stp_policy_subsys.su_mutex);
 config_item_put(&policy_node->group.cg_item);
}

int __init stp_configfs_init(void)
{
 config_group_init(&stp_policy_subsys.su_group);
 mutex_init(&stp_policy_subsys.su_mutex);
 return configfs_register_subsystem(&stp_policy_subsys);
}

void __exit stp_configfs_exit(void)
{
 configfs_unregister_subsystem(&stp_policy_subsys);
}