drivers/hwtracing/stm/policy.c

   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
  79 static ssize_t
  80 stp_policy_node_masters_show(struct config_item *item, char *page)
  81 {
  82         struct stp_policy_node *policy_node = to_stp_policy_node(item);
  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
  92 stp_policy_node_masters_store(struct config_item *item, const char *page,
  93                               size_t count)
  94 {
  95         struct stp_policy_node *policy_node = to_stp_policy_node(item);
  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
 128 stp_policy_node_channels_show(struct config_item *item, char *page)
 129 {
 130         struct stp_policy_node *policy_node = to_stp_policy_node(item);
 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
 140 stp_policy_node_channels_store(struct config_item *item, const char *page,
 141                                size_t count)
 142 {
 143         struct stp_policy_node *policy_node = to_stp_policy_node(item);
 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
 178 static struct configfs_item_operations stp_policy_node_item_ops = {
 179         .release                = stp_policy_node_release,
 180 };
 181
 182 CONFIGFS_ATTR(stp_policy_node_, masters);
 183 CONFIGFS_ATTR(stp_policy_node_, channels);
 184
 185 static struct configfs_attribute *stp_policy_node_attrs[] = {
 186         &stp_policy_node_attr_masters,
 187         &stp_policy_node_attr_channels,
 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  */
 250 static ssize_t stp_policy_device_show(struct config_item *item,
 251                                       char *page)
 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
 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
 271 void stp_policy_unbind(struct stp_policy *policy)
 272 {
 273         struct stm_device *stm = policy->stm;
 274
 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          */
 280         if (WARN_ON_ONCE(!policy->stm))
 281                 return;
 282
 283         lockdep_assert_held(&stm->policy_mutex);
 284
 285         stm->policy = NULL;
 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);
 294         struct stm_device *stm = policy->stm;
 295
 296         /* a policy *can* be unbound and still exist in configfs tree */
 297         if (!stm)
 298                 return;
 299
 300         mutex_lock(&stm->policy_mutex);
 301         stp_policy_unbind(policy);
 302         mutex_unlock(&stm->policy_mutex);
 303
 304         kfree(policy);
 305 }
 306
 307 static struct configfs_item_operations stp_policy_item_ops = {
 308         .release                = stp_policy_release,
 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
 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
 338          */
 339         p = strrchr(devname, '.');
 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 }