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 int dyn_event_create(const char *raw_command, struct dyn_event_operations *type);
104 
105 /*
106  * for_each_dyn_event	-	iterate over the dyn_event list
107  * @pos:	the struct dyn_event * to use as a loop cursor
108  *
109  * This is just a basement of for_each macro. Wrap this for
110  * each actual event structure with ops filtering.
111  */
112 #define for_each_dyn_event(pos)	\
113 	list_for_each_entry(pos, &dyn_event_list, list)
114 
115 /*
116  * for_each_dyn_event	-	iterate over the dyn_event list safely
117  * @pos:	the struct dyn_event * to use as a loop cursor
118  * @n:		the struct dyn_event * to use as temporary storage
119  */
120 #define for_each_dyn_event_safe(pos, n)	\
121 	list_for_each_entry_safe(pos, n, &dyn_event_list, list)
122 
123 extern void dynevent_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen,
124 			      enum dynevent_type type,
125 			      dynevent_create_fn_t run_command);
126 
127 typedef int (*dynevent_check_arg_fn_t)(void *data);
128 
129 struct dynevent_arg {
130 	const char		*str;
131 	char			separator; /* e.g. ';', ',', or nothing */
132 };
133 
134 extern void dynevent_arg_init(struct dynevent_arg *arg,
135 			      char separator);
136 extern int dynevent_arg_add(struct dynevent_cmd *cmd,
137 			    struct dynevent_arg *arg,
138 			    dynevent_check_arg_fn_t check_arg);
139 
140 struct dynevent_arg_pair {
141 	const char		*lhs;
142 	const char		*rhs;
143 	char			operator; /* e.g. '=' or nothing */
144 	char			separator; /* e.g. ';', ',', or nothing */
145 };
146 
147 extern void dynevent_arg_pair_init(struct dynevent_arg_pair *arg_pair,
148 				   char operator, char separator);
149 
150 extern int dynevent_arg_pair_add(struct dynevent_cmd *cmd,
151 				 struct dynevent_arg_pair *arg_pair,
152 				 dynevent_check_arg_fn_t check_arg);
153 extern int dynevent_str_add(struct dynevent_cmd *cmd, const char *str);
154 
155 #endif
156