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