Commit | Line | Data |
---|---|---|
5448d44c MH |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Generic dynamic event control interface | |
4 | * | |
5 | * Copyright (C) 2018 Masami Hiramatsu <mhiramat@kernel.org> | |
6 | */ | |
7 | ||
8 | #include <linux/debugfs.h> | |
9 | #include <linux/kernel.h> | |
10 | #include <linux/list.h> | |
11 | #include <linux/mm.h> | |
12 | #include <linux/mutex.h> | |
13 | #include <linux/tracefs.h> | |
14 | ||
15 | #include "trace.h" | |
1d18538e | 16 | #include "trace_output.h" /* for trace_event_sem */ |
5448d44c MH |
17 | #include "trace_dynevent.h" |
18 | ||
19 | static DEFINE_MUTEX(dyn_event_ops_mutex); | |
20 | static LIST_HEAD(dyn_event_ops_list); | |
21 | ||
1d18538e SRV |
22 | bool trace_event_dyn_try_get_ref(struct trace_event_call *dyn_call) |
23 | { | |
24 | struct trace_event_call *call; | |
25 | bool ret = false; | |
26 | ||
27 | if (WARN_ON_ONCE(!(dyn_call->flags & TRACE_EVENT_FL_DYNAMIC))) | |
28 | return false; | |
29 | ||
30 | down_read(&trace_event_sem); | |
31 | list_for_each_entry(call, &ftrace_events, list) { | |
32 | if (call == dyn_call) { | |
33 | atomic_inc(&dyn_call->refcnt); | |
34 | ret = true; | |
35 | } | |
36 | } | |
37 | up_read(&trace_event_sem); | |
38 | return ret; | |
39 | } | |
40 | ||
41 | void trace_event_dyn_put_ref(struct trace_event_call *call) | |
42 | { | |
43 | if (WARN_ON_ONCE(!(call->flags & TRACE_EVENT_FL_DYNAMIC))) | |
44 | return; | |
45 | ||
46 | if (WARN_ON_ONCE(atomic_read(&call->refcnt) <= 0)) { | |
47 | atomic_set(&call->refcnt, 0); | |
48 | return; | |
49 | } | |
50 | ||
51 | atomic_dec(&call->refcnt); | |
52 | } | |
53 | ||
54 | bool trace_event_dyn_busy(struct trace_event_call *call) | |
55 | { | |
56 | return atomic_read(&call->refcnt) != 0; | |
57 | } | |
58 | ||
5448d44c MH |
59 | int dyn_event_register(struct dyn_event_operations *ops) |
60 | { | |
61 | if (!ops || !ops->create || !ops->show || !ops->is_busy || | |
62 | !ops->free || !ops->match) | |
63 | return -EINVAL; | |
64 | ||
65 | INIT_LIST_HEAD(&ops->list); | |
66 | mutex_lock(&dyn_event_ops_mutex); | |
67 | list_add_tail(&ops->list, &dyn_event_ops_list); | |
68 | mutex_unlock(&dyn_event_ops_mutex); | |
69 | return 0; | |
70 | } | |
71 | ||
d262271d | 72 | int dyn_event_release(const char *raw_command, struct dyn_event_operations *type) |
5448d44c MH |
73 | { |
74 | struct dyn_event *pos, *n; | |
75 | char *system = NULL, *event, *p; | |
d262271d MH |
76 | int argc, ret = -ENOENT; |
77 | char **argv; | |
78 | ||
79 | argv = argv_split(GFP_KERNEL, raw_command, &argc); | |
80 | if (!argv) | |
81 | return -ENOMEM; | |
5448d44c | 82 | |
1ce25e9f | 83 | if (argv[0][0] == '-') { |
d262271d MH |
84 | if (argv[0][1] != ':') { |
85 | ret = -EINVAL; | |
86 | goto out; | |
87 | } | |
1ce25e9f MH |
88 | event = &argv[0][2]; |
89 | } else { | |
90 | event = strchr(argv[0], ':'); | |
d262271d MH |
91 | if (!event) { |
92 | ret = -EINVAL; | |
93 | goto out; | |
94 | } | |
1ce25e9f MH |
95 | event++; |
96 | } | |
5448d44c | 97 | |
5448d44c MH |
98 | p = strchr(event, '/'); |
99 | if (p) { | |
100 | system = event; | |
101 | event = p + 1; | |
102 | *p = '\0'; | |
103 | } | |
95c104c3 | 104 | if (!system && event[0] == '\0') { |
8db403b9 CJ |
105 | ret = -EINVAL; |
106 | goto out; | |
107 | } | |
5448d44c MH |
108 | |
109 | mutex_lock(&event_mutex); | |
110 | for_each_dyn_event_safe(pos, n) { | |
111 | if (type && type != pos->ops) | |
112 | continue; | |
30199137 | 113 | if (!pos->ops->match(system, event, |
d262271d | 114 | argc - 1, (const char **)argv + 1, pos)) |
cb8e7a8d MH |
115 | continue; |
116 | ||
117 | ret = pos->ops->free(pos); | |
118 | if (ret) | |
5448d44c | 119 | break; |
5448d44c | 120 | } |
4313e5a6 | 121 | tracing_reset_all_online_cpus(); |
5448d44c | 122 | mutex_unlock(&event_mutex); |
d262271d MH |
123 | out: |
124 | argv_free(argv); | |
5448d44c MH |
125 | return ret; |
126 | } | |
127 | ||
d262271d | 128 | static int create_dyn_event(const char *raw_command) |
5448d44c MH |
129 | { |
130 | struct dyn_event_operations *ops; | |
3dee10da | 131 | int ret = -ENODEV; |
5448d44c | 132 | |
d262271d MH |
133 | if (raw_command[0] == '-' || raw_command[0] == '!') |
134 | return dyn_event_release(raw_command, NULL); | |
5448d44c MH |
135 | |
136 | mutex_lock(&dyn_event_ops_mutex); | |
137 | list_for_each_entry(ops, &dyn_event_ops_list, list) { | |
d262271d | 138 | ret = ops->create(raw_command); |
5448d44c MH |
139 | if (!ret || ret != -ECANCELED) |
140 | break; | |
141 | } | |
142 | mutex_unlock(&dyn_event_ops_mutex); | |
143 | if (ret == -ECANCELED) | |
144 | ret = -EINVAL; | |
145 | ||
146 | return ret; | |
147 | } | |
148 | ||
149 | /* Protected by event_mutex */ | |
150 | LIST_HEAD(dyn_event_list); | |
151 | ||
152 | void *dyn_event_seq_start(struct seq_file *m, loff_t *pos) | |
153 | { | |
154 | mutex_lock(&event_mutex); | |
155 | return seq_list_start(&dyn_event_list, *pos); | |
156 | } | |
157 | ||
158 | void *dyn_event_seq_next(struct seq_file *m, void *v, loff_t *pos) | |
159 | { | |
160 | return seq_list_next(v, &dyn_event_list, pos); | |
161 | } | |
162 | ||
163 | void dyn_event_seq_stop(struct seq_file *m, void *v) | |
164 | { | |
165 | mutex_unlock(&event_mutex); | |
166 | } | |
167 | ||
168 | static int dyn_event_seq_show(struct seq_file *m, void *v) | |
169 | { | |
170 | struct dyn_event *ev = v; | |
171 | ||
172 | if (ev && ev->ops) | |
173 | return ev->ops->show(m, ev); | |
174 | ||
175 | return 0; | |
176 | } | |
177 | ||
178 | static const struct seq_operations dyn_event_seq_op = { | |
179 | .start = dyn_event_seq_start, | |
180 | .next = dyn_event_seq_next, | |
181 | .stop = dyn_event_seq_stop, | |
182 | .show = dyn_event_seq_show | |
183 | }; | |
184 | ||
185 | /* | |
186 | * dyn_events_release_all - Release all specific events | |
187 | * @type: the dyn_event_operations * which filters releasing events | |
188 | * | |
189 | * This releases all events which ->ops matches @type. If @type is NULL, | |
190 | * all events are released. | |
191 | * Return -EBUSY if any of them are in use, and return other errors when | |
192 | * it failed to free the given event. Except for -EBUSY, event releasing | |
193 | * process will be aborted at that point and there may be some other | |
194 | * releasable events on the list. | |
195 | */ | |
196 | int dyn_events_release_all(struct dyn_event_operations *type) | |
197 | { | |
198 | struct dyn_event *ev, *tmp; | |
199 | int ret = 0; | |
200 | ||
201 | mutex_lock(&event_mutex); | |
202 | for_each_dyn_event(ev) { | |
203 | if (type && ev->ops != type) | |
204 | continue; | |
205 | if (ev->ops->is_busy(ev)) { | |
206 | ret = -EBUSY; | |
207 | goto out; | |
208 | } | |
209 | } | |
210 | for_each_dyn_event_safe(ev, tmp) { | |
211 | if (type && ev->ops != type) | |
212 | continue; | |
213 | ret = ev->ops->free(ev); | |
214 | if (ret) | |
215 | break; | |
216 | } | |
217 | out: | |
4313e5a6 | 218 | tracing_reset_all_online_cpus(); |
5448d44c MH |
219 | mutex_unlock(&event_mutex); |
220 | ||
221 | return ret; | |
222 | } | |
223 | ||
224 | static int dyn_event_open(struct inode *inode, struct file *file) | |
225 | { | |
226 | int ret; | |
227 | ||
8530dec6 SRV |
228 | ret = tracing_check_open_get_tr(NULL); |
229 | if (ret) | |
230 | return ret; | |
231 | ||
5448d44c MH |
232 | if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) { |
233 | ret = dyn_events_release_all(NULL); | |
234 | if (ret < 0) | |
235 | return ret; | |
236 | } | |
237 | ||
238 | return seq_open(file, &dyn_event_seq_op); | |
239 | } | |
240 | ||
241 | static ssize_t dyn_event_write(struct file *file, const char __user *buffer, | |
242 | size_t count, loff_t *ppos) | |
243 | { | |
244 | return trace_parse_run_command(file, buffer, count, ppos, | |
245 | create_dyn_event); | |
246 | } | |
247 | ||
248 | static const struct file_operations dynamic_events_ops = { | |
249 | .owner = THIS_MODULE, | |
250 | .open = dyn_event_open, | |
251 | .read = seq_read, | |
252 | .llseek = seq_lseek, | |
253 | .release = seq_release, | |
254 | .write = dyn_event_write, | |
255 | }; | |
256 | ||
257 | /* Make a tracefs interface for controlling dynamic events */ | |
258 | static __init int init_dynamic_event(void) | |
259 | { | |
22c36b18 | 260 | int ret; |
5448d44c | 261 | |
22c36b18 WY |
262 | ret = tracing_init_dentry(); |
263 | if (ret) | |
5448d44c MH |
264 | return 0; |
265 | ||
e4931b82 YW |
266 | trace_create_file("dynamic_events", TRACE_MODE_WRITE, NULL, |
267 | NULL, &dynamic_events_ops); | |
5448d44c MH |
268 | |
269 | return 0; | |
270 | } | |
271 | fs_initcall(init_dynamic_event); | |
86c5426b TZ |
272 | |
273 | /** | |
274 | * dynevent_arg_add - Add an arg to a dynevent_cmd | |
275 | * @cmd: A pointer to the dynevent_cmd struct representing the new event cmd | |
276 | * @arg: The argument to append to the current cmd | |
74403b6c | 277 | * @check_arg: An (optional) pointer to a function checking arg sanity |
86c5426b TZ |
278 | * |
279 | * Append an argument to a dynevent_cmd. The argument string will be | |
280 | * appended to the current cmd string, followed by a separator, if | |
74403b6c TZ |
281 | * applicable. Before the argument is added, the @check_arg function, |
282 | * if present, will be used to check the sanity of the current arg | |
283 | * string. | |
86c5426b | 284 | * |
74403b6c TZ |
285 | * The cmd string and separator should be set using the |
286 | * dynevent_arg_init() before any arguments are added using this | |
287 | * function. | |
86c5426b TZ |
288 | * |
289 | * Return: 0 if successful, error otherwise. | |
290 | */ | |
291 | int dynevent_arg_add(struct dynevent_cmd *cmd, | |
74403b6c TZ |
292 | struct dynevent_arg *arg, |
293 | dynevent_check_arg_fn_t check_arg) | |
86c5426b TZ |
294 | { |
295 | int ret = 0; | |
86c5426b | 296 | |
74403b6c TZ |
297 | if (check_arg) { |
298 | ret = check_arg(arg); | |
86c5426b TZ |
299 | if (ret) |
300 | return ret; | |
301 | } | |
302 | ||
2b90927c TZ |
303 | ret = seq_buf_printf(&cmd->seq, " %s%c", arg->str, arg->separator); |
304 | if (ret) { | |
305 | pr_err("String is too long: %s%c\n", arg->str, arg->separator); | |
86c5426b TZ |
306 | return -E2BIG; |
307 | } | |
86c5426b TZ |
308 | |
309 | return ret; | |
310 | } | |
311 | ||
312 | /** | |
313 | * dynevent_arg_pair_add - Add an arg pair to a dynevent_cmd | |
314 | * @cmd: A pointer to the dynevent_cmd struct representing the new event cmd | |
315 | * @arg_pair: The argument pair to append to the current cmd | |
74403b6c | 316 | * @check_arg: An (optional) pointer to a function checking arg sanity |
86c5426b TZ |
317 | * |
318 | * Append an argument pair to a dynevent_cmd. An argument pair | |
319 | * consists of a left-hand-side argument and a right-hand-side | |
320 | * argument separated by an operator, which can be whitespace, all | |
321 | * followed by a separator, if applicable. This can be used to add | |
322 | * arguments of the form 'type variable_name;' or 'x+y'. | |
323 | * | |
324 | * The lhs argument string will be appended to the current cmd string, | |
2b5894cc | 325 | * followed by an operator, if applicable, followed by the rhs string, |
74403b6c TZ |
326 | * followed finally by a separator, if applicable. Before the |
327 | * argument is added, the @check_arg function, if present, will be | |
328 | * used to check the sanity of the current arg strings. | |
86c5426b | 329 | * |
74403b6c TZ |
330 | * The cmd strings, operator, and separator should be set using the |
331 | * dynevent_arg_pair_init() before any arguments are added using this | |
332 | * function. | |
86c5426b TZ |
333 | * |
334 | * Return: 0 if successful, error otherwise. | |
335 | */ | |
336 | int dynevent_arg_pair_add(struct dynevent_cmd *cmd, | |
74403b6c TZ |
337 | struct dynevent_arg_pair *arg_pair, |
338 | dynevent_check_arg_fn_t check_arg) | |
86c5426b TZ |
339 | { |
340 | int ret = 0; | |
86c5426b | 341 | |
74403b6c TZ |
342 | if (check_arg) { |
343 | ret = check_arg(arg_pair); | |
86c5426b TZ |
344 | if (ret) |
345 | return ret; | |
346 | } | |
347 | ||
2b90927c TZ |
348 | ret = seq_buf_printf(&cmd->seq, " %s%c%s%c", arg_pair->lhs, |
349 | arg_pair->operator, arg_pair->rhs, | |
350 | arg_pair->separator); | |
351 | if (ret) { | |
352 | pr_err("field string is too long: %s%c%s%c\n", arg_pair->lhs, | |
353 | arg_pair->operator, arg_pair->rhs, | |
354 | arg_pair->separator); | |
86c5426b TZ |
355 | return -E2BIG; |
356 | } | |
86c5426b TZ |
357 | |
358 | return ret; | |
359 | } | |
360 | ||
361 | /** | |
362 | * dynevent_str_add - Add a string to a dynevent_cmd | |
363 | * @cmd: A pointer to the dynevent_cmd struct representing the new event cmd | |
364 | * @str: The string to append to the current cmd | |
365 | * | |
366 | * Append a string to a dynevent_cmd. The string will be appended to | |
367 | * the current cmd string as-is, with nothing prepended or appended. | |
368 | * | |
369 | * Return: 0 if successful, error otherwise. | |
370 | */ | |
371 | int dynevent_str_add(struct dynevent_cmd *cmd, const char *str) | |
372 | { | |
373 | int ret = 0; | |
86c5426b | 374 | |
2b90927c TZ |
375 | ret = seq_buf_puts(&cmd->seq, str); |
376 | if (ret) { | |
86c5426b TZ |
377 | pr_err("String is too long: %s\n", str); |
378 | return -E2BIG; | |
379 | } | |
86c5426b TZ |
380 | |
381 | return ret; | |
382 | } | |
383 | ||
384 | /** | |
385 | * dynevent_cmd_init - Initialize a dynevent_cmd object | |
386 | * @cmd: A pointer to the dynevent_cmd struct representing the cmd | |
387 | * @buf: A pointer to the buffer to generate the command into | |
388 | * @maxlen: The length of the buffer the command will be generated into | |
389 | * @type: The type of the cmd, checked against further operations | |
390 | * @run_command: The type-specific function that will actually run the command | |
391 | * | |
392 | * Initialize a dynevent_cmd. A dynevent_cmd is used to build up and | |
393 | * run dynamic event creation commands, such as commands for creating | |
394 | * synthetic and kprobe events. Before calling any of the functions | |
395 | * used to build the command, a dynevent_cmd object should be | |
396 | * instantiated and initialized using this function. | |
397 | * | |
398 | * The initialization sets things up by saving a pointer to the | |
399 | * user-supplied buffer and its length via the @buf and @maxlen | |
400 | * params, and by saving the cmd-specific @type and @run_command | |
401 | * params which are used to check subsequent dynevent_cmd operations | |
402 | * and actually run the command when complete. | |
403 | */ | |
404 | void dynevent_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen, | |
405 | enum dynevent_type type, | |
406 | dynevent_create_fn_t run_command) | |
407 | { | |
408 | memset(cmd, '\0', sizeof(*cmd)); | |
409 | ||
2b90927c | 410 | seq_buf_init(&cmd->seq, buf, maxlen); |
86c5426b TZ |
411 | cmd->type = type; |
412 | cmd->run_command = run_command; | |
413 | } | |
414 | ||
415 | /** | |
416 | * dynevent_arg_init - Initialize a dynevent_arg object | |
417 | * @arg: A pointer to the dynevent_arg struct representing the arg | |
86c5426b TZ |
418 | * @separator: An (optional) separator, appended after adding the arg |
419 | * | |
420 | * Initialize a dynevent_arg object. A dynevent_arg represents an | |
421 | * object used to append single arguments to the current command | |
74403b6c | 422 | * string. After the arg string is successfully appended to the |
86c5426b TZ |
423 | * command string, the optional @separator is appended. If no |
424 | * separator was specified when initializing the arg, a space will be | |
425 | * appended. | |
426 | */ | |
427 | void dynevent_arg_init(struct dynevent_arg *arg, | |
86c5426b TZ |
428 | char separator) |
429 | { | |
430 | memset(arg, '\0', sizeof(*arg)); | |
431 | ||
432 | if (!separator) | |
433 | separator = ' '; | |
434 | arg->separator = separator; | |
86c5426b TZ |
435 | } |
436 | ||
437 | /** | |
438 | * dynevent_arg_pair_init - Initialize a dynevent_arg_pair object | |
439 | * @arg_pair: A pointer to the dynevent_arg_pair struct representing the arg | |
86c5426b TZ |
440 | * @operator: An (optional) operator, appended after adding the first arg |
441 | * @separator: An (optional) separator, appended after adding the second arg | |
442 | * | |
443 | * Initialize a dynevent_arg_pair object. A dynevent_arg_pair | |
444 | * represents an object used to append argument pairs such as 'type | |
445 | * variable_name;' or 'x+y' to the current command string. An | |
446 | * argument pair consists of a left-hand-side argument and a | |
447 | * right-hand-side argument separated by an operator, which can be | |
74403b6c TZ |
448 | * whitespace, all followed by a separator, if applicable. After the |
449 | * first arg string is successfully appended to the command string, | |
450 | * the optional @operator is appended, followed by the second arg and | |
5c8c206e | 451 | * optional @separator. If no separator was specified when |
74403b6c | 452 | * initializing the arg, a space will be appended. |
86c5426b TZ |
453 | */ |
454 | void dynevent_arg_pair_init(struct dynevent_arg_pair *arg_pair, | |
86c5426b TZ |
455 | char operator, char separator) |
456 | { | |
457 | memset(arg_pair, '\0', sizeof(*arg_pair)); | |
458 | ||
459 | if (!operator) | |
460 | operator = ' '; | |
461 | arg_pair->operator = operator; | |
462 | ||
463 | if (!separator) | |
464 | separator = ' '; | |
465 | arg_pair->separator = separator; | |
86c5426b TZ |
466 | } |
467 | ||
468 | /** | |
469 | * dynevent_create - Create the dynamic event contained in dynevent_cmd | |
470 | * @cmd: The dynevent_cmd object containing the dynamic event creation command | |
471 | * | |
472 | * Once a dynevent_cmd object has been successfully built up via the | |
473 | * dynevent_cmd_init(), dynevent_arg_add() and dynevent_arg_pair_add() | |
474 | * functions, this function runs the final command to actually create | |
475 | * the event. | |
476 | * | |
477 | * Return: 0 if the event was successfully created, error otherwise. | |
478 | */ | |
479 | int dynevent_create(struct dynevent_cmd *cmd) | |
480 | { | |
481 | return cmd->run_command(cmd); | |
482 | } | |
483 | EXPORT_SYMBOL_GPL(dynevent_create); |