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[];
  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         /*
 349          * Drop the reference on the protocol driver and lose the link.
 350          */
 351         stm_put_protocol(stm->pdrv);
 352         stm->pdrv = NULL;
 353         stm_put_device(stm);
 354 }
 355
 356 static void stp_policy_release(struct config_item *item)
 357 {
 358         struct stp_policy *policy = to_stp_policy(item);
 359         struct stm_device *stm = policy->stm;
 360
 361         /* a policy *can* be unbound and still exist in configfs tree */
 362         if (!stm)
 363                 return;
 364
 365         mutex_lock(&stm->policy_mutex);
 366         stp_policy_unbind(policy);
 367         mutex_unlock(&stm->policy_mutex);
 368
 369         kfree(policy);
 370 }
 371
 372 static struct configfs_item_operations stp_policy_item_ops = {
 373         .release                = stp_policy_release,
 374 };
 375
 376 static struct configfs_group_operations stp_policy_group_ops = {
 377         .make_group     = stp_policy_node_make,
 378 };
 379
 380 static const struct config_item_type stp_policy_type = {
 381         .ct_item_ops    = &stp_policy_item_ops,
 382         .ct_group_ops   = &stp_policy_group_ops,
 383         .ct_attrs       = stp_policy_attrs,
 384         .ct_owner       = THIS_MODULE,
 385 };
 386
 387 static struct config_group *
 388 stp_policy_make(struct config_group *group, const char *name)
 389 {
 390         const struct config_item_type *pdrv_node_type;
 391         const struct stm_protocol_driver *pdrv;
 392         char *devname, *proto, *p;
 393         struct config_group *ret;
 394         struct stm_device *stm;
 395         int err;
 396
 397         devname = kasprintf(GFP_KERNEL, "%s", name);
 398         if (!devname)
 399                 return ERR_PTR(-ENOMEM);
 400
 401         /*
 402          * node must look like <device_name>.<policy_name>, where
 403          * <device_name> is the name of an existing stm device; may
 404          *               contain dots;
 405          * <policy_name> is an arbitrary string; may not contain dots
 406          * <device_name>:<protocol_name>.<policy_name>
 407          */
 408         p = strrchr(devname, '.');
 409         if (!p) {
 410                 kfree(devname);
 411                 return ERR_PTR(-EINVAL);
 412         }
 413
 414         *p = '\0';
 415
 416         /*
 417          * look for ":<protocol_name>":
 418          *  + no protocol suffix: fall back to whatever is available;
 419          *  + unknown protocol: fail the whole thing
 420          */
 421         proto = strrchr(devname, ':');
 422         if (proto)
 423                 *proto++ = '\0';
 424
 425         stm = stm_find_device(devname);
 426         if (!stm) {
 427                 kfree(devname);
 428                 return ERR_PTR(-ENODEV);
 429         }
 430
 431         err = stm_lookup_protocol(proto, &pdrv, &pdrv_node_type);
 432         kfree(devname);
 433
 434         if (err) {
 435                 stm_put_device(stm);
 436                 return ERR_PTR(-ENODEV);
 437         }
 438
 439         mutex_lock(&stm->policy_mutex);
 440         if (stm->policy) {
 441                 ret = ERR_PTR(-EBUSY);
 442                 goto unlock_policy;
 443         }
 444
 445         stm->policy = kzalloc(sizeof(*stm->policy), GFP_KERNEL);
 446         if (!stm->policy) {
 447                 ret = ERR_PTR(-ENOMEM);
 448                 goto unlock_policy;
 449         }
 450
 451         config_group_init_type_name(&stm->policy->group, name,
 452                                     &stp_policy_type);
 453
 454         stm->pdrv = pdrv;
 455         stm->pdrv_node_type = pdrv_node_type;
 456         stm->policy->stm = stm;
 457         ret = &stm->policy->group;
 458
 459 unlock_policy:
 460         mutex_unlock(&stm->policy_mutex);
 461
 462         if (IS_ERR(ret)) {
 463                 /*
 464                  * pdrv and stm->pdrv at this point can be quite different,
 465                  * and only one of them needs to be 'put'
 466                  */
 467                 stm_put_protocol(pdrv);
 468                 stm_put_device(stm);
 469         }
 470
 471         return ret;
 472 }
 473
 474 static struct configfs_group_operations stp_policy_root_group_ops = {
 475         .make_group     = stp_policy_make,
 476 };
 477
 478 static const struct config_item_type stp_policy_root_type = {
 479         .ct_group_ops   = &stp_policy_root_group_ops,
 480         .ct_owner       = THIS_MODULE,
 481 };
 482
 483 static struct configfs_subsystem stp_policy_subsys = {
 484         .su_group = {
 485                 .cg_item = {
 486                         .ci_namebuf     = "stp-policy",
 487                         .ci_type        = &stp_policy_root_type,
 488                 },
 489         },
 490 };
 491
 492 /*
 493  * Lock the policy mutex from the outside
 494  */
 495 static struct stp_policy_node *
 496 __stp_policy_node_lookup(struct stp_policy *policy, char *s)
 497 {
 498         struct stp_policy_node *policy_node, *ret = NULL;
 499         struct list_head *head = &policy->group.cg_children;
 500         struct config_item *item;
 501         char *start, *end = s;
 502
 503         if (list_empty(head))
 504                 return NULL;
 505
 506 next:
 507         for (;;) {
 508                 start = strsep(&end, "/");
 509                 if (!start)
 510                         break;
 511
 512                 if (!*start)
 513                         continue;
 514
 515                 list_for_each_entry(item, head, ci_entry) {
 516                         policy_node = to_stp_policy_node(item);
 517
 518                         if (!strcmp(start,
 519                                     policy_node->group.cg_item.ci_name)) {
 520                                 ret = policy_node;
 521
 522                                 if (!end)
 523                                         goto out;
 524
 525                                 head = &policy_node->group.cg_children;
 526                                 goto next;
 527                         }
 528                 }
 529                 break;
 530         }
 531
 532 out:
 533         return ret;
 534 }
 535
 536
 537 struct stp_policy_node *
 538 stp_policy_node_lookup(struct stm_device *stm, char *s)
 539 {
 540         struct stp_policy_node *policy_node = NULL;
 541
 542         mutex_lock(&stp_policy_subsys.su_mutex);
 543
 544         mutex_lock(&stm->policy_mutex);
 545         if (stm->policy)
 546                 policy_node = __stp_policy_node_lookup(stm->policy, s);
 547         mutex_unlock(&stm->policy_mutex);
 548
 549         if (policy_node)
 550                 config_item_get(&policy_node->group.cg_item);
 551         else
 552                 mutex_unlock(&stp_policy_subsys.su_mutex);
 553
 554         return policy_node;
 555 }
 556
 557 void stp_policy_node_put(struct stp_policy_node *policy_node)
 558 {
 559         lockdep_assert_held(&stp_policy_subsys.su_mutex);
 560
 561         mutex_unlock(&stp_policy_subsys.su_mutex);
 562         config_item_put(&policy_node->group.cg_item);
 563 }
 564
 565 int __init stp_configfs_init(void)
 566 {
 567         config_group_init(&stp_policy_subsys.su_group);
 568         mutex_init(&stp_policy_subsys.su_mutex);
 569         return configfs_register_subsystem(&stp_policy_subsys);
 570 }
 571
 572 void __exit stp_configfs_exit(void)
 573 {
 574         configfs_unregister_subsystem(&stp_policy_subsys);
 575 }