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
 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, 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 */
 40struct 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 */
 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				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
 92static inline void dyn_event_remove(struct dyn_event *ev)
 93{
 94	lockdep_assert_held(&event_mutex);
 95	list_del_init(&ev->list);
 96}
 97
 98void *dyn_event_seq_start(struct seq_file *m, loff_t *pos);
 99void *dyn_event_seq_next(struct seq_file *m, void *v, loff_t *pos);
100void dyn_event_seq_stop(struct seq_file *m, void *v);
101int dyn_events_release_all(struct dyn_event_operations *type);
102int dyn_event_release(const char *raw_command, struct dyn_event_operations *type);
103int 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
123extern 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
127typedef int (*dynevent_check_arg_fn_t)(void *data);
128
129struct dynevent_arg {
130	const char		*str;
131	char			separator; /* e.g. ';', ',', or nothing */
132};
133
134extern void dynevent_arg_init(struct dynevent_arg *arg,
135			      char separator);
136extern int dynevent_arg_add(struct dynevent_cmd *cmd,
137			    struct dynevent_arg *arg,
138			    dynevent_check_arg_fn_t check_arg);
139
140struct 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
147extern void dynevent_arg_pair_init(struct dynevent_arg_pair *arg_pair,
148				   char operator, char separator);
149
150extern int dynevent_arg_pair_add(struct dynevent_cmd *cmd,
151				 struct dynevent_arg_pair *arg_pair,
152				 dynevent_check_arg_fn_t check_arg);
153extern int dynevent_str_add(struct dynevent_cmd *cmd, const char *str);
154
155#endif