[PATCH 1/3] rust: add static_call support

[Alice Ryhl <aliceryhl@google.com>]

Add static_call support by mirroring how C does. When the platform does
not support static calls (right now, that means that it is not x86),
then the function pointer is loaded from a global and called. Otherwise,
we generate a call to a trampoline function, and objtool is used to make
these calls patchable at runtime.

Signed-off-by: Alice Ryhl <aliceryhl@google.com>
---
 rust/kernel/lib.rs         |  1 +
 rust/kernel/static_call.rs | 92 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 93 insertions(+)

diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index fbd91a48ff8b..d534b1178955 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -38,6 +38,7 @@
 pub mod prelude;
 pub mod print;
 mod static_assert;
+pub mod static_call;
 #[doc(hidden)]
 pub mod std_vendor;
 pub mod str;
diff --git a/rust/kernel/static_call.rs b/rust/kernel/static_call.rs
new file mode 100644
index 000000000000..f7b8ba7bf1fb
--- /dev/null
+++ b/rust/kernel/static_call.rs
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: GPL-2.0
+
+// Copyright (C) 2024 Google LLC.
+
+//! Logic for static calls.
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! ty_underscore_for {
+    ($arg:expr) => {
+        _
+    };
+}
+
+#[doc(hidden)]
+#[repr(transparent)]
+pub struct AddressableStaticCallKey {
+    _ptr: *const bindings::static_call_key,
+}
+unsafe impl Sync for AddressableStaticCallKey {}
+impl AddressableStaticCallKey {
+    pub const fn new(ptr: *const bindings::static_call_key) -> Self {
+        Self { _ptr: ptr }
+    }
+}
+
+#[cfg(CONFIG_HAVE_STATIC_CALL)]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! _static_call {
+    ($name:ident($($args:expr),* $(,)?)) => {{
+        // Symbol mangling will give this symbol a unique name.
+        #[cfg(CONFIG_HAVE_STATIC_CALL_INLINE)]
+        #[link_section = ".discard.addressable"]
+        #[used]
+        static __ADDRESSABLE: $crate::static_call::AddressableStaticCallKey = unsafe {
+            $crate::static_call::AddressableStaticCallKey::new(::core::ptr::addr_of!(
+                $crate::macros::paste! { $crate::bindings:: [<__SCK__ $name >]; }
+            ))
+        };
+
+        let fn_ptr: unsafe extern "C" fn($($crate::static_call::ty_underscore_for!($args)),*) -> _ =
+            $crate::macros::paste! { $crate::bindings:: [<__SCT__ $name >]; };
+        (fn_ptr)($($args),*)
+    }};
+}
+
+#[cfg(not(CONFIG_HAVE_STATIC_CALL))]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! _static_call {
+    ($name:ident($($args:expr),* $(,)?)) => {{
+        let void_ptr_fn: *mut ::core::ffi::c_void =
+            $crate::macros::paste! { $crate::bindings:: [<__SCK__ $name >]; }.func;
+
+        let fn_ptr: unsafe extern "C" fn($($crate::static_call::ty_underscore_for!($args)),*) -> _ =
+            if true {
+                ::core::mem::transmute(void_ptr_fn)
+            } else {
+                // This is dead code, but it influences type inference on `fn_ptr` so that we
+                // transmute the function pointer to the right type.
+                $crate::macros::paste! { $crate::bindings:: [<__SCT__ $name >]; }
+            };
+
+        (fn_ptr)($($args),*)
+    }};
+}
+
+/// Statically call a global function.
+///
+/// # Safety
+///
+/// This macro will call the provided function. It is up to the caller to uphold the safety
+/// guarantees of the function.
+///
+/// # Examples
+///
+/// ```ignore
+/// fn call_static() {
+///     unsafe {
+///         static_call! { your_static_call() };
+///     }
+/// }
+/// ```
+#[macro_export]
+macro_rules! static_call {
+    // Forward to the real implementation. Separated like this so that we don't have to duplicate
+    // the documentation.
+    ($($args:tt)*) => { $crate::static_call::_static_call! { $($args)* } };
+}
+
+pub use {_static_call, static_call, ty_underscore_for};

-- 
2.45.2.505.gda0bf45e8d-goog