1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * Common header file for generic dynamic events.
4 */
5
6 #ifndef _TRACE_DYNEVENT_H
7 #define _TRACE_DYNEVENT_H
8
9 #include <linux/kernel.h>
10 #include <linux/list.h>
11 #include <linux/mutex.h>
12 #include <linux/seq_file.h>
13
14 #include "trace.h"
15
16 struct dyn_event;
17
18 /**
19 * struct dyn_event_operations - Methods for each type of dynamic events
20 *
21 * These methods must be set for each type, since there is no default method.
22 * Before using this for dyn_event_init(), it must be registered by
23 * dyn_event_register().
24 *
25 * @create: Parse and create event method. This is invoked when user passes
26 * a event definition to dynamic_events interface. This must not destruct
27 * the arguments and return -ECANCELED if given arguments doesn't match its
28 * command prefix.
29 * @show: Showing method. This is invoked when user reads the event definitions
30 * via dynamic_events interface.
31 * @is_busy: Check whether given event is busy so that it can not be deleted.
32 * Return true if it is busy, otherwise false.
33 * @free: Delete the given event. Return 0 if success, otherwise error.
34 * @match: Check whether given event and system name match this event. The argc
35 * and argv is used for exact match. Return true if it matches, otherwise
36 * false.
37 *
38 * Except for @create, these methods are called under holding event_mutex.
39 */
40 struct dyn_event_operations {
41 struct list_head list;
42 int (*create)(const char *raw_command);
43 int (*show)(struct seq_file *m, struct dyn_event *ev);
44 bool (*is_busy)(struct dyn_event *ev);
45 int (*free)(struct dyn_event *ev);
46 bool (*match)(const char *system, const char *event,
47 int argc, const char **argv, struct dyn_event *ev);
48 };
49
50 /* Register new dyn_event type -- must be called at first */
51 int dyn_event_register(struct dyn_event_operations *ops);
52
53 /**
54 * struct dyn_event - Dynamic event list header
55 *
56 * The dyn_event structure encapsulates a list and a pointer to the operators
57 * for making a global list of dynamic events.
58 * User must includes this in each event structure, so that those events can
59 * be added/removed via dynamic_events interface.
60 */
61 struct dyn_event {
62 struct list_head list;
63 struct dyn_event_operations *ops;
64 };
65
66 extern struct list_head dyn_event_list;
67
68 static inline
69 int dyn_event_init(struct dyn_event *ev, struct dyn_event_operations *ops)
70 {
71 if (!ev || !ops)
72 return -EINVAL;
73
74 INIT_LIST_HEAD(&ev->list);
75 ev->ops = ops;
76 return 0;
77 }
78
79 static inline int dyn_event_add(struct dyn_event *ev,
80 struct trace_event_call *call)
81 {
82 lockdep_assert_held(&event_mutex);
83
84 if (!ev || !ev->ops)
85 return -EINVAL;
86
87 call->flags |= TRACE_EVENT_FL_DYNAMIC;
88 list_add_tail(&ev->list, &dyn_event_list);
89 return 0;
90 }
91
92 static inline void dyn_event_remove(struct dyn_event *ev)
93 {
94 lockdep_assert_held(&event_mutex);
95 list_del_init(&ev->list);
96 }
97
98 void *dyn_event_seq_start(struct seq_file *m, loff_t *pos);
99 void *dyn_event_seq_next(struct seq_file *m, void *v, loff_t *pos);
100 void dyn_event_seq_stop(struct seq_file *m, void *v);
101 int dyn_events_release_all(struct dyn_event_operations *type);
102 int dyn_event_release(const char *raw_command, struct dyn_event_operations *type);
103
104 /*
105 * for_each_dyn_event - iterate over the dyn_event list
106 * @pos: the struct dyn_event * to use as a loop cursor
107 *
108 * This is just a basement of for_each macro. Wrap this for
109 * each actual event structure with ops filtering.
110 */
111 #define for_each_dyn_event(pos) \
112 list_for_each_entry(pos, &dyn_event_list, list)
113
114 /*
115 * for_each_dyn_event - iterate over the dyn_event list safely
116 * @pos: the struct dyn_event * to use as a loop cursor
117 * @n: the struct dyn_event * to use as temporary storage
118 */
119 #define for_each_dyn_event_safe(pos, n) \
120 list_for_each_entry_safe(pos, n, &dyn_event_list, list)
121
122 extern void dynevent_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen,
123 enum dynevent_type type,
124 dynevent_create_fn_t run_command);
125
126 typedef int (*dynevent_check_arg_fn_t)(void *data);
127
128 struct dynevent_arg {
129 const char *str;
130 char separator; /* e.g. ';', ',', or nothing */
131 };
132
133 extern void dynevent_arg_init(struct dynevent_arg *arg,
134 char separator);
135 extern int dynevent_arg_add(struct dynevent_cmd *cmd,
136 struct dynevent_arg *arg,
137 dynevent_check_arg_fn_t check_arg);
138
139 struct dynevent_arg_pair {
140 const char *lhs;
141 const char *rhs;
142 char operator; /* e.g. '=' or nothing */
143 char separator; /* e.g. ';', ',', or nothing */
144 };
145
146 extern void dynevent_arg_pair_init(struct dynevent_arg_pair *arg_pair,
147 char operator, char separator);
148
149 extern int dynevent_arg_pair_add(struct dynevent_cmd *cmd,
150 struct dynevent_arg_pair *arg_pair,
151 dynevent_check_arg_fn_t check_arg);
152 extern int dynevent_str_add(struct dynevent_cmd *cmd, const char *str);
153
154 #endif
155
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.