kernel/trace/trace_dynevent.h

   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