LXR linux/kernel/trace/trace

   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
  16struct 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, otherwides false.
  33 * @free: Delete the given event. Return 0 if success, otherwides 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, otherwides
  36 *  false.
  37 *
  38 * Except for @create, these methods are called under holding event_mutex.
  39 */
  40struct dyn_event_operations {
  41        struct list_head        list;
  42        int (*create)(int argc, const char *argv[]);
  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 */
  51int 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 */
  61struct dyn_event {
  62        struct list_head                list;
  63        struct dyn_event_operations     *ops;
  64};
  65
  66extern struct list_head dyn_event_list;
  67
  68static inline
  69int 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
  79static inline int dyn_event_add(struct dyn_event *ev)
  80{
  81        lockdep_assert_held(&event_mutex);
  82
  83        if (!ev || !ev->ops)
  84                return -EINVAL;
  85
  86        list_add_tail(&ev->list, &dyn_event_list);
  87        return 0;
  88}
  89
  90static inline void dyn_event_remove(struct dyn_event *ev)
  91{
  92        lockdep_assert_held(&event_mutex);
  93        list_del_init(&ev->list);
  94}
  95
  96void *dyn_event_seq_start(struct seq_file *m, loff_t *pos);
  97void *dyn_event_seq_next(struct seq_file *m, void *v, loff_t *pos);
  98void dyn_event_seq_stop(struct seq_file *m, void *v);
  99int dyn_events_release_all(struct dyn_event_operations *type);
 100int dyn_event_release(int argc, char **argv, struct dyn_event_operations *type);
 101
 102/*
 103 * for_each_dyn_event   -       iterate over the dyn_event list
 104 * @pos:        the struct dyn_event * to use as a loop cursor
 105 *
 106 * This is just a basement of for_each macro. Wrap this for
 107 * each actual event structure with ops filtering.
 108 */
 109#define for_each_dyn_event(pos) \
 110        list_for_each_entry(pos, &dyn_event_list, list)
 111
 112/*
 113 * for_each_dyn_event   -       iterate over the dyn_event list safely
 114 * @pos:        the struct dyn_event * to use as a loop cursor
 115 * @n:          the struct dyn_event * to use as temporary storage
 116 */
 117#define for_each_dyn_event_safe(pos, n) \
 118        list_for_each_entry_safe(pos, n, &dyn_event_list, list)
 119
 120extern void dynevent_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen,
 121                              enum dynevent_type type,
 122                              dynevent_create_fn_t run_command);
 123
 124typedef int (*dynevent_check_arg_fn_t)(void *data);
 125
 126struct dynevent_arg {
 127        const char              *str;
 128        char                    separator; /* e.g. ';', ',', or nothing */
 129};
 130
 131extern void dynevent_arg_init(struct dynevent_arg *arg,
 132                              char separator);
 133extern int dynevent_arg_add(struct dynevent_cmd *cmd,
 134                            struct dynevent_arg *arg,
 135                            dynevent_check_arg_fn_t check_arg);
 136
 137struct dynevent_arg_pair {
 138        const char              *lhs;
 139        const char              *rhs;
 140        char                    operator; /* e.g. '=' or nothing */
 141        char                    separator; /* e.g. ';', ',', or nothing */
 142};
 143
 144extern void dynevent_arg_pair_init(struct dynevent_arg_pair *arg_pair,
 145                                   char operator, char separator);
 146
 147extern int dynevent_arg_pair_add(struct dynevent_cmd *cmd,
 148                                 struct dynevent_arg_pair *arg_pair,
 149                                 dynevent_check_arg_fn_t check_arg);
 150extern int dynevent_str_add(struct dynevent_cmd *cmd, const char *str);
 151
 152#endif
 153