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
dyn_event_init(struct dyn_event * ev,struct dyn_event_operations * ops)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 
dyn_event_add(struct dyn_event * ev,struct trace_event_call * call)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 
dyn_event_remove(struct dyn_event * ev)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