Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262// SPDX-License-Identifier: GPL-2.0/* * Copyright (C) 2025 - Google LLC * Author: Vincent Donnefort <vdonnefort@google.com> */
#include <linux/module.h>#include <linux/simple_ring_buffer.h>#include <linux/trace_remote.h>#include <linux/tracefs.h>#include <linux/types.h>
#define REMOTE_EVENT_INCLUDE_FILE kernel/trace/remote_test_events.h#include <trace/define_remote_events.h>
static DEFINE_PER_CPU(struct simple_rb_per_cpu *, simple_rbs);static struct trace_buffer_desc *remote_test_buffer_desc;
/* * The trace_remote lock already serializes accesses from the trace_remote_callbacks. * However write_event can still race with load/unload. */static DEFINE_MUTEX(simple_rbs_lock);
static int remote_test_load_simple_rb(int cpu, struct ring_buffer_desc *rb_desc){ struct simple_rb_per_cpu *cpu_buffer; struct simple_buffer_page *bpages; int ret = -ENOMEM;
cpu_buffer = kmalloc_obj(*cpu_buffer); if (!cpu_buffer) return ret;
bpages = kmalloc_objs(*bpages, rb_desc->nr_page_va); if (!bpages) goto err_free_cpu_buffer;
ret = simple_ring_buffer_init(cpu_buffer, bpages, rb_desc); if (ret) goto err_free_bpages;
scoped_guard(mutex, &simple_rbs_lock) { WARN_ON(*per_cpu_ptr(&simple_rbs, cpu)); *per_cpu_ptr(&simple_rbs, cpu) = cpu_buffer; }
return 0;
err_free_bpages: kfree(bpages);
err_free_cpu_buffer: kfree(cpu_buffer);
return ret;}
static void remote_test_unload_simple_rb(int cpu){ struct simple_rb_per_cpu *cpu_buffer = *per_cpu_ptr(&simple_rbs, cpu); struct simple_buffer_page *bpages;
if (!cpu_buffer) return;
guard(mutex)(&simple_rbs_lock);
bpages = cpu_buffer->bpages; simple_ring_buffer_unload(cpu_buffer); kfree(bpages); kfree(cpu_buffer); *per_cpu_ptr(&simple_rbs, cpu) = NULL;}
static struct trace_buffer_desc *remote_test_load(unsigned long size, void *unused){ struct ring_buffer_desc *rb_desc; struct trace_buffer_desc *desc; size_t desc_size; int cpu, ret;
if (WARN_ON(remote_test_buffer_desc)) return ERR_PTR(-EINVAL);
desc_size = trace_buffer_desc_size(size, num_possible_cpus()); if (desc_size == SIZE_MAX) { ret = -E2BIG; goto err; }
desc = kmalloc(desc_size, GFP_KERNEL); if (!desc) { ret = -ENOMEM; goto err; }
ret = trace_remote_alloc_buffer(desc, desc_size, size, cpu_possible_mask); if (ret) goto err_free_desc;
for_each_ring_buffer_desc(rb_desc, cpu, desc) { ret = remote_test_load_simple_rb(rb_desc->cpu, rb_desc); if (ret) goto err_unload; }
remote_test_buffer_desc = desc;
return remote_test_buffer_desc;
err_unload: for_each_ring_buffer_desc(rb_desc, cpu, desc) remote_test_unload_simple_rb(rb_desc->cpu); trace_remote_free_buffer(desc);
err_free_desc: kfree(desc);
err: return ERR_PTR(ret);}
static void remote_test_unload(struct trace_buffer_desc *desc, void *unused){ struct ring_buffer_desc *rb_desc; int cpu;
if (WARN_ON(desc != remote_test_buffer_desc)) return;
for_each_ring_buffer_desc(rb_desc, cpu, desc) remote_test_unload_simple_rb(rb_desc->cpu);
remote_test_buffer_desc = NULL; trace_remote_free_buffer(desc); kfree(desc);}
static int remote_test_enable_tracing(bool enable, void *unused){ struct ring_buffer_desc *rb_desc; int cpu;
if (!remote_test_buffer_desc) return -ENODEV;
for_each_ring_buffer_desc(rb_desc, cpu, remote_test_buffer_desc) WARN_ON(simple_ring_buffer_enable_tracing(*per_cpu_ptr(&simple_rbs, rb_desc->cpu), enable)); return 0;}
static int remote_test_swap_reader_page(unsigned int cpu, void *unused){ struct simple_rb_per_cpu *cpu_buffer;
if (cpu >= NR_CPUS) return -EINVAL;
cpu_buffer = *per_cpu_ptr(&simple_rbs, cpu); if (!cpu_buffer) return -EINVAL;
return simple_ring_buffer_swap_reader_page(cpu_buffer);}
static int remote_test_reset(unsigned int cpu, void *unused){ struct simple_rb_per_cpu *cpu_buffer;
if (cpu >= NR_CPUS) return -EINVAL;
cpu_buffer = *per_cpu_ptr(&simple_rbs, cpu); if (!cpu_buffer) return -EINVAL;
return simple_ring_buffer_reset(cpu_buffer);}
static int remote_test_enable_event(unsigned short id, bool enable, void *unused){ if (id != REMOTE_TEST_EVENT_ID) return -EINVAL;
/* * Let's just use the struct remote_event enabled field that is turned on and off by * trace_remote. This is a bit racy but good enough for a simple test module. */ return 0;}
static ssize_twrite_event_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *pos){ struct remote_event_format_selftest *evt_test; struct simple_rb_per_cpu *cpu_buffer; unsigned long val; int ret;
ret = kstrtoul_from_user(ubuf, cnt, 10, &val); if (ret) return ret;
guard(mutex)(&simple_rbs_lock);
if (!remote_event_selftest.enabled) return -ENODEV;
guard(preempt)();
cpu_buffer = *this_cpu_ptr(&simple_rbs); if (!cpu_buffer) return -ENODEV;
evt_test = simple_ring_buffer_reserve(cpu_buffer, sizeof(struct remote_event_format_selftest), trace_clock_global()); if (!evt_test) return -ENODEV;
evt_test->hdr.id = REMOTE_TEST_EVENT_ID; evt_test->id = val;
simple_ring_buffer_commit(cpu_buffer);
return cnt;}
static const struct file_operations write_event_fops = { .write = write_event_write,};
static int remote_test_init_tracefs(struct dentry *d, void *unused){ return tracefs_create_file("write_event", 0200, d, NULL, &write_event_fops) ? 0 : -ENOMEM;}
static struct trace_remote_callbacks trace_remote_callbacks = { .init = remote_test_init_tracefs, .load_trace_buffer = remote_test_load, .unload_trace_buffer = remote_test_unload, .enable_tracing = remote_test_enable_tracing, .swap_reader_page = remote_test_swap_reader_page, .reset = remote_test_reset, .enable_event = remote_test_enable_event,};
static int __init remote_test_init(void){ return trace_remote_register("test", &trace_remote_callbacks, NULL, &remote_event_selftest, 1);}
module_init(remote_test_init);
MODULE_DESCRIPTION("Test module for the trace remote interface");MODULE_AUTHOR("Vincent Donnefort");MODULE_LICENSE("GPL");