2024-04-16 12:51:31

by Andreas Hindborg

[permalink] [raw]
Subject: [PATCH] kbuild: rust: split up helpers.c

From: Andreas Hindborg <[email protected]>

This patch splits up the rust helpers C file. When rebasing patch sets on
upstream linux, merge conflicts in helpers.c is common and time consuming
[1]. Thus, split the file so that each kernel component can live in a
separate file.

This patch lists helper files explicitly and thus conflicts in the file
list is still likely. However, they should be more simple to resolve than
the conflicts usually seen in helpers.c.

Link:
https://rust-for-linux.zulipchat.com/#narrow/stream/288089-General/topic/Splitting.20up.20helpers.2Ec/near/426694012 [1]

Signed-off-by: Andreas Hindborg <[email protected]>
---
rust/Makefile | 36 ++++++--
rust/helpers.c | 180 ------------------------------------
rust/helpers/Makefile | 7 ++
rust/helpers/README.md | 18 ++++
rust/helpers/bug.c | 9 ++
rust/helpers/build_assert.c | 25 +++++
rust/helpers/build_bug.c | 10 ++
rust/helpers/err.c | 22 +++++
rust/helpers/kunit.c | 10 ++
rust/helpers/mutex.c | 10 ++
rust/helpers/refcount.c | 22 +++++
rust/helpers/signal.c | 10 ++
rust/helpers/spinlock.c | 27 ++++++
rust/helpers/task.c | 22 +++++
rust/helpers/wait.c | 10 ++
rust/helpers/workqueue.c | 16 ++++
16 files changed, 246 insertions(+), 188 deletions(-)
delete mode 100644 rust/helpers.c
create mode 100644 rust/helpers/Makefile
create mode 100644 rust/helpers/README.md
create mode 100644 rust/helpers/bug.c
create mode 100644 rust/helpers/build_assert.c
create mode 100644 rust/helpers/build_bug.c
create mode 100644 rust/helpers/err.c
create mode 100644 rust/helpers/kunit.c
create mode 100644 rust/helpers/mutex.c
create mode 100644 rust/helpers/refcount.c
create mode 100644 rust/helpers/signal.c
create mode 100644 rust/helpers/spinlock.c
create mode 100644 rust/helpers/task.c
create mode 100644 rust/helpers/wait.c
create mode 100644 rust/helpers/workqueue.c

diff --git a/rust/Makefile b/rust/Makefile
index 846e6ab9d5a9..ef76dcd5aa7a 100644
--- a/rust/Makefile
+++ b/rust/Makefile
@@ -6,10 +6,22 @@ rustdoc_output := $(objtree)/Documentation/output/rust/rustdoc
obj-$(CONFIG_RUST) += core.o compiler_builtins.o
always-$(CONFIG_RUST) += exports_core_generated.h

-# Missing prototypes are expected in the helpers since these are exported
-# for Rust only, thus there is no header nor prototypes.
-obj-$(CONFIG_RUST) += helpers.o
-CFLAGS_REMOVE_helpers.o = -Wmissing-prototypes -Wmissing-declarations
+RUST_HELPERS := \
+ bug \
+ build_assert \
+ build_bug \
+ err \
+ kunit \
+ mutex \
+ refcount \
+ signal \
+ spinlock\
+ task \
+ wait \
+ workqueue
+
+export RUST_HELPERS
+obj-y += helpers/

always-$(CONFIG_RUST) += libmacros.so
no-clean-files += libmacros.so
@@ -339,6 +351,10 @@ quiet_cmd_bindgen = BINDGEN $@
-o $@ -- $(bindgen_c_flags_final) -DMODULE \
$(bindgen_target_cflags) $(bindgen_target_extra)

+quiet_cmd_cat = CAT $@
+ cmd_cat = \
+ cat $(patsubst %,$(srctree)/$(src)/helpers/%.c, $(RUST_HELPERS)) > $@
+
$(obj)/bindings/bindings_generated.rs: private bindgen_target_flags = \
$(shell grep -Ev '^#|^$$' $(srctree)/$(src)/bindgen_parameters)
$(obj)/bindings/bindings_generated.rs: private bindgen_target_extra = ; \
@@ -353,9 +369,9 @@ $(obj)/uapi/uapi_generated.rs: $(src)/uapi/uapi_helper.h \
$(src)/bindgen_parameters FORCE
$(call if_changed_dep,bindgen)

-# See `CFLAGS_REMOVE_helpers.o` above. In addition, Clang on C does not warn
-# with `-Wmissing-declarations` (unlike GCC), so it is not strictly needed here
-# given it is `libclang`; but for consistency, future Clang changes and/or
+# See `ccflags-remove-y` in helpers/Makefile . In addition, Clang on C does not
+# warn with `-Wmissing-declarations` (unlike GCC), so it is not strictly needed
+# here given it is `libclang`; but for consistency, future Clang changes and/or
# a potential future GCC backend for `bindgen`, we disable it too.
$(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_flags = \
--blocklist-type '.*' --allowlist-var '' \
@@ -364,9 +380,13 @@ $(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_cflags = \
-I$(objtree)/$(obj) -Wno-missing-prototypes -Wno-missing-declarations
$(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_extra = ; \
sed -Ei 's/pub fn rust_helper_([a-zA-Z0-9_]*)/#[link_name="rust_helper_\1"]\n pub fn \1/g' $@
-$(obj)/bindings/bindings_helpers_generated.rs: $(src)/helpers.c FORCE
+$(obj)/bindings/bindings_helpers_generated.rs: $(obj)/helpers/helpers_combined.c FORCE
$(call if_changed_dep,bindgen)

+targets += helpers/helpers_combined.c
+$(obj)/helpers/helpers_combined.c: $(patsubst %,$(src)/helpers/%.c, $(RUST_HELPERS)) FORCE
+ $(call if_changed,cat)
+
quiet_cmd_exports = EXPORTS $@
cmd_exports = \
$(NM) -p --defined-only $< \
diff --git a/rust/helpers.c b/rust/helpers.c
deleted file mode 100644
index 70e59efd92bc..000000000000
--- a/rust/helpers.c
+++ /dev/null
@@ -1,180 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Non-trivial C macros cannot be used in Rust. Similarly, inlined C functions
- * cannot be called either. This file explicitly creates functions ("helpers")
- * that wrap those so that they can be called from Rust.
- *
- * Even though Rust kernel modules should never use directly the bindings, some
- * of these helpers need to be exported because Rust generics and inlined
- * functions may not get their code generated in the crate where they are
- * defined. Other helpers, called from non-inline functions, may not be
- * exported, in principle. However, in general, the Rust compiler does not
- * guarantee codegen will be performed for a non-inline function either.
- * Therefore, this file exports all the helpers. In the future, this may be
- * revisited to reduce the number of exports after the compiler is informed
- * about the places codegen is required.
- *
- * All symbols are exported as GPL-only to guarantee no GPL-only feature is
- * accidentally exposed.
- *
- * Sorted alphabetically.
- */
-
-#include <kunit/test-bug.h>
-#include <linux/bug.h>
-#include <linux/build_bug.h>
-#include <linux/err.h>
-#include <linux/errname.h>
-#include <linux/mutex.h>
-#include <linux/refcount.h>
-#include <linux/sched/signal.h>
-#include <linux/spinlock.h>
-#include <linux/wait.h>
-#include <linux/workqueue.h>
-
-__noreturn void rust_helper_BUG(void)
-{
- BUG();
-}
-EXPORT_SYMBOL_GPL(rust_helper_BUG);
-
-void rust_helper_mutex_lock(struct mutex *lock)
-{
- mutex_lock(lock);
-}
-EXPORT_SYMBOL_GPL(rust_helper_mutex_lock);
-
-void rust_helper___spin_lock_init(spinlock_t *lock, const char *name,
- struct lock_class_key *key)
-{
-#ifdef CONFIG_DEBUG_SPINLOCK
- __raw_spin_lock_init(spinlock_check(lock), name, key, LD_WAIT_CONFIG);
-#else
- spin_lock_init(lock);
-#endif
-}
-EXPORT_SYMBOL_GPL(rust_helper___spin_lock_init);
-
-void rust_helper_spin_lock(spinlock_t *lock)
-{
- spin_lock(lock);
-}
-EXPORT_SYMBOL_GPL(rust_helper_spin_lock);
-
-void rust_helper_spin_unlock(spinlock_t *lock)
-{
- spin_unlock(lock);
-}
-EXPORT_SYMBOL_GPL(rust_helper_spin_unlock);
-
-void rust_helper_init_wait(struct wait_queue_entry *wq_entry)
-{
- init_wait(wq_entry);
-}
-EXPORT_SYMBOL_GPL(rust_helper_init_wait);
-
-int rust_helper_signal_pending(struct task_struct *t)
-{
- return signal_pending(t);
-}
-EXPORT_SYMBOL_GPL(rust_helper_signal_pending);
-
-refcount_t rust_helper_REFCOUNT_INIT(int n)
-{
- return (refcount_t)REFCOUNT_INIT(n);
-}
-EXPORT_SYMBOL_GPL(rust_helper_REFCOUNT_INIT);
-
-void rust_helper_refcount_inc(refcount_t *r)
-{
- refcount_inc(r);
-}
-EXPORT_SYMBOL_GPL(rust_helper_refcount_inc);
-
-bool rust_helper_refcount_dec_and_test(refcount_t *r)
-{
- return refcount_dec_and_test(r);
-}
-EXPORT_SYMBOL_GPL(rust_helper_refcount_dec_and_test);
-
-__force void *rust_helper_ERR_PTR(long err)
-{
- return ERR_PTR(err);
-}
-EXPORT_SYMBOL_GPL(rust_helper_ERR_PTR);
-
-bool rust_helper_IS_ERR(__force const void *ptr)
-{
- return IS_ERR(ptr);
-}
-EXPORT_SYMBOL_GPL(rust_helper_IS_ERR);
-
-long rust_helper_PTR_ERR(__force const void *ptr)
-{
- return PTR_ERR(ptr);
-}
-EXPORT_SYMBOL_GPL(rust_helper_PTR_ERR);
-
-const char *rust_helper_errname(int err)
-{
- return errname(err);
-}
-EXPORT_SYMBOL_GPL(rust_helper_errname);
-
-struct task_struct *rust_helper_get_current(void)
-{
- return current;
-}
-EXPORT_SYMBOL_GPL(rust_helper_get_current);
-
-void rust_helper_get_task_struct(struct task_struct *t)
-{
- get_task_struct(t);
-}
-EXPORT_SYMBOL_GPL(rust_helper_get_task_struct);
-
-void rust_helper_put_task_struct(struct task_struct *t)
-{
- put_task_struct(t);
-}
-EXPORT_SYMBOL_GPL(rust_helper_put_task_struct);
-
-struct kunit *rust_helper_kunit_get_current_test(void)
-{
- return kunit_get_current_test();
-}
-EXPORT_SYMBOL_GPL(rust_helper_kunit_get_current_test);
-
-void rust_helper_init_work_with_key(struct work_struct *work, work_func_t func,
- bool onstack, const char *name,
- struct lock_class_key *key)
-{
- __init_work(work, onstack);
- work->data = (atomic_long_t)WORK_DATA_INIT();
- lockdep_init_map(&work->lockdep_map, name, key, 0);
- INIT_LIST_HEAD(&work->entry);
- work->func = func;
-}
-EXPORT_SYMBOL_GPL(rust_helper_init_work_with_key);
-
-/*
- * `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.
- * `usize` is defined to be the same as C's `uintptr_t` type (can hold any
- * pointer) but not necessarily the same as `size_t` (can hold the size of any
- * single object). Most modern platforms use the same concrete integer type for
- * both of them, but in case we find ourselves on a platform where
- * that's not true, fail early instead of risking ABI or
- * integer-overflow issues.
- *
- * If your platform fails this assertion, it means that you are in
- * danger of integer-overflow bugs (even if you attempt to add
- * `--no-size_t-is-usize`). It may be easiest to change the kernel ABI on
- * your platform such that `size_t` matches `uintptr_t` (i.e., to increase
- * `size_t`, because `uintptr_t` has to be at least as big as `size_t`).
- */
-static_assert(
- sizeof(size_t) == sizeof(uintptr_t) &&
- __alignof__(size_t) == __alignof__(uintptr_t),
- "Rust code expects C `size_t` to match Rust `usize`"
-);
diff --git a/rust/helpers/Makefile b/rust/helpers/Makefile
new file mode 100644
index 000000000000..f0236099f209
--- /dev/null
+++ b/rust/helpers/Makefile
@@ -0,0 +1,7 @@
+
+# Note: `RUST_HELPERS` is defined in `../Makefile`
+
+# Missing prototypes are expected in the helpers since these are exported
+# for Rust only, thus there is no header nor prototypes.
+obj-$(CONFIG_RUST) += $(patsubst %,%.o, $(RUST_HELPERS))
+ccflags-remove-y += -Wmissing-prototypes -Wmissing-declarations
diff --git a/rust/helpers/README.md b/rust/helpers/README.md
new file mode 100644
index 000000000000..7b94ac69878f
--- /dev/null
+++ b/rust/helpers/README.md
@@ -0,0 +1,18 @@
+# Rust Helpers
+
+Non-trivial C macros cannot be used in Rust. Similarly, inlined C functions
+cannot be called either. The files in this directory explicitly create functions
+("helpers") that wrap those so that they can be called from Rust.
+
+Even though Rust kernel modules should never use directly the bindings, some
+of these helpers need to be exported because Rust generics and inlined
+functions may not get their code generated in the crate where they are
+defined. Other helpers, called from non-inline functions, may not be
+exported, in principle. However, in general, the Rust compiler does not
+guarantee codegen will be performed for a non-inline function either.
+Therefore, this file exports all the helpers. In the future, this may be
+revisited to reduce the number of exports after the compiler is informed
+about the places codegen is required.
+
+All symbols are exported as GPL-only to guarantee no GPL-only feature is
+accidentally exposed.
diff --git a/rust/helpers/bug.c b/rust/helpers/bug.c
new file mode 100644
index 000000000000..e2afbad23dcd
--- /dev/null
+++ b/rust/helpers/bug.c
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/bug.h>
+
+__noreturn void rust_helper_BUG(void)
+{
+ BUG();
+}
+EXPORT_SYMBOL_GPL(rust_helper_BUG);
diff --git a/rust/helpers/build_assert.c b/rust/helpers/build_assert.c
new file mode 100644
index 000000000000..6a54b2680b14
--- /dev/null
+++ b/rust/helpers/build_assert.c
@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/build_bug.h>
+
+/*
+ * `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.
+ * `usize` is defined to be the same as C's `uintptr_t` type (can hold any
+ * pointer) but not necessarily the same as `size_t` (can hold the size of any
+ * single object). Most modern platforms use the same concrete integer type for
+ * both of them, but in case we find ourselves on a platform where
+ * that's not true, fail early instead of risking ABI or
+ * integer-overflow issues.
+ *
+ * If your platform fails this assertion, it means that you are in
+ * danger of integer-overflow bugs (even if you attempt to add
+ * `--no-size_t-is-usize`). It may be easiest to change the kernel ABI on
+ * your platform such that `size_t` matches `uintptr_t` (i.e., to increase
+ * `size_t`, because `uintptr_t` has to be at least as big as `size_t`).
+ */
+static_assert(
+ sizeof(size_t) == sizeof(uintptr_t) &&
+ __alignof__(size_t) == __alignof__(uintptr_t),
+ "Rust code expects C `size_t` to match Rust `usize`"
+);
diff --git a/rust/helpers/build_bug.c b/rust/helpers/build_bug.c
new file mode 100644
index 000000000000..f3106f248485
--- /dev/null
+++ b/rust/helpers/build_bug.c
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/export.h>
+#include <linux/errname.h>
+
+const char *rust_helper_errname(int err)
+{
+ return errname(err);
+}
+EXPORT_SYMBOL_GPL(rust_helper_errname);
diff --git a/rust/helpers/err.c b/rust/helpers/err.c
new file mode 100644
index 000000000000..fba4e0be64f5
--- /dev/null
+++ b/rust/helpers/err.c
@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/err.h>
+#include <linux/export.h>
+
+__force void *rust_helper_ERR_PTR(long err)
+{
+ return ERR_PTR(err);
+}
+EXPORT_SYMBOL_GPL(rust_helper_ERR_PTR);
+
+bool rust_helper_IS_ERR(__force const void *ptr)
+{
+ return IS_ERR(ptr);
+}
+EXPORT_SYMBOL_GPL(rust_helper_IS_ERR);
+
+long rust_helper_PTR_ERR(__force const void *ptr)
+{
+ return PTR_ERR(ptr);
+}
+EXPORT_SYMBOL_GPL(rust_helper_PTR_ERR);
diff --git a/rust/helpers/kunit.c b/rust/helpers/kunit.c
new file mode 100644
index 000000000000..905e4ff4424a
--- /dev/null
+++ b/rust/helpers/kunit.c
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <kunit/test-bug.h>
+#include <linux/export.h>
+
+struct kunit *rust_helper_kunit_get_current_test(void)
+{
+ return kunit_get_current_test();
+}
+EXPORT_SYMBOL_GPL(rust_helper_kunit_get_current_test);
diff --git a/rust/helpers/mutex.c b/rust/helpers/mutex.c
new file mode 100644
index 000000000000..29fd141c387d
--- /dev/null
+++ b/rust/helpers/mutex.c
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/export.h>
+#include <linux/mutex.h>
+
+void rust_helper_mutex_lock(struct mutex *lock)
+{
+ mutex_lock(lock);
+}
+EXPORT_SYMBOL_GPL(rust_helper_mutex_lock);
diff --git a/rust/helpers/refcount.c b/rust/helpers/refcount.c
new file mode 100644
index 000000000000..13ab64805f77
--- /dev/null
+++ b/rust/helpers/refcount.c
@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/export.h>
+#include <linux/refcount.h>
+
+refcount_t rust_helper_REFCOUNT_INIT(int n)
+{
+ return (refcount_t)REFCOUNT_INIT(n);
+}
+EXPORT_SYMBOL_GPL(rust_helper_REFCOUNT_INIT);
+
+void rust_helper_refcount_inc(refcount_t *r)
+{
+ refcount_inc(r);
+}
+EXPORT_SYMBOL_GPL(rust_helper_refcount_inc);
+
+bool rust_helper_refcount_dec_and_test(refcount_t *r)
+{
+ return refcount_dec_and_test(r);
+}
+EXPORT_SYMBOL_GPL(rust_helper_refcount_dec_and_test);
diff --git a/rust/helpers/signal.c b/rust/helpers/signal.c
new file mode 100644
index 000000000000..d44e8096b8a9
--- /dev/null
+++ b/rust/helpers/signal.c
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/export.h>
+#include <linux/sched/signal.h>
+
+int rust_helper_signal_pending(struct task_struct *t)
+{
+ return signal_pending(t);
+}
+EXPORT_SYMBOL_GPL(rust_helper_signal_pending);
diff --git a/rust/helpers/spinlock.c b/rust/helpers/spinlock.c
new file mode 100644
index 000000000000..04fd8ddb4986
--- /dev/null
+++ b/rust/helpers/spinlock.c
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/export.h>
+#include <linux/spinlock.h>
+
+void rust_helper___spin_lock_init(spinlock_t *lock, const char *name,
+ struct lock_class_key *key)
+{
+#ifdef CONFIG_DEBUG_SPINLOCK
+ __raw_spin_lock_init(spinlock_check(lock), name, key, LD_WAIT_CONFIG);
+#else
+ spin_lock_init(lock);
+#endif
+}
+EXPORT_SYMBOL_GPL(rust_helper___spin_lock_init);
+
+void rust_helper_spin_lock(spinlock_t *lock)
+{
+ spin_lock(lock);
+}
+EXPORT_SYMBOL_GPL(rust_helper_spin_lock);
+
+void rust_helper_spin_unlock(spinlock_t *lock)
+{
+ spin_unlock(lock);
+}
+EXPORT_SYMBOL_GPL(rust_helper_spin_unlock);
diff --git a/rust/helpers/task.c b/rust/helpers/task.c
new file mode 100644
index 000000000000..b176c347f0d4
--- /dev/null
+++ b/rust/helpers/task.c
@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/export.h>
+#include <linux/sched/task.h>
+
+struct task_struct *rust_helper_get_current(void)
+{
+ return current;
+}
+EXPORT_SYMBOL_GPL(rust_helper_get_current);
+
+void rust_helper_get_task_struct(struct task_struct *t)
+{
+ get_task_struct(t);
+}
+EXPORT_SYMBOL_GPL(rust_helper_get_task_struct);
+
+void rust_helper_put_task_struct(struct task_struct *t)
+{
+ put_task_struct(t);
+}
+EXPORT_SYMBOL_GPL(rust_helper_put_task_struct);
diff --git a/rust/helpers/wait.c b/rust/helpers/wait.c
new file mode 100644
index 000000000000..bf361f40c7cb
--- /dev/null
+++ b/rust/helpers/wait.c
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/export.h>
+#include <linux/wait.h>
+
+void rust_helper_init_wait(struct wait_queue_entry *wq_entry)
+{
+ init_wait(wq_entry);
+}
+EXPORT_SYMBOL_GPL(rust_helper_init_wait);
diff --git a/rust/helpers/workqueue.c b/rust/helpers/workqueue.c
new file mode 100644
index 000000000000..12e2ee66aa4f
--- /dev/null
+++ b/rust/helpers/workqueue.c
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/export.h>
+#include <linux/workqueue.h>
+
+void rust_helper_init_work_with_key(struct work_struct *work, work_func_t func,
+ bool onstack, const char *name,
+ struct lock_class_key *key)
+{
+ __init_work(work, onstack);
+ work->data = (atomic_long_t)WORK_DATA_INIT();
+ lockdep_init_map(&work->lockdep_map, name, key, 0);
+ INIT_LIST_HEAD(&work->entry);
+ work->func = func;
+}
+EXPORT_SYMBOL_GPL(rust_helper_init_work_with_key);

base-commit: 8db31d3f3bd5dbc8cf3a22bba04b4b4add7f984e
--
2.44.0



2024-05-01 11:10:46

by Sergio González Collado

[permalink] [raw]
Subject: Re: [PATCH] kbuild: rust: split up helpers.c

On Tue, 16 Apr 2024 at 09:46, Andreas Hindborg <[email protected]> wrote:
>
> From: Andreas Hindborg <[email protected]>
>
> This patch splits up the rust helpers C file. When rebasing patch sets on
> upstream linux, merge conflicts in helpers.c is common and time consuming
> [1]. Thus, split the file so that each kernel component can live in a
> separate file.
>
> This patch lists helper files explicitly and thus conflicts in the file
> list is still likely. However, they should be more simple to resolve than
> the conflicts usually seen in helpers.c.
>
> Link:
> https://rust-for-linux.zulipchat.com/#narrow/stream/288089-General/topic/Splitting.20up.20helpers.2Ec/near/426694012 [1]
>
> Signed-off-by: Andreas Hindborg <[email protected]>
> ---
> rust/Makefile | 36 ++++++--
> rust/helpers.c | 180 ------------------------------------
> rust/helpers/Makefile | 7 ++
> rust/helpers/README.md | 18 ++++
> rust/helpers/bug.c | 9 ++
> rust/helpers/build_assert.c | 25 +++++
> rust/helpers/build_bug.c | 10 ++
> rust/helpers/err.c | 22 +++++
> rust/helpers/kunit.c | 10 ++
> rust/helpers/mutex.c | 10 ++
> rust/helpers/refcount.c | 22 +++++
> rust/helpers/signal.c | 10 ++
> rust/helpers/spinlock.c | 27 ++++++
> rust/helpers/task.c | 22 +++++
> rust/helpers/wait.c | 10 ++
> rust/helpers/workqueue.c | 16 ++++
> 16 files changed, 246 insertions(+), 188 deletions(-)
> delete mode 100644 rust/helpers.c
> create mode 100644 rust/helpers/Makefile
> create mode 100644 rust/helpers/README.md
> create mode 100644 rust/helpers/bug.c
> create mode 100644 rust/helpers/build_assert.c
> create mode 100644 rust/helpers/build_bug.c
> create mode 100644 rust/helpers/err.c
> create mode 100644 rust/helpers/kunit.c
> create mode 100644 rust/helpers/mutex.c
> create mode 100644 rust/helpers/refcount.c
> create mode 100644 rust/helpers/signal.c
> create mode 100644 rust/helpers/spinlock.c
> create mode 100644 rust/helpers/task.c
> create mode 100644 rust/helpers/wait.c
> create mode 100644 rust/helpers/workqueue.c
>
> diff --git a/rust/Makefile b/rust/Makefile
> index 846e6ab9d5a9..ef76dcd5aa7a 100644
> --- a/rust/Makefile
> +++ b/rust/Makefile
> @@ -6,10 +6,22 @@ rustdoc_output := $(objtree)/Documentation/output/rust/rustdoc
> obj-$(CONFIG_RUST) += core.o compiler_builtins.o
> always-$(CONFIG_RUST) += exports_core_generated.h
>
> -# Missing prototypes are expected in the helpers since these are exported
> -# for Rust only, thus there is no header nor prototypes.
> -obj-$(CONFIG_RUST) += helpers.o
> -CFLAGS_REMOVE_helpers.o = -Wmissing-prototypes -Wmissing-declarations
> +RUST_HELPERS := \
> + bug \
> + build_assert \
> + build_bug \
> + err \
> + kunit \
> + mutex \
> + refcount \
> + signal \
> + spinlock\
> + task \
> + wait \
> + workqueue
> +
> +export RUST_HELPERS
> +obj-y += helpers/
>
> always-$(CONFIG_RUST) += libmacros.so
> no-clean-files += libmacros.so
> @@ -339,6 +351,10 @@ quiet_cmd_bindgen = BINDGEN $@
> -o $@ -- $(bindgen_c_flags_final) -DMODULE \
> $(bindgen_target_cflags) $(bindgen_target_extra)
>
> +quiet_cmd_cat = CAT $@
> + cmd_cat = \
> + cat $(patsubst %,$(srctree)/$(src)/helpers/%.c, $(RUST_HELPERS)) > $@
> +
> $(obj)/bindings/bindings_generated.rs: private bindgen_target_flags = \
> $(shell grep -Ev '^#|^$$' $(srctree)/$(src)/bindgen_parameters)
> $(obj)/bindings/bindings_generated.rs: private bindgen_target_extra = ; \
> @@ -353,9 +369,9 @@ $(obj)/uapi/uapi_generated.rs: $(src)/uapi/uapi_helper.h \
> $(src)/bindgen_parameters FORCE
> $(call if_changed_dep,bindgen)
>
> -# See `CFLAGS_REMOVE_helpers.o` above. In addition, Clang on C does not warn
> -# with `-Wmissing-declarations` (unlike GCC), so it is not strictly needed here
> -# given it is `libclang`; but for consistency, future Clang changes and/or
> +# See `ccflags-remove-y` in helpers/Makefile . In addition, Clang on C does not
> +# warn with `-Wmissing-declarations` (unlike GCC), so it is not strictly needed
> +# here given it is `libclang`; but for consistency, future Clang changes and/or
> # a potential future GCC backend for `bindgen`, we disable it too.
> $(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_flags = \
> --blocklist-type '.*' --allowlist-var '' \
> @@ -364,9 +380,13 @@ $(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_cflags = \
> -I$(objtree)/$(obj) -Wno-missing-prototypes -Wno-missing-declarations
> $(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_extra = ; \
> sed -Ei 's/pub fn rust_helper_([a-zA-Z0-9_]*)/#[link_name="rust_helper_\1"]\n pub fn \1/g' $@
> -$(obj)/bindings/bindings_helpers_generated.rs: $(src)/helpers.c FORCE
> +$(obj)/bindings/bindings_helpers_generated.rs: $(obj)/helpers/helpers_combined.c FORCE
> $(call if_changed_dep,bindgen)
>
> +targets += helpers/helpers_combined.c
> +$(obj)/helpers/helpers_combined.c: $(patsubst %,$(src)/helpers/%.c, $(RUST_HELPERS)) FORCE
> + $(call if_changed,cat)
> +
> quiet_cmd_exports = EXPORTS $@
> cmd_exports = \
> $(NM) -p --defined-only $< \
> diff --git a/rust/helpers.c b/rust/helpers.c
> deleted file mode 100644
> index 70e59efd92bc..000000000000
> --- a/rust/helpers.c
> +++ /dev/null
> @@ -1,180 +0,0 @@
> -// SPDX-License-Identifier: GPL-2.0
> -/*
> - * Non-trivial C macros cannot be used in Rust. Similarly, inlined C functions
> - * cannot be called either. This file explicitly creates functions ("helpers")
> - * that wrap those so that they can be called from Rust.
> - *
> - * Even though Rust kernel modules should never use directly the bindings, some
> - * of these helpers need to be exported because Rust generics and inlined
> - * functions may not get their code generated in the crate where they are
> - * defined. Other helpers, called from non-inline functions, may not be
> - * exported, in principle. However, in general, the Rust compiler does not
> - * guarantee codegen will be performed for a non-inline function either.
> - * Therefore, this file exports all the helpers. In the future, this may be
> - * revisited to reduce the number of exports after the compiler is informed
> - * about the places codegen is required.
> - *
> - * All symbols are exported as GPL-only to guarantee no GPL-only feature is
> - * accidentally exposed.
> - *
> - * Sorted alphabetically.
> - */
> -
> -#include <kunit/test-bug.h>
> -#include <linux/bug.h>
> -#include <linux/build_bug.h>
> -#include <linux/err.h>
> -#include <linux/errname.h>
> -#include <linux/mutex.h>
> -#include <linux/refcount.h>
> -#include <linux/sched/signal.h>
> -#include <linux/spinlock.h>
> -#include <linux/wait.h>
> -#include <linux/workqueue.h>
> -
> -__noreturn void rust_helper_BUG(void)
> -{
> - BUG();
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_BUG);
> -
> -void rust_helper_mutex_lock(struct mutex *lock)
> -{
> - mutex_lock(lock);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_mutex_lock);
> -
> -void rust_helper___spin_lock_init(spinlock_t *lock, const char *name,
> - struct lock_class_key *key)
> -{
> -#ifdef CONFIG_DEBUG_SPINLOCK
> - __raw_spin_lock_init(spinlock_check(lock), name, key, LD_WAIT_CONFIG);
> -#else
> - spin_lock_init(lock);
> -#endif
> -}
> -EXPORT_SYMBOL_GPL(rust_helper___spin_lock_init);
> -
> -void rust_helper_spin_lock(spinlock_t *lock)
> -{
> - spin_lock(lock);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_spin_lock);
> -
> -void rust_helper_spin_unlock(spinlock_t *lock)
> -{
> - spin_unlock(lock);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_spin_unlock);
> -
> -void rust_helper_init_wait(struct wait_queue_entry *wq_entry)
> -{
> - init_wait(wq_entry);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_init_wait);
> -
> -int rust_helper_signal_pending(struct task_struct *t)
> -{
> - return signal_pending(t);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_signal_pending);
> -
> -refcount_t rust_helper_REFCOUNT_INIT(int n)
> -{
> - return (refcount_t)REFCOUNT_INIT(n);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_REFCOUNT_INIT);
> -
> -void rust_helper_refcount_inc(refcount_t *r)
> -{
> - refcount_inc(r);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_refcount_inc);
> -
> -bool rust_helper_refcount_dec_and_test(refcount_t *r)
> -{
> - return refcount_dec_and_test(r);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_refcount_dec_and_test);
> -
> -__force void *rust_helper_ERR_PTR(long err)
> -{
> - return ERR_PTR(err);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_ERR_PTR);
> -
> -bool rust_helper_IS_ERR(__force const void *ptr)
> -{
> - return IS_ERR(ptr);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_IS_ERR);
> -
> -long rust_helper_PTR_ERR(__force const void *ptr)
> -{
> - return PTR_ERR(ptr);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_PTR_ERR);
> -
> -const char *rust_helper_errname(int err)
> -{
> - return errname(err);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_errname);
> -
> -struct task_struct *rust_helper_get_current(void)
> -{
> - return current;
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_get_current);
> -
> -void rust_helper_get_task_struct(struct task_struct *t)
> -{
> - get_task_struct(t);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_get_task_struct);
> -
> -void rust_helper_put_task_struct(struct task_struct *t)
> -{
> - put_task_struct(t);
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_put_task_struct);
> -
> -struct kunit *rust_helper_kunit_get_current_test(void)
> -{
> - return kunit_get_current_test();
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_kunit_get_current_test);
> -
> -void rust_helper_init_work_with_key(struct work_struct *work, work_func_t func,
> - bool onstack, const char *name,
> - struct lock_class_key *key)
> -{
> - __init_work(work, onstack);
> - work->data = (atomic_long_t)WORK_DATA_INIT();
> - lockdep_init_map(&work->lockdep_map, name, key, 0);
> - INIT_LIST_HEAD(&work->entry);
> - work->func = func;
> -}
> -EXPORT_SYMBOL_GPL(rust_helper_init_work_with_key);
> -
> -/*
> - * `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.
> - * `usize` is defined to be the same as C's `uintptr_t` type (can hold any
> - * pointer) but not necessarily the same as `size_t` (can hold the size of any
> - * single object). Most modern platforms use the same concrete integer type for
> - * both of them, but in case we find ourselves on a platform where
> - * that's not true, fail early instead of risking ABI or
> - * integer-overflow issues.
> - *
> - * If your platform fails this assertion, it means that you are in
> - * danger of integer-overflow bugs (even if you attempt to add
> - * `--no-size_t-is-usize`). It may be easiest to change the kernel ABI on
> - * your platform such that `size_t` matches `uintptr_t` (i.e., to increase
> - * `size_t`, because `uintptr_t` has to be at least as big as `size_t`).
> - */
> -static_assert(
> - sizeof(size_t) == sizeof(uintptr_t) &&
> - __alignof__(size_t) == __alignof__(uintptr_t),
> - "Rust code expects C `size_t` to match Rust `usize`"
> -);
> diff --git a/rust/helpers/Makefile b/rust/helpers/Makefile
> new file mode 100644
> index 000000000000..f0236099f209
> --- /dev/null
> +++ b/rust/helpers/Makefile
> @@ -0,0 +1,7 @@
> +
> +# Note: `RUST_HELPERS` is defined in `../Makefile`
> +
> +# Missing prototypes are expected in the helpers since these are exported
> +# for Rust only, thus there is no header nor prototypes.
> +obj-$(CONFIG_RUST) += $(patsubst %,%.o, $(RUST_HELPERS))
> +ccflags-remove-y += -Wmissing-prototypes -Wmissing-declarations
> diff --git a/rust/helpers/README.md b/rust/helpers/README.md
> new file mode 100644
> index 000000000000..7b94ac69878f
> --- /dev/null
> +++ b/rust/helpers/README.md
> @@ -0,0 +1,18 @@
> +# Rust Helpers
> +
> +Non-trivial C macros cannot be used in Rust. Similarly, inlined C functions
> +cannot be called either. The files in this directory explicitly create functions
> +("helpers") that wrap those so that they can be called from Rust.
> +
> +Even though Rust kernel modules should never use directly the bindings, some
> +of these helpers need to be exported because Rust generics and inlined
> +functions may not get their code generated in the crate where they are
> +defined. Other helpers, called from non-inline functions, may not be
> +exported, in principle. However, in general, the Rust compiler does not
> +guarantee codegen will be performed for a non-inline function either.
> +Therefore, this file exports all the helpers. In the future, this may be
> +revisited to reduce the number of exports after the compiler is informed
> +about the places codegen is required.
> +
> +All symbols are exported as GPL-only to guarantee no GPL-only feature is
> +accidentally exposed.
> diff --git a/rust/helpers/bug.c b/rust/helpers/bug.c
> new file mode 100644
> index 000000000000..e2afbad23dcd
> --- /dev/null
> +++ b/rust/helpers/bug.c
> @@ -0,0 +1,9 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/bug.h>
> +
> +__noreturn void rust_helper_BUG(void)
> +{
> + BUG();
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_BUG);
> diff --git a/rust/helpers/build_assert.c b/rust/helpers/build_assert.c
> new file mode 100644
> index 000000000000..6a54b2680b14
> --- /dev/null
> +++ b/rust/helpers/build_assert.c
> @@ -0,0 +1,25 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/build_bug.h>
> +
> +/*
> + * `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.
> + * `usize` is defined to be the same as C's `uintptr_t` type (can hold any
> + * pointer) but not necessarily the same as `size_t` (can hold the size of any
> + * single object). Most modern platforms use the same concrete integer type for
> + * both of them, but in case we find ourselves on a platform where
> + * that's not true, fail early instead of risking ABI or
> + * integer-overflow issues.
> + *
> + * If your platform fails this assertion, it means that you are in
> + * danger of integer-overflow bugs (even if you attempt to add
> + * `--no-size_t-is-usize`). It may be easiest to change the kernel ABI on
> + * your platform such that `size_t` matches `uintptr_t` (i.e., to increase
> + * `size_t`, because `uintptr_t` has to be at least as big as `size_t`).
> + */
> +static_assert(
> + sizeof(size_t) == sizeof(uintptr_t) &&
> + __alignof__(size_t) == __alignof__(uintptr_t),
> + "Rust code expects C `size_t` to match Rust `usize`"
> +);
> diff --git a/rust/helpers/build_bug.c b/rust/helpers/build_bug.c
> new file mode 100644
> index 000000000000..f3106f248485
> --- /dev/null
> +++ b/rust/helpers/build_bug.c
> @@ -0,0 +1,10 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/export.h>
> +#include <linux/errname.h>
> +
> +const char *rust_helper_errname(int err)
> +{
> + return errname(err);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_errname);
> diff --git a/rust/helpers/err.c b/rust/helpers/err.c
> new file mode 100644
> index 000000000000..fba4e0be64f5
> --- /dev/null
> +++ b/rust/helpers/err.c
> @@ -0,0 +1,22 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/err.h>
> +#include <linux/export.h>
> +
> +__force void *rust_helper_ERR_PTR(long err)
> +{
> + return ERR_PTR(err);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_ERR_PTR);
> +
> +bool rust_helper_IS_ERR(__force const void *ptr)
> +{
> + return IS_ERR(ptr);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_IS_ERR);
> +
> +long rust_helper_PTR_ERR(__force const void *ptr)
> +{
> + return PTR_ERR(ptr);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_PTR_ERR);
> diff --git a/rust/helpers/kunit.c b/rust/helpers/kunit.c
> new file mode 100644
> index 000000000000..905e4ff4424a
> --- /dev/null
> +++ b/rust/helpers/kunit.c
> @@ -0,0 +1,10 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <kunit/test-bug.h>
> +#include <linux/export.h>
> +
> +struct kunit *rust_helper_kunit_get_current_test(void)
> +{
> + return kunit_get_current_test();
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_kunit_get_current_test);
> diff --git a/rust/helpers/mutex.c b/rust/helpers/mutex.c
> new file mode 100644
> index 000000000000..29fd141c387d
> --- /dev/null
> +++ b/rust/helpers/mutex.c
> @@ -0,0 +1,10 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/export.h>
> +#include <linux/mutex.h>
> +
> +void rust_helper_mutex_lock(struct mutex *lock)
> +{
> + mutex_lock(lock);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_mutex_lock);
> diff --git a/rust/helpers/refcount.c b/rust/helpers/refcount.c
> new file mode 100644
> index 000000000000..13ab64805f77
> --- /dev/null
> +++ b/rust/helpers/refcount.c
> @@ -0,0 +1,22 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/export.h>
> +#include <linux/refcount.h>
> +
> +refcount_t rust_helper_REFCOUNT_INIT(int n)
> +{
> + return (refcount_t)REFCOUNT_INIT(n);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_REFCOUNT_INIT);
> +
> +void rust_helper_refcount_inc(refcount_t *r)
> +{
> + refcount_inc(r);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_refcount_inc);
> +
> +bool rust_helper_refcount_dec_and_test(refcount_t *r)
> +{
> + return refcount_dec_and_test(r);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_refcount_dec_and_test);
> diff --git a/rust/helpers/signal.c b/rust/helpers/signal.c
> new file mode 100644
> index 000000000000..d44e8096b8a9
> --- /dev/null
> +++ b/rust/helpers/signal.c
> @@ -0,0 +1,10 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/export.h>
> +#include <linux/sched/signal.h>
> +
> +int rust_helper_signal_pending(struct task_struct *t)
> +{
> + return signal_pending(t);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_signal_pending);
> diff --git a/rust/helpers/spinlock.c b/rust/helpers/spinlock.c
> new file mode 100644
> index 000000000000..04fd8ddb4986
> --- /dev/null
> +++ b/rust/helpers/spinlock.c
> @@ -0,0 +1,27 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/export.h>
> +#include <linux/spinlock.h>
> +
> +void rust_helper___spin_lock_init(spinlock_t *lock, const char *name,
> + struct lock_class_key *key)
> +{
> +#ifdef CONFIG_DEBUG_SPINLOCK
> + __raw_spin_lock_init(spinlock_check(lock), name, key, LD_WAIT_CONFIG);
> +#else
> + spin_lock_init(lock);
> +#endif
> +}
> +EXPORT_SYMBOL_GPL(rust_helper___spin_lock_init);
> +
> +void rust_helper_spin_lock(spinlock_t *lock)
> +{
> + spin_lock(lock);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_spin_lock);
> +
> +void rust_helper_spin_unlock(spinlock_t *lock)
> +{
> + spin_unlock(lock);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_spin_unlock);
> diff --git a/rust/helpers/task.c b/rust/helpers/task.c
> new file mode 100644
> index 000000000000..b176c347f0d4
> --- /dev/null
> +++ b/rust/helpers/task.c
> @@ -0,0 +1,22 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/export.h>
> +#include <linux/sched/task.h>
> +
> +struct task_struct *rust_helper_get_current(void)
> +{
> + return current;
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_get_current);
> +
> +void rust_helper_get_task_struct(struct task_struct *t)
> +{
> + get_task_struct(t);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_get_task_struct);
> +
> +void rust_helper_put_task_struct(struct task_struct *t)
> +{
> + put_task_struct(t);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_put_task_struct);
> diff --git a/rust/helpers/wait.c b/rust/helpers/wait.c
> new file mode 100644
> index 000000000000..bf361f40c7cb
> --- /dev/null
> +++ b/rust/helpers/wait.c
> @@ -0,0 +1,10 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/export.h>
> +#include <linux/wait.h>
> +
> +void rust_helper_init_wait(struct wait_queue_entry *wq_entry)
> +{
> + init_wait(wq_entry);
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_init_wait);
> diff --git a/rust/helpers/workqueue.c b/rust/helpers/workqueue.c
> new file mode 100644
> index 000000000000..12e2ee66aa4f
> --- /dev/null
> +++ b/rust/helpers/workqueue.c
> @@ -0,0 +1,16 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/export.h>
> +#include <linux/workqueue.h>
> +
> +void rust_helper_init_work_with_key(struct work_struct *work, work_func_t func,
> + bool onstack, const char *name,
> + struct lock_class_key *key)
> +{
> + __init_work(work, onstack);
> + work->data = (atomic_long_t)WORK_DATA_INIT();
> + lockdep_init_map(&work->lockdep_map, name, key, 0);
> + INIT_LIST_HEAD(&work->entry);
> + work->func = func;
> +}
> +EXPORT_SYMBOL_GPL(rust_helper_init_work_with_key);
>
> base-commit: 8db31d3f3bd5dbc8cf3a22bba04b4b4add7f984e
> --
> 2.44.0
>
>

Reviewed-by: Sergio González Collado<[email protected]>
Tested-by: Sergio González Collado<[email protected]>