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