Commit | Line | Data |
---|---|---|
7bd1d409 AS |
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 | ||
9aa3d651 LT |
79 | static ssize_t |
80 | stp_policy_node_masters_show(struct config_item *item, char *page) | |
7bd1d409 | 81 | { |
9aa3d651 | 82 | struct stp_policy_node *policy_node = to_stp_policy_node(item); |
7bd1d409 AS |
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 | |
9aa3d651 LT |
92 | stp_policy_node_masters_store(struct config_item *item, const char *page, |
93 | size_t count) | |
7bd1d409 | 94 | { |
9aa3d651 | 95 | struct stp_policy_node *policy_node = to_stp_policy_node(item); |
7bd1d409 AS |
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 | |
9aa3d651 | 128 | stp_policy_node_channels_show(struct config_item *item, char *page) |
7bd1d409 | 129 | { |
9aa3d651 | 130 | struct stp_policy_node *policy_node = to_stp_policy_node(item); |
7bd1d409 AS |
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 | |
9aa3d651 LT |
140 | stp_policy_node_channels_store(struct config_item *item, const char *page, |
141 | size_t count) | |
7bd1d409 | 142 | { |
9aa3d651 | 143 | struct stp_policy_node *policy_node = to_stp_policy_node(item); |
7bd1d409 AS |
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 | ||
7bd1d409 AS |
178 | static struct configfs_item_operations stp_policy_node_item_ops = { |
179 | .release = stp_policy_node_release, | |
7bd1d409 AS |
180 | }; |
181 | ||
9aa3d651 LT |
182 | CONFIGFS_ATTR(stp_policy_node_, masters); |
183 | CONFIGFS_ATTR(stp_policy_node_, channels); | |
7bd1d409 AS |
184 | |
185 | static struct configfs_attribute *stp_policy_node_attrs[] = { | |
9aa3d651 LT |
186 | &stp_policy_node_attr_masters, |
187 | &stp_policy_node_attr_channels, | |
7bd1d409 AS |
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 | */ | |
9aa3d651 LT |
250 | static ssize_t stp_policy_device_show(struct config_item *item, |
251 | char *page) | |
7bd1d409 AS |
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 | ||
9aa3d651 LT |
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 | ||
7bd1d409 AS |
271 | void stp_policy_unbind(struct stp_policy *policy) |
272 | { | |
273 | struct stm_device *stm = policy->stm; | |
274 | ||
275 | if (WARN_ON_ONCE(!policy->stm)) | |
276 | return; | |
277 | ||
278 | mutex_lock(&stm->policy_mutex); | |
279 | stm->policy = NULL; | |
280 | mutex_unlock(&stm->policy_mutex); | |
281 | ||
282 | policy->stm = NULL; | |
283 | ||
284 | stm_put_device(stm); | |
285 | } | |
286 | ||
287 | static void stp_policy_release(struct config_item *item) | |
288 | { | |
289 | struct stp_policy *policy = to_stp_policy(item); | |
290 | ||
291 | stp_policy_unbind(policy); | |
292 | kfree(policy); | |
293 | } | |
294 | ||
295 | static struct configfs_item_operations stp_policy_item_ops = { | |
296 | .release = stp_policy_release, | |
7bd1d409 AS |
297 | }; |
298 | ||
299 | static struct configfs_group_operations stp_policy_group_ops = { | |
300 | .make_group = stp_policy_node_make, | |
301 | }; | |
302 | ||
303 | static struct config_item_type stp_policy_type = { | |
304 | .ct_item_ops = &stp_policy_item_ops, | |
305 | .ct_group_ops = &stp_policy_group_ops, | |
306 | .ct_attrs = stp_policy_attrs, | |
307 | .ct_owner = THIS_MODULE, | |
308 | }; | |
309 | ||
310 | static struct config_group * | |
311 | stp_policies_make(struct config_group *group, const char *name) | |
312 | { | |
313 | struct config_group *ret; | |
314 | struct stm_device *stm; | |
315 | char *devname, *p; | |
316 | ||
317 | devname = kasprintf(GFP_KERNEL, "%s", name); | |
318 | if (!devname) | |
319 | return ERR_PTR(-ENOMEM); | |
320 | ||
321 | /* | |
322 | * node must look like <device_name>.<policy_name>, where | |
323 | * <device_name> is the name of an existing stm device and | |
324 | * <policy_name> is an arbitrary string | |
325 | */ | |
326 | p = strchr(devname, '.'); | |
327 | if (!p) { | |
328 | kfree(devname); | |
329 | return ERR_PTR(-EINVAL); | |
330 | } | |
331 | ||
332 | *p++ = '\0'; | |
333 | ||
334 | stm = stm_find_device(devname); | |
335 | kfree(devname); | |
336 | ||
337 | if (!stm) | |
338 | return ERR_PTR(-ENODEV); | |
339 | ||
340 | mutex_lock(&stm->policy_mutex); | |
341 | if (stm->policy) { | |
342 | ret = ERR_PTR(-EBUSY); | |
343 | goto unlock_policy; | |
344 | } | |
345 | ||
346 | stm->policy = kzalloc(sizeof(*stm->policy), GFP_KERNEL); | |
347 | if (!stm->policy) { | |
348 | ret = ERR_PTR(-ENOMEM); | |
349 | goto unlock_policy; | |
350 | } | |
351 | ||
352 | config_group_init_type_name(&stm->policy->group, name, | |
353 | &stp_policy_type); | |
354 | stm->policy->stm = stm; | |
355 | ||
356 | ret = &stm->policy->group; | |
357 | ||
358 | unlock_policy: | |
359 | mutex_unlock(&stm->policy_mutex); | |
360 | ||
361 | if (IS_ERR(ret)) | |
362 | stm_put_device(stm); | |
363 | ||
364 | return ret; | |
365 | } | |
366 | ||
367 | static struct configfs_group_operations stp_policies_group_ops = { | |
368 | .make_group = stp_policies_make, | |
369 | }; | |
370 | ||
371 | static struct config_item_type stp_policies_type = { | |
372 | .ct_group_ops = &stp_policies_group_ops, | |
373 | .ct_owner = THIS_MODULE, | |
374 | }; | |
375 | ||
376 | static struct configfs_subsystem stp_policy_subsys = { | |
377 | .su_group = { | |
378 | .cg_item = { | |
379 | .ci_namebuf = "stp-policy", | |
380 | .ci_type = &stp_policies_type, | |
381 | }, | |
382 | }, | |
383 | }; | |
384 | ||
385 | /* | |
386 | * Lock the policy mutex from the outside | |
387 | */ | |
388 | static struct stp_policy_node * | |
389 | __stp_policy_node_lookup(struct stp_policy *policy, char *s) | |
390 | { | |
391 | struct stp_policy_node *policy_node, *ret; | |
392 | struct list_head *head = &policy->group.cg_children; | |
393 | struct config_item *item; | |
394 | char *start, *end = s; | |
395 | ||
396 | if (list_empty(head)) | |
397 | return NULL; | |
398 | ||
399 | /* return the first entry if everything else fails */ | |
400 | item = list_entry(head->next, struct config_item, ci_entry); | |
401 | ret = to_stp_policy_node(item); | |
402 | ||
403 | next: | |
404 | for (;;) { | |
405 | start = strsep(&end, "/"); | |
406 | if (!start) | |
407 | break; | |
408 | ||
409 | if (!*start) | |
410 | continue; | |
411 | ||
412 | list_for_each_entry(item, head, ci_entry) { | |
413 | policy_node = to_stp_policy_node(item); | |
414 | ||
415 | if (!strcmp(start, | |
416 | policy_node->group.cg_item.ci_name)) { | |
417 | ret = policy_node; | |
418 | ||
419 | if (!end) | |
420 | goto out; | |
421 | ||
422 | head = &policy_node->group.cg_children; | |
423 | goto next; | |
424 | } | |
425 | } | |
426 | break; | |
427 | } | |
428 | ||
429 | out: | |
430 | return ret; | |
431 | } | |
432 | ||
433 | ||
434 | struct stp_policy_node * | |
435 | stp_policy_node_lookup(struct stm_device *stm, char *s) | |
436 | { | |
437 | struct stp_policy_node *policy_node = NULL; | |
438 | ||
439 | mutex_lock(&stp_policy_subsys.su_mutex); | |
440 | ||
441 | mutex_lock(&stm->policy_mutex); | |
442 | if (stm->policy) | |
443 | policy_node = __stp_policy_node_lookup(stm->policy, s); | |
444 | mutex_unlock(&stm->policy_mutex); | |
445 | ||
446 | if (policy_node) | |
447 | config_item_get(&policy_node->group.cg_item); | |
448 | mutex_unlock(&stp_policy_subsys.su_mutex); | |
449 | ||
450 | return policy_node; | |
451 | } | |
452 | ||
453 | void stp_policy_node_put(struct stp_policy_node *policy_node) | |
454 | { | |
455 | config_item_put(&policy_node->group.cg_item); | |
456 | } | |
457 | ||
458 | int __init stp_configfs_init(void) | |
459 | { | |
460 | int err; | |
461 | ||
462 | config_group_init(&stp_policy_subsys.su_group); | |
463 | mutex_init(&stp_policy_subsys.su_mutex); | |
464 | err = configfs_register_subsystem(&stp_policy_subsys); | |
465 | ||
466 | return err; | |
467 | } | |
468 | ||
469 | void __exit stp_configfs_exit(void) | |
470 | { | |
471 | configfs_unregister_subsystem(&stp_policy_subsys); | |
472 | } |