[linux.git] / kernel / trace / trace_dynevent.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Common header file for generic dynamic events.
 */

#ifndef _TRACE_DYNEVENT_H
#define _TRACE_DYNEVENT_H

#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/seq_file.h>

#include "trace.h"

struct dyn_event;

/**
 * struct dyn_event_operations - Methods for each type of dynamic events
 *
 * These methods must be set for each type, since there is no default method.
 * Before using this for dyn_event_init(), it must be registered by
 * dyn_event_register().
 *
 * @create: Parse and create event method. This is invoked when user passes
 *  a event definition to dynamic_events interface. This must not destruct
 *  the arguments and return -ECANCELED if given arguments doesn't match its
 *  command prefix.
 * @show: Showing method. This is invoked when user reads the event definitions
 *  via dynamic_events interface.
 * @is_busy: Check whether given event is busy so that it can not be deleted.
 *  Return true if it is busy, otherwise false.
 * @free: Delete the given event. Return 0 if success, otherwise error.
 * @match: Check whether given event and system name match this event. The argc
 *  and argv is used for exact match. Return true if it matches, otherwise
 *  false.
 *
 * Except for @create, these methods are called under holding event_mutex.
 */
struct dyn_event_operations {
	struct list_head	list;
	int (*create)(int argc, const char *argv[]);
	int (*show)(struct seq_file *m, struct dyn_event *ev);
	bool (*is_busy)(struct dyn_event *ev);
	int (*free)(struct dyn_event *ev);
	bool (*match)(const char *system, const char *event,
		      int argc, const char **argv, struct dyn_event *ev);
};

/* Register new dyn_event type -- must be called at first */
int dyn_event_register(struct dyn_event_operations *ops);

/**
 * struct dyn_event - Dynamic event list header
 *
 * The dyn_event structure encapsulates a list and a pointer to the operators
 * for making a global list of dynamic events.
 * User must includes this in each event structure, so that those events can
 * be added/removed via dynamic_events interface.
 */
struct dyn_event {
	struct list_head		list;
	struct dyn_event_operations	*ops;
};

extern struct list_head dyn_event_list;

static inline
int dyn_event_init(struct dyn_event *ev, struct dyn_event_operations *ops)
{
	if (!ev || !ops)
		return -EINVAL;

	INIT_LIST_HEAD(&ev->list);
	ev->ops = ops;
	return 0;
}

static inline int dyn_event_add(struct dyn_event *ev)
{
	lockdep_assert_held(&event_mutex);

	if (!ev || !ev->ops)
		return -EINVAL;

	list_add_tail(&ev->list, &dyn_event_list);
	return 0;
}

static inline void dyn_event_remove(struct dyn_event *ev)
{
	lockdep_assert_held(&event_mutex);
	list_del_init(&ev->list);
}

void *dyn_event_seq_start(struct seq_file *m, loff_t *pos);
void *dyn_event_seq_next(struct seq_file *m, void *v, loff_t *pos);
void dyn_event_seq_stop(struct seq_file *m, void *v);
int dyn_events_release_all(struct dyn_event_operations *type);
int dyn_event_release(int argc, char **argv, struct dyn_event_operations *type);

/*
 * for_each_dyn_event	-	iterate over the dyn_event list
 * @pos:	the struct dyn_event * to use as a loop cursor
 *
 * This is just a basement of for_each macro. Wrap this for
 * each actual event structure with ops filtering.
 */
#define for_each_dyn_event(pos)	\
	list_for_each_entry(pos, &dyn_event_list, list)

/*
 * for_each_dyn_event	-	iterate over the dyn_event list safely
 * @pos:	the struct dyn_event * to use as a loop cursor
 * @n:		the struct dyn_event * to use as temporary storage
 */
#define for_each_dyn_event_safe(pos, n)	\
	list_for_each_entry_safe(pos, n, &dyn_event_list, list)

extern void dynevent_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen,
			      enum dynevent_type type,
			      dynevent_create_fn_t run_command);

typedef int (*dynevent_check_arg_fn_t)(void *data);

struct dynevent_arg {
	const char		*str;
	char			separator; /* e.g. ';', ',', or nothing */
};

extern void dynevent_arg_init(struct dynevent_arg *arg,
			      char separator);
extern int dynevent_arg_add(struct dynevent_cmd *cmd,
			    struct dynevent_arg *arg,
			    dynevent_check_arg_fn_t check_arg);

struct dynevent_arg_pair {
	const char		*lhs;
	const char		*rhs;
	char			operator; /* e.g. '=' or nothing */
	char			separator; /* e.g. ';', ',', or nothing */
};

extern void dynevent_arg_pair_init(struct dynevent_arg_pair *arg_pair,
				   char operator, char separator);

extern int dynevent_arg_pair_add(struct dynevent_cmd *cmd,
				 struct dynevent_arg_pair *arg_pair,
				 dynevent_check_arg_fn_t check_arg);
extern int dynevent_str_add(struct dynevent_cmd *cmd, const char *str);

#endif
Commit	Line	Data
5448d44c MH	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.
2b5894cc QH	32	* Return true if it is busy, otherwise false.
2b5894cc QH	33	* @free: Delete the given event. Return 0 if success, otherwise error.
30199137	34	* @match: Check whether given event and system name match this event. The argc
2b5894cc	35	* and argv is used for exact match. Return true if it matches, otherwise
30199137	36	* false.
5448d44c MH	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)(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,
30199137	47	int argc, const char *argv, struct dyn_event ev);
5448d44c MH	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	{
	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
	90	static inline void dyn_event_remove(struct dyn_event *ev)
	91	{
	92	lockdep_assert_held(&event_mutex);
	93	list_del_init(&ev->list);
	94	}
	95
	96	void dyn_event_seq_start(struct seq_file m, loff_t *pos);
	97	void dyn_event_seq_next(struct seq_file m, void v, loff_t pos);
	98	void dyn_event_seq_stop(struct seq_file m, void v);
	99	int dyn_events_release_all(struct dyn_event_operations *type);
	100	int 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
86c5426b TZ	120	extern 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
	124	typedef int (dynevent_check_arg_fn_t)(void data);
	125
	126	struct dynevent_arg {
	127	const char *str;
	128	char separator; /* e.g. ';', ',', or nothing */
86c5426b TZ	129	};
	130
	131	extern void dynevent_arg_init(struct dynevent_arg *arg,
86c5426b TZ	132	char separator);
86c5426b TZ	133	extern int dynevent_arg_add(struct dynevent_cmd *cmd,
74403b6c TZ	134	struct dynevent_arg *arg,
74403b6c TZ	135	dynevent_check_arg_fn_t check_arg);
86c5426b TZ	136
	137	struct 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 */
86c5426b TZ	142	};
	143
	144	extern void dynevent_arg_pair_init(struct dynevent_arg_pair *arg_pair,
86c5426b	145	char operator, char separator);
74403b6c	146
86c5426b	147	extern int dynevent_arg_pair_add(struct dynevent_cmd *cmd,
74403b6c TZ	148	struct dynevent_arg_pair *arg_pair,
74403b6c TZ	149	dynevent_check_arg_fn_t check_arg);
86c5426b TZ	150	extern int dynevent_str_add(struct dynevent_cmd cmd, const char str);
86c5426b TZ	151
5448d44c	152	#endif