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