drivers/hwtracing/stm/policy.c

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