| Message ID | 20250213135759.190006-1-fujita.tomonori@gmail.com (mailing list archive) |
|---|---|
| Headers | show |
| Series | rust: Add bug/warn abstractions | expand |
Hi Fujita, "FUJITA Tomonori" <fujita.tomonori@gmail.com> writes: > This patchset adds warn_on and warn_on_once macros with the bug/warn > abstraction. > > Wrapping C's BUG/WARN macros does not work well for x86, RISC-V, > ARM64, and LoongArch. Rust code needs to directly execute the same > assembly code used on the C side. To avoid duplicating the assembly > code, this approach mirrors what the static branch code does: it > generates the assembly code for Rust using the C preprocessor at > compile time. > > The 1st to 4th patches export the BUG/WARN assembly code for Rust on > each architecture, with no functional changes on the C side. The > changes for x86 and RISC-V are straightforward. However, the ARM64 and > LoongArch assembly code are designed differently; they are used by > both C inline assembly and assembly code. As a result, sharing this > code with Rust is complicated. > > The last patch adds the bug abstraction with warn_on and warn_on_once > implementations. > > This has been tested on x86, ARM64, and RISC-V (QEMU), with only a > compile test performed for LoongArch. > > The assembly code can be used for both BUG and WARN, but currently > only supports warn_on and warn_on_once. I will work on the remaining > functionality after this abstraction is merged. > How does this series compare/overlap with [1] ? Best regards, Andreas Hindborg [1] https://lore.kernel.org/all/20241126-pr_once_macros-v4-0-410b8ca9643e@tuta.io/
On Wed, 26 Feb 2025 20:39:45 +0100 Andreas Hindborg <a.hindborg@kernel.org> wrote: > How does this series compare/overlap with [1] ? > > [1] https://lore.kernel.org/all/20241126-pr_once_macros-v4-0-410b8ca9643e@tuta.io/ No overlap. Each solves a different problem. Both are necessary. This patchset enables Rust code to call C's BUG/WARN properly. Currently, Rust's BUG() is a simple wrapper for C's BUG() (rust/helpers/bug.c). I added BUG() to rnull's init() and got the following: # insmod /root/rnull_mod.ko rnull_mod: Rust null_blk loaded ------------[ cut here ]------------ kernel BUG at rust/helpers/bug.c:7! Oops: invalid opcode: 0000 [#1] SMP CPU: 0 UID: 0 PID: 31 Comm: insmod Not tainted 6.14.0-rc1+ #103 RIP: 0010:rust_helper_BUG+0x8/0x10 (snip) This is NOT debug information that we expect. The problem is that BUG/WARN feature (lib/bug.c) can only be used from assembly. This patchset includes only warn() but with bug() implementation on top of this patchset, I got: # insmod /root/rnull_mod.ko rnull_mod: Rust null_blk loaded ------------[ cut here ]------------ WARNING: CPU: 0 PID: 31 at /home/fujita/git/linux-rust/drivers/block/rnull.rs:46 _RNvXCsafUg3oOYix8_5rnullNtB2_13NullBlkModu] Modules linked in: rnull_mod(+) CPU: 0 UID: 0 PID: 31 Comm: insmod Not tainted 6.14.0-rc1+ #104 RIP: 0010:_RNvXCsafUg3oOYix8_5rnullNtB2_13NullBlkModuleNtCsaYBeKL739Xz_6kernel13InPlaceModule4init+0x71/0x4f0 [rnull_mod] The [1] patchset adds an abstraciton for include/linux/once_lite.h, 'call a function once' feature, with pr_*_once() implementation. pr_*_once() just calls printk() once. Unlike BUG/WARN, no debug information (call place, registers, stack trace, etc). The only connection between two patchset is that WARN_ONCE() can be built on top of both like the C side.
"FUJITA Tomonori" <fujita.tomonori@gmail.com> writes: > On Wed, 26 Feb 2025 20:39:45 +0100 > Andreas Hindborg <a.hindborg@kernel.org> wrote: > >> How does this series compare/overlap with [1] ? >> >> [1] https://lore.kernel.org/all/20241126-pr_once_macros-v4-0-410b8ca9643e@tuta.io/ > > No overlap. Each solves a different problem. Both are necessary. > > This patchset enables Rust code to call C's BUG/WARN properly. > > Currently, Rust's BUG() is a simple wrapper for C's BUG() > (rust/helpers/bug.c). I added BUG() to rnull's init() and got the > following: > > # insmod /root/rnull_mod.ko > rnull_mod: Rust null_blk loaded > ------------[ cut here ]------------ > kernel BUG at rust/helpers/bug.c:7! > Oops: invalid opcode: 0000 [#1] SMP > CPU: 0 UID: 0 PID: 31 Comm: insmod Not tainted 6.14.0-rc1+ #103 > RIP: 0010:rust_helper_BUG+0x8/0x10 > (snip) > > This is NOT debug information that we expect. The problem is that > BUG/WARN feature (lib/bug.c) can only be used from assembly. > > This patchset includes only warn() but with bug() implementation on > top of this patchset, I got: > > # insmod /root/rnull_mod.ko > rnull_mod: Rust null_blk loaded > ------------[ cut here ]------------ > WARNING: CPU: 0 PID: 31 at /home/fujita/git/linux-rust/drivers/block/rnull.rs:46 _RNvXCsafUg3oOYix8_5rnullNtB2_13NullBlkModu] > Modules linked in: rnull_mod(+) > CPU: 0 UID: 0 PID: 31 Comm: insmod Not tainted 6.14.0-rc1+ #104 > RIP: 0010:_RNvXCsafUg3oOYix8_5rnullNtB2_13NullBlkModuleNtCsaYBeKL739Xz_6kernel13InPlaceModule4init+0x71/0x4f0 [rnull_mod] > > > The [1] patchset adds an abstraciton for include/linux/once_lite.h, > 'call a function once' feature, with pr_*_once() implementation. > > pr_*_once() just calls printk() once. Unlike BUG/WARN, no debug > information (call place, registers, stack trace, etc). > > > The only connection between two patchset is that WARN_ONCE() can be > built on top of both like the C side. Awesome, thanks for explaining
This patchset adds warn_on and warn_on_once macros with the bug/warn abstraction. Wrapping C's BUG/WARN macros does not work well for x86, RISC-V, ARM64, and LoongArch. Rust code needs to directly execute the same assembly code used on the C side. To avoid duplicating the assembly code, this approach mirrors what the static branch code does: it generates the assembly code for Rust using the C preprocessor at compile time. The 1st to 4th patches export the BUG/WARN assembly code for Rust on each architecture, with no functional changes on the C side. The changes for x86 and RISC-V are straightforward. However, the ARM64 and LoongArch assembly code are designed differently; they are used by both C inline assembly and assembly code. As a result, sharing this code with Rust is complicated. The last patch adds the bug abstraction with warn_on and warn_on_once implementations. This has been tested on x86, ARM64, and RISC-V (QEMU), with only a compile test performed for LoongArch. The assembly code can be used for both BUG and WARN, but currently only supports warn_on and warn_on_once. I will work on the remaining functionality after this abstraction is merged. v3: - rebased on rust-next - use ANNOTATE_REACHABLE macro (replaced ASM_REACHABLE) - added Acked-by tag to the x86 change v2: https://lore.kernel.org/linux-arm-kernel/20241218062009.2402650-1-fujita.tomonori@gmail.com/ - remove target_arch cfg by using asm comment - clean up the changes to loongarch asm v1: https://lore.kernel.org/linux-arm-kernel/20241210001802.228725-1-fujita.tomonori@gmail.com/ FUJITA Tomonori (5): x86/bug: Add ARCH_WARN_ASM macro for BUG/WARN asm code sharing with Rust riscv/bug: Add ARCH_WARN_ASM macro for BUG/WARN asm code sharing with Rust arm64/bug: Add ARCH_WARN_ASM macro for BUG/WARN asm code sharing with Rust loongarch/bug: Add ARCH_WARN_ASM macro for BUG/WARN asm code sharing with Rust rust: Add warn_on and warn_on_once arch/arm64/include/asm/asm-bug.h | 33 +++++- arch/loongarch/include/asm/bug.h | 35 +++++- arch/riscv/include/asm/bug.h | 37 ++++--- arch/x86/include/asm/bug.h | 56 +++++----- rust/Makefile | 8 ++ rust/kernel/.gitignore | 2 + rust/kernel/bug.rs | 100 ++++++++++++++++++ rust/kernel/generated_arch_reachable_asm.rs.S | 7 ++ rust/kernel/generated_arch_warn_asm.rs.S | 7 ++ rust/kernel/lib.rs | 1 + 10 files changed, 235 insertions(+), 51 deletions(-) create mode 100644 rust/kernel/bug.rs create mode 100644 rust/kernel/generated_arch_reachable_asm.rs.S create mode 100644 rust/kernel/generated_arch_warn_asm.rs.S base-commit: beeb78d46249cab8b2b8359a2ce8fa5376b5ad2d