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 > last || first < stm->data->sw_start || 111 last > stm->data->sw_end) { 112 ret = -ERANGE; 113 goto unlock; 114 } 115 116 ret = count; 117 policy_node->first_master = first; 118 policy_node->last_master = last; 119 120 unlock: 121 mutex_unlock(&stp_policy_subsys.su_mutex); 122 123 return ret; 124 } 125 126 static ssize_t 127 stp_policy_node_channels_show(struct config_item *item, char *page) 128 { 129 struct stp_policy_node *policy_node = to_stp_policy_node(item); 130 ssize_t count; 131 132 count = sprintf(page, "%u %u\n", policy_node->first_channel, 133 policy_node->last_channel); 134 135 return count; 136 } 137 138 static ssize_t 139 stp_policy_node_channels_store(struct config_item *item, const char *page, 140 size_t count) 141 { 142 struct stp_policy_node *policy_node = to_stp_policy_node(item); 143 unsigned int first, last; 144 struct stm_device *stm; 145 char *p = (char *)page; 146 ssize_t ret = -ENODEV; 147 148 if (sscanf(p, "%u %u", &first, &last) != 2) 149 return -EINVAL; 150 151 mutex_lock(&stp_policy_subsys.su_mutex); 152 stm = policy_node->policy->stm; 153 if (!stm) 154 goto unlock; 155 156 if (first > INT_MAX || last > INT_MAX || first > last || 157 last >= stm->data->sw_nchannels) { 158 ret = -ERANGE; 159 goto unlock; 160 } 161 162 ret = count; 163 policy_node->first_channel = first; 164 policy_node->last_channel = last; 165 166 unlock: 167 mutex_unlock(&stp_policy_subsys.su_mutex); 168 169 return ret; 170 } 171 172 static void stp_policy_node_release(struct config_item *item) 173 { 174 kfree(to_stp_policy_node(item)); 175 } 176 177 static struct configfs_item_operations stp_policy_node_item_ops = { 178 .release = stp_policy_node_release, 179 }; 180 181 CONFIGFS_ATTR(stp_policy_node_, masters); 182 CONFIGFS_ATTR(stp_policy_node_, channels); 183 184 static struct configfs_attribute *stp_policy_node_attrs[] = { 185 &stp_policy_node_attr_masters, 186 &stp_policy_node_attr_channels, 187 NULL, 188 }; 189 190 static struct config_item_type stp_policy_type; 191 static struct config_item_type stp_policy_node_type; 192 193 static struct config_group * 194 stp_policy_node_make(struct config_group *group, const char *name) 195 { 196 struct stp_policy_node *policy_node, *parent_node; 197 struct stp_policy *policy; 198 199 if (group->cg_item.ci_type == &stp_policy_type) { 200 policy = container_of(group, struct stp_policy, group); 201 } else { 202 parent_node = container_of(group, struct stp_policy_node, 203 group); 204 policy = parent_node->policy; 205 } 206 207 if (!policy->stm) 208 return ERR_PTR(-ENODEV); 209 210 policy_node = kzalloc(sizeof(struct stp_policy_node), GFP_KERNEL); 211 if (!policy_node) 212 return ERR_PTR(-ENOMEM); 213 214 config_group_init_type_name(&policy_node->group, name, 215 &stp_policy_node_type); 216 217 policy_node->policy = policy; 218 219 /* default values for the attributes */ 220 policy_node->first_master = policy->stm->data->sw_start; 221 policy_node->last_master = policy->stm->data->sw_end; 222 policy_node->first_channel = 0; 223 policy_node->last_channel = policy->stm->data->sw_nchannels - 1; 224 225 return &policy_node->group; 226 } 227 228 static void 229 stp_policy_node_drop(struct config_group *group, struct config_item *item) 230 { 231 config_item_put(item); 232 } 233 234 static struct configfs_group_operations stp_policy_node_group_ops = { 235 .make_group = stp_policy_node_make, 236 .drop_item = stp_policy_node_drop, 237 }; 238 239 static struct config_item_type stp_policy_node_type = { 240 .ct_item_ops = &stp_policy_node_item_ops, 241 .ct_group_ops = &stp_policy_node_group_ops, 242 .ct_attrs = stp_policy_node_attrs, 243 .ct_owner = THIS_MODULE, 244 }; 245 246 /* 247 * Root group: policies. 248 */ 249 static ssize_t stp_policy_device_show(struct config_item *item, 250 char *page) 251 { 252 struct stp_policy *policy = to_stp_policy(item); 253 ssize_t count; 254 255 count = sprintf(page, "%s\n", 256 (policy && policy->stm) ? 257 policy->stm->data->name : 258 "<none>"); 259 260 return count; 261 } 262 263 CONFIGFS_ATTR_RO(stp_policy_, device); 264 265 static struct configfs_attribute *stp_policy_attrs[] = { 266 &stp_policy_attr_device, 267 NULL, 268 }; 269 270 void stp_policy_unbind(struct stp_policy *policy) 271 { 272 struct stm_device *stm = policy->stm; 273 274 /* 275 * stp_policy_release() will not call here if the policy is already 276 * unbound; other users should not either, as no link exists between 277 * this policy and anything else in that case 278 */ 279 if (WARN_ON_ONCE(!policy->stm)) 280 return; 281 282 lockdep_assert_held(&stm->policy_mutex); 283 284 stm->policy = NULL; 285 policy->stm = NULL; 286 287 stm_put_device(stm); 288 } 289 290 static void stp_policy_release(struct config_item *item) 291 { 292 struct stp_policy *policy = to_stp_policy(item); 293 struct stm_device *stm = policy->stm; 294 295 /* a policy *can* be unbound and still exist in configfs tree */ 296 if (!stm) 297 return; 298 299 mutex_lock(&stm->policy_mutex); 300 stp_policy_unbind(policy); 301 mutex_unlock(&stm->policy_mutex); 302 303 kfree(policy); 304 } 305 306 static struct configfs_item_operations stp_policy_item_ops = { 307 .release = stp_policy_release, 308 }; 309 310 static struct configfs_group_operations stp_policy_group_ops = { 311 .make_group = stp_policy_node_make, 312 }; 313 314 static struct config_item_type stp_policy_type = { 315 .ct_item_ops = &stp_policy_item_ops, 316 .ct_group_ops = &stp_policy_group_ops, 317 .ct_attrs = stp_policy_attrs, 318 .ct_owner = THIS_MODULE, 319 }; 320 321 static struct config_group * 322 stp_policies_make(struct config_group *group, const char *name) 323 { 324 struct config_group *ret; 325 struct stm_device *stm; 326 char *devname, *p; 327 328 devname = kasprintf(GFP_KERNEL, "%s", name); 329 if (!devname) 330 return ERR_PTR(-ENOMEM); 331 332 /* 333 * node must look like <device_name>.<policy_name>, where 334 * <device_name> is the name of an existing stm device; may 335 * contain dots; 336 * <policy_name> is an arbitrary string; may not contain dots 337 */ 338 p = strrchr(devname, '.'); 339 if (!p) { 340 kfree(devname); 341 return ERR_PTR(-EINVAL); 342 } 343 344 *p = '\0'; 345 346 stm = stm_find_device(devname); 347 kfree(devname); 348 349 if (!stm) 350 return ERR_PTR(-ENODEV); 351 352 mutex_lock(&stm->policy_mutex); 353 if (stm->policy) { 354 ret = ERR_PTR(-EBUSY); 355 goto unlock_policy; 356 } 357 358 stm->policy = kzalloc(sizeof(*stm->policy), GFP_KERNEL); 359 if (!stm->policy) { 360 ret = ERR_PTR(-ENOMEM); 361 goto unlock_policy; 362 } 363 364 config_group_init_type_name(&stm->policy->group, name, 365 &stp_policy_type); 366 stm->policy->stm = stm; 367 368 ret = &stm->policy->group; 369 370 unlock_policy: 371 mutex_unlock(&stm->policy_mutex); 372 373 if (IS_ERR(ret)) 374 stm_put_device(stm); 375 376 return ret; 377 } 378 379 static struct configfs_group_operations stp_policies_group_ops = { 380 .make_group = stp_policies_make, 381 }; 382 383 static struct config_item_type stp_policies_type = { 384 .ct_group_ops = &stp_policies_group_ops, 385 .ct_owner = THIS_MODULE, 386 }; 387 388 static struct configfs_subsystem stp_policy_subsys = { 389 .su_group = { 390 .cg_item = { 391 .ci_namebuf = "stp-policy", 392 .ci_type = &stp_policies_type, 393 }, 394 }, 395 }; 396 397 /* 398 * Lock the policy mutex from the outside 399 */ 400 static struct stp_policy_node * 401 __stp_policy_node_lookup(struct stp_policy *policy, char *s) 402 { 403 struct stp_policy_node *policy_node, *ret; 404 struct list_head *head = &policy->group.cg_children; 405 struct config_item *item; 406 char *start, *end = s; 407 408 if (list_empty(head)) 409 return NULL; 410 411 /* return the first entry if everything else fails */ 412 item = list_entry(head->next, struct config_item, ci_entry); 413 ret = to_stp_policy_node(item); 414 415 next: 416 for (;;) { 417 start = strsep(&end, "/"); 418 if (!start) 419 break; 420 421 if (!*start) 422 continue; 423 424 list_for_each_entry(item, head, ci_entry) { 425 policy_node = to_stp_policy_node(item); 426 427 if (!strcmp(start, 428 policy_node->group.cg_item.ci_name)) { 429 ret = policy_node; 430 431 if (!end) 432 goto out; 433 434 head = &policy_node->group.cg_children; 435 goto next; 436 } 437 } 438 break; 439 } 440 441 out: 442 return ret; 443 } 444 445 446 struct stp_policy_node * 447 stp_policy_node_lookup(struct stm_device *stm, char *s) 448 { 449 struct stp_policy_node *policy_node = NULL; 450 451 mutex_lock(&stp_policy_subsys.su_mutex); 452 453 mutex_lock(&stm->policy_mutex); 454 if (stm->policy) 455 policy_node = __stp_policy_node_lookup(stm->policy, s); 456 mutex_unlock(&stm->policy_mutex); 457 458 if (policy_node) 459 config_item_get(&policy_node->group.cg_item); 460 mutex_unlock(&stp_policy_subsys.su_mutex); 461 462 return policy_node; 463 } 464 465 void stp_policy_node_put(struct stp_policy_node *policy_node) 466 { 467 config_item_put(&policy_node->group.cg_item); 468 } 469 470 int __init stp_configfs_init(void) 471 { 472 int err; 473 474 config_group_init(&stp_policy_subsys.su_group); 475 mutex_init(&stp_policy_subsys.su_mutex); 476 err = configfs_register_subsystem(&stp_policy_subsys); 477 478 return err; 479 } 480 481 void __exit stp_configfs_exit(void) 482 { 483 configfs_unregister_subsystem(&stp_policy_subsys); 484 } 485