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