From nobody Sat Oct 4 03:10:34 2025 Received: from mail-wm1-f73.google.com (mail-wm1-f73.google.com [209.85.128.73]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 7356322B8CB for ; Fri, 3 Oct 2025 13:39:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.73 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759498755; cv=none; b=HbQbSI1XHVuFHHiK0KDlrRZOouVw7w/BH6EPpuKjxvpf3pGyhqxdcCdCOvY+KGjH1jeG1ckW+LTgB9Rkv8kNOxKtdVSc2ZOrsjbYrYMTIX1i/plk2PxZw99Np3SVUu9hEkkVW+j0evyRo1HFePdU5N07HK0EBgVI6Zmq2aQxgPI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759498755; c=relaxed/simple; bh=xrVBm+FT0XzhRMZkLbkQ3uI8HKhD3I9Ry3Ce2Kr4lCw=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=AAiFEKo/9PCeOj+YDpXnoM2vpbcE9k7zzr4l9hOXNsmv6WouDXivgsCu5mJ9Fl3Qtrf1ts9jY37s8ZscxATPMN42In9Hq1AV1jHe/A6zL1opbAmZmi1h/yMfCecSfV74fk6/cFSzTcZxggCCIB29xXH4W7R6uPsuFTUvXaVZIZk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--vdonnefort.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=y6yv0w31; arc=none smtp.client-ip=209.85.128.73 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--vdonnefort.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="y6yv0w31" Received: by mail-wm1-f73.google.com with SMTP id 5b1f17b1804b1-46e41c32209so9805545e9.0 for ; Fri, 03 Oct 2025 06:39:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1759498750; x=1760103550; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=WBvCjNgRhVQi+n8pjF4GEugOWJdtcq46oEjmHUcdEEI=; b=y6yv0w31/2IYJYwbbIZWRD1M2NT5Haqj0A1Ufir5/adi9a3g0KSv+u1zzZKBQysYNK HjcOYEogp2srDxTbHlZ+gQyozDRlbMl53h4uKSQVt9CGi7umNjsFAt1x5nsOi6qB9yTE +2IoPgsPMwHM2VeK+MTlo4lCjplBCx3IiruDcOzTossZs1tE28//1NLX+zBlutqR4Jza E9AvZz8Ha80JpJEtyh8ZG0me5KpeR3opYGj9MbvQf14HnmkdUXcXI6MR+tEDgg+n3u/K xWJRgwOYiHmGAJ4LpNxDKXK/vFo0gadTaIKMxpj3/YTSgZWccxsfv/8dK9UyrhjDzf8Z VfYA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1759498750; x=1760103550; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=WBvCjNgRhVQi+n8pjF4GEugOWJdtcq46oEjmHUcdEEI=; b=kHRfAqk1kFUP0aUdk9/qqcgLqSFfiDdrTS4XjHZTmLjeWdmU2yDJ/EltobYV5KKc6s joKCfoOjC2FVikITlWJZ2mxxkSvxAxl23Z8AEeyt2d/JSboRJtHJeSOD8K8fggoMDF9l 5mbieA8WtSCrXWnAD+jJbNchRLKQCaehSMLd2ZBy5WngGv+ZNuodsdfGrt1hiUChcnP8 zAGPJzqyUyQnGtk8ODQ40liySwIiGPvcruHtaqgPrDAjQ29z9pmB0yT7z9AiJm5bTOnt 0fpy63x6MQm2wdfns7sHk+/jbFia5qrK6dLnwFP6GiSleoLgA3DJUZjAXu7ofzqj//rb nXaA== X-Forwarded-Encrypted: i=1; AJvYcCWoL7c4d8rCMRZrDx5UopnzNtr7a0BCCh3xz7+ksHyxz5pObdMZf/ocZOrp70XeBlxPaj4NxUzijx7vDXg=@vger.kernel.org X-Gm-Message-State: AOJu0YygK8i4lQEqSPLbOZuX1/w6ZBPTPahio7wzV4NiT7IE7418gaT7 6fxRUafamzsvc+G1DVNyOzDiGIq9gi7ojVzK6lY6cKm94QwbqHVNq5g+D1lZIAdKX7r4Df093Vg LpZ533qe9U47R9enboC9lsw== X-Google-Smtp-Source: AGHT+IEZXqk0h/U8X3T5FaPQjU1b3XgoSS4qKq+zLH3tKMaLXszAm0LYuyPG5fUfKH9oUZtB+8PRN2jt9Kkja4Ej X-Received: from wmby13.prod.google.com ([2002:a05:600c:c04d:b0:46e:3771:b9c9]) (user=vdonnefort job=prod-delivery.src-stubby-dispatcher) by 2002:a05:600c:1993:b0:46e:3d41:5fed with SMTP id 5b1f17b1804b1-46e711026cfmr21469115e9.11.1759498750172; Fri, 03 Oct 2025 06:39:10 -0700 (PDT) Date: Fri, 3 Oct 2025 14:38:11 +0100 In-Reply-To: <20251003133825.2068970-1-vdonnefort@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20251003133825.2068970-1-vdonnefort@google.com> X-Mailer: git-send-email 2.51.0.618.g983fd99d29-goog Message-ID: <20251003133825.2068970-15-vdonnefort@google.com> Subject: [PATCH v7 14/28] tracing: Add a trace remote module for testing From: Vincent Donnefort To: rostedt@goodmis.org, mhiramat@kernel.org, mathieu.desnoyers@efficios.com, linux-trace-kernel@vger.kernel.org, maz@kernel.org, oliver.upton@linux.dev, joey.gouly@arm.com, suzuki.poulose@arm.com, yuzenghui@huawei.com Cc: kvmarm@lists.linux.dev, linux-arm-kernel@lists.infradead.org, jstultz@google.com, qperret@google.com, will@kernel.org, aneesh.kumar@kernel.org, kernel-team@android.com, linux-kernel@vger.kernel.org, Vincent Donnefort Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add a module to help testing the tracefs support for trace remotes. This module: * Use simple_ring_buffer to write into a ring-buffer. * Declare a single "selftest" event that can be triggered from user-space. * Register a "test" trace remote. This is intended to be used by trace remote selftests. Signed-off-by: Vincent Donnefort diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig index 918afcc1fcaf..52131d89993c 100644 --- a/kernel/trace/Kconfig +++ b/kernel/trace/Kconfig @@ -1244,4 +1244,12 @@ config TRACE_REMOTE config SIMPLE_RING_BUFFER bool =20 +config TRACE_REMOTE_TEST + tristate "Test module for remote tracing" + select TRACE_REMOTE + select SIMPLE_RING_BUFFER + help + This trace remote includes a ring-buffer writer implementation using + "simple_ring_buffer". This is solely intending for testing. + endif # FTRACE diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile index 03d7d80a9436..53534447e70b 100644 --- a/kernel/trace/Makefile +++ b/kernel/trace/Makefile @@ -112,4 +112,6 @@ obj-$(CONFIG_RV) +=3D rv/ =20 obj-$(CONFIG_TRACE_REMOTE) +=3D trace_remote.o obj-$(CONFIG_SIMPLE_RING_BUFFER) +=3D simple_ring_buffer.o +obj-$(CONFIG_TRACE_REMOTE_TEST) +=3D remote_test.o + libftrace-y :=3D ftrace.o diff --git a/kernel/trace/remote_test.c b/kernel/trace/remote_test.c new file mode 100644 index 000000000000..059127489c99 --- /dev/null +++ b/kernel/trace/remote_test.c @@ -0,0 +1,259 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2025 - Google LLC + * Author: Vincent Donnefort + */ + +#include +#include +#include +#include +#include + +#define REMOTE_EVENT_INCLUDE_FILE kernel/trace/remote_test_events.h +#include + +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 =3D -ENOMEM; + + cpu_buffer =3D kmalloc(sizeof(*cpu_buffer), GFP_KERNEL); + if (!cpu_buffer) + return ret; + + bpages =3D kmalloc_array(rb_desc->nr_page_va, sizeof(*bpages), GFP_KERNEL= ); + if (!bpages) + goto err_free_cpu_buffer; + + ret =3D simple_ring_buffer_init(cpu_buffer, bpages, rb_desc); + if (ret) + goto err_free_bpages; + + scoped_guard(mutex, &simple_rbs_lock) + *per_cpu_ptr(&simple_rbs, cpu) =3D 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 =3D *per_cpu_ptr(&simple_rbs, cpu); + struct simple_buffer_page *bpages; + + if (!cpu_buffer) + return; + + guard(mutex)(&simple_rbs_lock); + + bpages =3D cpu_buffer->bpages; + simple_ring_buffer_unload(cpu_buffer); + kfree(bpages); + kfree(cpu_buffer); + *per_cpu_ptr(&simple_rbs, cpu) =3D 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 =3D trace_buffer_desc_size(size, num_possible_cpus()); + if (desc_size =3D=3D SIZE_MAX) { + ret =3D -E2BIG; + goto err_unlock_cpus; + } + + desc =3D kmalloc(desc_size, GFP_KERNEL); + if (!desc) { + ret =3D -ENOMEM; + goto err_unlock_cpus; + } + + ret =3D trace_remote_alloc_buffer(desc, desc_size, size, cpu_possible_mas= k); + if (ret) + goto err_free_desc; + + for_each_ring_buffer_desc(rb_desc, cpu, desc) { + ret =3D remote_test_load_simple_rb(rb_desc->cpu, rb_desc); + if (ret) + goto err; + } + + remote_test_buffer_desc =3D desc; + + return remote_test_buffer_desc; + +err: + for_each_ring_buffer_desc(rb_desc, cpu, remote_test_buffer_desc) + remote_test_unload_simple_rb(rb_desc->cpu); + trace_remote_free_buffer(remote_test_buffer_desc); + +err_free_desc: + kfree(desc); + +err_unlock_cpus: + cpus_read_unlock(); + + return ERR_PTR(ret); +} + +static void remote_test_unload(struct trace_buffer_desc *desc, void *unuse= d) +{ + struct ring_buffer_desc *rb_desc; + int cpu; + + if (WARN_ON(desc !=3D 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 =3D 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_d= esc->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 >=3D NR_CPUS) + return -EINVAL; + + cpu_buffer =3D *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 >=3D NR_CPUS) + return -EINVAL; + + cpu_buffer =3D *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 !=3D 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 mod= ule. + */ + return 0; +} + +static ssize_t +write_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 =3D kstrtoul_from_user(ubuf, cnt, 10, &val); + if (ret) + return ret; + + guard(mutex)(&simple_rbs_lock); + + if (!remote_event_selftest.enabled) + return -ENODEV; + + cpu_buffer =3D *this_cpu_ptr(&simple_rbs); + if (!cpu_buffer) + return -ENODEV; + + evt_test =3D simple_ring_buffer_reserve(cpu_buffer, + sizeof(struct remote_event_format_selftest), + trace_clock_global()); + if (!evt_test) + return -ENODEV; + + evt_test->hdr.id =3D REMOTE_TEST_EVENT_ID; + evt_test->id =3D val; + + simple_ring_buffer_commit(cpu_buffer); + + return cnt; +} + +static const struct file_operations write_event_fops =3D { + .write =3D 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_fop= s) ? + 0 : -ENOMEM; +} + +static struct trace_remote_callbacks trace_remote_callbacks =3D { + .init =3D remote_test_init_tracefs, + .load_trace_buffer =3D remote_test_load, + .unload_trace_buffer =3D remote_test_unload, + .enable_tracing =3D remote_test_enable_tracing, + .swap_reader_page =3D remote_test_swap_reader_page, + .reset =3D remote_test_reset, + .enable_event =3D 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"); diff --git a/kernel/trace/remote_test_events.h b/kernel/trace/remote_test_e= vents.h new file mode 100644 index 000000000000..bb68aac4a25c --- /dev/null +++ b/kernel/trace/remote_test_events.h @@ -0,0 +1,10 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#define REMOTE_TEST_EVENT_ID 1 + +REMOTE_EVENT(selftest, REMOTE_TEST_EVENT_ID, + RE_STRUCT( + re_field(u64, id) + ), + RE_PRINTK("id=3D%lld", __entry->id) +); --=20 2.51.0.618.g983fd99d29-goog