Commit 07252915 authored by Vincent Donnefort's avatar Vincent Donnefort Committed by Steven Rostedt (Google)
Browse files

tracing: Add events to trace remotes 

An event is predefined point in the writer code that allows to log
data. Following the same scheme as kernel events, add remote events,
described to user-space within the events/ tracefs directory found in
the corresponding trace remote.

Remote events are expected to be described during the trace remote
registration.

Add also a .enable_event callback for trace_remote to toggle the event
logging, if supported.

Link: https://patch.msgid.link/20260309162516.2623589-10-vdonnefort@google.com


Reviewed-by: default avatarSteven Rostedt (Google) <rostedt@goodmis.org>
Signed-off-by: default avatarVincent Donnefort <vdonnefort@google.com>
Signed-off-by: default avatarSteven Rostedt (Google) <rostedt@goodmis.org>
parent bf2ba0f8

include/linux/trace_remote.h

+6 −1
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 


#include <linux/dcache.h>

#include <linux/ring_buffer.h>

#include <linux/trace_remote_event.h>



/**

 * struct trace_remote_callbacks - Callbacks used by Tracefs to control the remote
@@ -23,6 +24,8 @@ 
 * @reset:		Called on `echo 0 > trace`. It is expected from the

 *			remote to reset all ring-buffer pages.

 *			new reader-page from the @cpu ring-buffer.

 * @enable_event:	Called on events/event_name/enable. It is expected from

 *			the remote to allow the writing event @id.

 */

struct trace_remote_callbacks {

	int	(*init)(struct dentry *d, void *priv);
@@ -31,9 +34,11 @@ struct trace_remote_callbacks { 
	int	(*enable_tracing)(bool enable, void *priv);

	int	(*swap_reader_page)(unsigned int cpu, void *priv);

	int	(*reset)(unsigned int cpu, void *priv);

	int	(*enable_event)(unsigned short id, bool enable, void *priv);

};



int trace_remote_register(const char *name, struct trace_remote_callbacks *cbs, void *priv);

int trace_remote_register(const char *name, struct trace_remote_callbacks *cbs, void *priv,

			  struct remote_event *events, size_t nr_events);



int trace_remote_alloc_buffer(struct trace_buffer_desc *desc, size_t desc_size, size_t buffer_size,

			      const struct cpumask *cpumask);

include/linux/trace_remote_event.h

0 → 100644
+23 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */



#ifndef _LINUX_TRACE_REMOTE_EVENTS_H

#define _LINUX_TRACE_REMOTE_EVENTS_H



struct trace_remote;

struct trace_event_fields;



struct remote_event_hdr {

	unsigned short	id;

};



#define REMOTE_EVENT_NAME_MAX 30

struct remote_event {

	char				name[REMOTE_EVENT_NAME_MAX];

	unsigned short			id;

	bool				enabled;

	struct trace_remote		*remote;

	struct trace_event_fields	*fields;

	char				*print_fmt;

	void				(*print)(void *evt, struct trace_seq *seq);

};

#endif

kernel/trace/trace_remote.c

+259 −5
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ struct trace_remote_iterator { 
	u64				ts;

	struct ring_buffer_iter		*rb_iter;

	struct ring_buffer_iter		**rb_iters;

	struct remote_event_hdr		*evt;

	int				cpu;

	int				evt_cpu;

	loff_t				pos;
@@ -42,6 +43,10 @@ struct trace_remote { 
	void				*priv;

	struct trace_buffer		*trace_buffer;

	struct trace_buffer_desc	*trace_buffer_desc;

	struct dentry			*dentry;

	struct eventfs_inode		*eventfs;

	struct remote_event		*events;

	unsigned long			nr_events;

	unsigned long			trace_buffer_size;

	struct ring_buffer_remote	rb_remote;

	struct mutex			lock;
@@ -168,7 +173,8 @@ static void trace_remote_reset(struct trace_remote *remote, int cpu) 
static ssize_t

tracing_on_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *ppos)

{

	struct trace_remote *remote = filp->private_data;

	struct seq_file *seq = filp->private_data;

	struct trace_remote *remote = seq->private;

	unsigned long val;

	int ret;
@@ -197,7 +203,8 @@ DEFINE_SHOW_STORE_ATTRIBUTE(tracing_on); 
static ssize_t buffer_size_kb_write(struct file *filp, const char __user *ubuf, size_t cnt,

				    loff_t *ppos)

{

	struct trace_remote *remote = filp->private_data;

	struct seq_file *seq = filp->private_data;

	struct trace_remote *remote = seq->private;

	unsigned long val;

	int ret;
@@ -484,16 +491,19 @@ __peek_event(struct trace_remote_iterator *iter, int cpu, u64 *ts, unsigned long 
static bool trace_remote_iter_read_event(struct trace_remote_iterator *iter)

{

	struct trace_buffer *trace_buffer = iter->remote->trace_buffer;

	struct ring_buffer_event *rb_evt;

	int cpu = iter->cpu;



	if (cpu != RING_BUFFER_ALL_CPUS) {

		if (ring_buffer_empty_cpu(trace_buffer, cpu))

			return false;



		if (!__peek_event(iter, cpu, &iter->ts, &iter->lost_events))

		rb_evt = __peek_event(iter, cpu, &iter->ts, &iter->lost_events);

		if (!rb_evt)

			return false;



		iter->evt_cpu = cpu;

		iter->evt = ring_buffer_event_data(rb_evt);

		return true;

	}
@@ -505,7 +515,8 @@ static bool trace_remote_iter_read_event(struct trace_remote_iterator *iter) 
		if (ring_buffer_empty_cpu(trace_buffer, cpu))

			continue;



		if (!__peek_event(iter, cpu, &ts, &lost_events))

		rb_evt = __peek_event(iter, cpu, &ts, &lost_events);

		if (!rb_evt)

			continue;



		if (ts >= iter->ts)
@@ -513,6 +524,7 @@ static bool trace_remote_iter_read_event(struct trace_remote_iterator *iter) 


		iter->ts = ts;

		iter->evt_cpu = cpu;

		iter->evt = ring_buffer_event_data(rb_evt);

		iter->lost_events = lost_events;

	}
@@ -533,8 +545,11 @@ static void trace_remote_iter_move(struct trace_remote_iterator *iter) 
	}

}



static struct remote_event *trace_remote_find_event(struct trace_remote *remote, unsigned short id);



static int trace_remote_iter_print_event(struct trace_remote_iterator *iter)

{

	struct remote_event *evt;

	unsigned long usecs_rem;

	u64 ts = iter->ts;
@@ -548,6 +563,12 @@ static int trace_remote_iter_print_event(struct trace_remote_iterator *iter) 
	trace_seq_printf(&iter->seq, "[%03d]\t%5llu.%06lu: ", iter->evt_cpu,

			 ts, usecs_rem);



	evt = trace_remote_find_event(iter->remote, iter->evt->id);

	if (!evt)

		trace_seq_printf(&iter->seq, "UNKNOWN id=%d\n", iter->evt->id);

	else

		evt->print(iter->evt, &iter->seq);



	return trace_seq_has_overflowed(&iter->seq) ? -EOVERFLOW : 0;

}
@@ -829,6 +850,8 @@ static int trace_remote_init_tracefs(const char *name, struct trace_remote *remo 
			goto err;

	}



	remote->dentry = remote_d;



	return 0;



err:
@@ -842,6 +865,9 @@ static int trace_remote_init_tracefs(const char *name, struct trace_remote *remo 
	return -ENOMEM;

}



static int trace_remote_register_events(const char *remote_name, struct trace_remote *remote,

					struct remote_event *events, size_t nr_events);



/**

 * trace_remote_register() - Register a Tracefs remote

 * @name:	Name of the remote, used for the Tracefs remotes/ directory.
@@ -860,7 +886,8 @@ static int trace_remote_init_tracefs(const char *name, struct trace_remote *remo 
 *

 * Return: 0 on success, negative error code on failure.

 */

int trace_remote_register(const char *name, struct trace_remote_callbacks *cbs, void *priv)

int trace_remote_register(const char *name, struct trace_remote_callbacks *cbs, void *priv,

			  struct remote_event *events, size_t nr_events)

{

	struct trace_remote *remote;

	int ret;
@@ -881,6 +908,13 @@ int trace_remote_register(const char *name, struct trace_remote_callbacks *cbs, 
		return -ENOMEM;

	}



	ret = trace_remote_register_events(name, remote, events, nr_events);

	if (ret) {

		pr_err("Failed to register events for trace remote '%s' (%d)\n",

		       name, ret);

		return ret;

	}



	ret = cbs->init ? cbs->init(remote->dentry, priv) : 0;

	if (ret)

		pr_err("Init failed for trace remote '%s' (%d)\n", name, ret);
@@ -976,3 +1010,223 @@ int trace_remote_alloc_buffer(struct trace_buffer_desc *desc, size_t desc_size, 
	return ret;

}

EXPORT_SYMBOL_GPL(trace_remote_alloc_buffer);



static int

trace_remote_enable_event(struct trace_remote *remote, struct remote_event *evt, bool enable)

{

	int ret;



	lockdep_assert_held(&remote->lock);



	if (evt->enabled == enable)

		return 0;



	ret = remote->cbs->enable_event(evt->id, enable, remote->priv);

	if (ret)

		return ret;



	evt->enabled = enable;



	return 0;

}



static int remote_event_enable_show(struct seq_file *s, void *unused)

{

	struct remote_event *evt = s->private;



	seq_printf(s, "%d\n", evt->enabled);



	return 0;

}



static ssize_t remote_event_enable_write(struct file *filp, const char __user *ubuf,

					 size_t count, loff_t *ppos)

{

	struct seq_file *seq = filp->private_data;

	struct remote_event *evt = seq->private;

	struct trace_remote *remote = evt->remote;

	u8 enable;

	int ret;



	ret = kstrtou8_from_user(ubuf, count, 10, &enable);

	if (ret)

		return ret;



	guard(mutex)(&remote->lock);



	ret = trace_remote_enable_event(remote, evt, enable);

	if (ret)

		return ret;



	return count;

}

DEFINE_SHOW_STORE_ATTRIBUTE(remote_event_enable);



static int remote_event_id_show(struct seq_file *s, void *unused)

{

	struct remote_event *evt = s->private;



	seq_printf(s, "%d\n", evt->id);



	return 0;

}

DEFINE_SHOW_ATTRIBUTE(remote_event_id);



static int remote_event_format_show(struct seq_file *s, void *unused)

{

	size_t offset = sizeof(struct remote_event_hdr);

	struct remote_event *evt = s->private;

	struct trace_event_fields *field;



	seq_printf(s, "name: %s\n", evt->name);

	seq_printf(s, "ID: %d\n", evt->id);

	seq_puts(s,

		 "format:\n\tfield:unsigned short common_type;\toffset:0;\tsize:2;\tsigned:0;\n\n");



	field = &evt->fields[0];

	while (field->name) {

		seq_printf(s, "\tfield:%s %s;\toffset:%zu;\tsize:%u;\tsigned:%d;\n",

			   field->type, field->name, offset, field->size,

			   field->is_signed);

		offset += field->size;

		field++;

	}



	if (field != &evt->fields[0])

		seq_puts(s, "\n");



	seq_printf(s, "print fmt: %s\n", evt->print_fmt);



	return 0;

}

DEFINE_SHOW_ATTRIBUTE(remote_event_format);



static int remote_event_callback(const char *name, umode_t *mode, void **data,

				 const struct file_operations **fops)

{

	if (!strcmp(name, "enable")) {

		*mode = TRACEFS_MODE_WRITE;

		*fops = &remote_event_enable_fops;

		return 1;

	}



	if (!strcmp(name, "id")) {

		*mode = TRACEFS_MODE_READ;

		*fops = &remote_event_id_fops;

		return 1;

	}



	if (!strcmp(name, "format")) {

		*mode = TRACEFS_MODE_READ;

		*fops = &remote_event_format_fops;

		return 1;

	}



	return 0;

}



static int trace_remote_init_eventfs(const char *remote_name, struct trace_remote *remote,

				     struct remote_event *evt)

{

	struct eventfs_inode *eventfs = remote->eventfs;

	static struct eventfs_entry entries[] = {

		{

			.name		= "enable",

			.callback	= remote_event_callback,

		}, {

			.name		= "id",

			.callback	= remote_event_callback,

		}, {

			.name		= "format",

			.callback	= remote_event_callback,

		}

	};

	bool eventfs_create = false;



	if (!eventfs) {

		eventfs = eventfs_create_events_dir("events", remote->dentry, NULL, 0, NULL);

		if (IS_ERR(eventfs))

			return PTR_ERR(eventfs);



		/*

		 * Create similar hierarchy as local events even if a single system is supported at

		 * the moment

		 */

		eventfs = eventfs_create_dir(remote_name, eventfs, NULL, 0, NULL);

		if (IS_ERR(eventfs))

			return PTR_ERR(eventfs);



		remote->eventfs = eventfs;

		eventfs_create = true;

	}



	eventfs = eventfs_create_dir(evt->name, eventfs, entries, ARRAY_SIZE(entries), evt);

	if (IS_ERR(eventfs)) {

		if (eventfs_create) {

			eventfs_remove_events_dir(remote->eventfs);

			remote->eventfs = NULL;

		}

		return PTR_ERR(eventfs);

	}



	return 0;

}



static int trace_remote_attach_events(struct trace_remote *remote, struct remote_event *events,

				      size_t nr_events)

{

	int i;



	for (i = 0; i < nr_events; i++) {

		struct remote_event *evt = &events[i];



		if (evt->remote)

			return -EEXIST;



		evt->remote = remote;



		/* We need events to be sorted for efficient lookup */

		if (i && evt->id <= events[i - 1].id)

			return -EINVAL;

	}



	remote->events = events;

	remote->nr_events = nr_events;



	return 0;

}



static int trace_remote_register_events(const char *remote_name, struct trace_remote *remote,

					struct remote_event *events, size_t nr_events)

{

	int i, ret;



	ret = trace_remote_attach_events(remote, events, nr_events);

	if (ret)

		return ret;



	for (i = 0; i < nr_events; i++) {

		struct remote_event *evt = &events[i];



		ret = trace_remote_init_eventfs(remote_name, remote, evt);

		if (ret)

			pr_warn("Failed to init eventfs for event '%s' (%d)",

				evt->name, ret);

	}



	return 0;

}



static int __cmp_events(const void *key, const void *data)

{

	const struct remote_event *evt = data;

	int id = (int)((long)key);



	return id - (int)evt->id;

}



static struct remote_event *trace_remote_find_event(struct trace_remote *remote, unsigned short id)

{

	return bsearch((const void *)(unsigned long)id, remote->events, remote->nr_events,

		       sizeof(*remote->events), __cmp_events);

}