Make it possible to have Rust code call into tracepoints defined by C
code. It is still required that the tracepoint is declared in a C
header, and that this header is included in the input to bindgen.
Signed-off-by: Alice Ryhl <alicer...@google.com>
---
rust/bindings/bindings_helper.h | 1 +
rust/bindings/lib.rs | 15 +++++++
rust/helpers.c | 24 +++++++++++
rust/kernel/lib.rs | 1 +
rust/kernel/tracepoint.rs | 92 +++++++++++++++++++++++++++++++++++++++++
5 files changed, 133 insertions(+)
diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h
index ddb5644d4fd9..d442f9ccfc2c 100644
--- a/rust/bindings/bindings_helper.h
+++ b/rust/bindings/bindings_helper.h
@@ -15,6 +15,7 @@
#include <linux/refcount.h>
#include <linux/sched.h>
#include <linux/slab.h>
+#include <linux/tracepoint.h>
#include <linux/wait.h>
#include <linux/workqueue.h>
diff --git a/rust/bindings/lib.rs b/rust/bindings/lib.rs
index 40ddaee50d8b..48856761d682 100644
--- a/rust/bindings/lib.rs
+++ b/rust/bindings/lib.rs
@@ -48,3 +48,18 @@ mod bindings_helper {
}
pub use bindings_raw::*;
+
+/// Rust version of the C macro `rcu_dereference_raw`.
+///
+/// The rust helper only works with void pointers, but this wrapper method
makes it work with any
+/// pointer type using pointer casts.
+///
+/// # Safety
+///
+/// This method has the same safety requirements as the C macro of the same
name.
+#[inline(always)]
+pub unsafe fn rcu_dereference_raw<T>(p: *const *mut T) -> *mut T {
+ // SAFETY: This helper calls into the C macro, so the caller promises to
uphold the safety
+ // requirements.
+ unsafe { __rcu_dereference_raw(p as *mut *mut _) as *mut T }
+}
diff --git a/rust/helpers.c b/rust/helpers.c
index 2c37a0f5d7a8..0560cc2a512a 100644
--- a/rust/helpers.c
+++ b/rust/helpers.c
@@ -165,6 +165,30 @@ rust_helper_krealloc(const void *objp, size_t new_size,
gfp_t flags)
}
EXPORT_SYMBOL_GPL(rust_helper_krealloc);
+void rust_helper_preempt_enable_notrace(void)
+{
+ preempt_enable_notrace();
+}
+EXPORT_SYMBOL_GPL(rust_helper_preempt_enable_notrace);
+
+void rust_helper_preempt_disable_notrace(void)
+{
+ preempt_disable_notrace();
+}
+EXPORT_SYMBOL_GPL(rust_helper_preempt_disable_notrace);
+
+bool rust_helper_current_cpu_online(void)
+{
+ return cpu_online(raw_smp_processor_id());
+}
+EXPORT_SYMBOL_GPL(rust_helper_current_cpu_online);
+
+void *rust_helper___rcu_dereference_raw(void **p)
+{
+ return rcu_dereference_raw(p);
+}
+EXPORT_SYMBOL_GPL(rust_helper___rcu_dereference_raw);
+
/*
* `bindgen` binds the C `size_t` type as the Rust `usize` type, so we can
* use it in contexts where Rust expects a `usize` like slice (array) indices.
diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index 22e1fedd0774..3f3b280bb437 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -46,6 +46,7 @@
pub mod sync;
pub mod task;
pub mod time;
+pub mod tracepoint;
pub mod types;
pub mod workqueue;
diff --git a/rust/kernel/tracepoint.rs b/rust/kernel/tracepoint.rs
new file mode 100644
index 000000000000..d628ae71fc58
--- /dev/null
+++ b/rust/kernel/tracepoint.rs
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: GPL-2.0
+
+// Copyright (C) 2024 Google LLC.
+
+//! Logic for tracepoints.
+
+/// Declare the Rust entry point for a tracepoint.
+#[macro_export]
+macro_rules! declare_trace {
+ ($($(#[$attr:meta])* $pub:vis fn $name:ident($($argname:ident :
$argtyp:ty),* $(,)?);)*) => {$(
+ $( #[$attr] )*
+ #[inline(always)]
+ $pub unsafe fn $name($($argname : $argtyp),*) {
+ #[cfg(CONFIG_TRACEPOINTS)]
+ {
+ use $crate::bindings::*;
+
+ // SAFETY: This macro only compiles if $name is a real
tracepoint, and if it is a
+ // real tracepoint, then it is okay to query the static key.
+ let should_trace = unsafe {
+ $crate::macros::paste! {
+ $crate::static_key::static_key_false!(
+ [< __tracepoint_ $name >],
+ $crate::bindings::tracepoint,
+ key
+ )
+ }
+ };
+
+ if should_trace {
+ $crate::tracepoint::do_trace!($name($($argname :
$argtyp),*), cond);
+ }
+ }
+
+ #[cfg(not(CONFIG_TRACEPOINTS))]
+ {
+ // If tracepoints are disabled, insert a trivial use of each
argument
+ // to avoid unused argument warnings.
+ $( let _unused = $argname; )*
+ }
+ }
+ )*}
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! do_trace {
+ ($name:ident($($argname:ident : $argtyp:ty),* $(,)?), $cond:expr) => {{
+ if !$crate::bindings::current_cpu_online() {
+ return;
+ }
+
+ // SAFETY: This call is balanced with the call below.
+ unsafe { $crate::bindings::preempt_disable_notrace() };
+
+ // SAFETY: This calls the tracepoint with the provided arguments. The
caller of the Rust
+ // wrapper guarantees that this is okay.
+ #[cfg(CONFIG_HAVE_STATIC_CALL)]
+ unsafe {
+ let it_func_ptr: *mut $crate::bindings::tracepoint_func =
+ $crate::bindings::rcu_dereference_raw(
+ ::core::ptr::addr_of!(
+ $crate::macros::concat_idents!(__tracepoint_,
$name).funcs
+ )
+ );
+
+ if !it_func_ptr.is_null() {
+ let __data = (*it_func_ptr).data;
+ $crate::macros::paste! {
+ $crate::static_call::static_call! {
+ [< tp_func_ $name >] (__data, $($argname),*)
+ };
+ }
+ }
+ }
+
+ // SAFETY: This calls the tracepoint with the provided arguments. The
caller of the Rust
+ // wrapper guarantees that this is okay.
+ #[cfg(not(CONFIG_HAVE_STATIC_CALL))]
+ unsafe {
+ $crate::macros::concat_idents!(__traceiter_, $name)(
+ ::core::ptr::null_mut(),
+ $($argname),*
+ );
+ }
+
+ // SAFETY: This call is balanced with the call above.
+ unsafe { $crate::bindings::preempt_enable_notrace() };
+ }}
+}
+
+pub use {declare_trace, do_trace};
--
2.45.2.505.gda0bf45e8d-goog
