| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <CAA76j92Eagjv7FjyCHs_fVH+SernJkOQE1htkSB0HDCgnuH37w@mail.gmail.com>
Date: Wed, 1 May 2024 13:09:43 +0200
From: Sergio González Collado <sergio.collado@...il.com>
To: Andreas Hindborg <nmi@...aspace.dk>
Cc: Miguel Ojeda <ojeda@...nel.org>, Alex Gaynor <alex.gaynor@...il.com>,
Wedson Almeida Filho <wedsonaf@...il.com>, Andreas Hindborg <a.hindborg@...sung.com>,
Boqun Feng <boqun.feng@...il.com>, Gary Guo <gary@...yguo.net>,
Björn Roy Baron <bjorn3_gh@...tonmail.com>,
Benno Lossin <benno.lossin@...ton.me>, Alice Ryhl <aliceryhl@...gle.com>,
rust-for-linux@...r.kernel.org, linux-kernel@...r.kernel.org
Subject: Re: [PATCH] kbuild: rust: split up helpers.c
On Tue, 16 Apr 2024 at 09:46, Andreas Hindborg <nmi@...aspace.dk> wrote:
>
> From: Andreas Hindborg <a.hindborg@...sung.com>
>
> 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 <a.hindborg@...sung.com>
> ---
> 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<sergio.collado@...il.com>
Tested-by: Sergio González Collado<sergio.collado@...il.com>
Powered by blists - more mailing lists