Rust support
Subsystems (27)
Miguel Ojeda
maintainerv5 cover Rust support
Rust support
This is the patch series (v5) to add support for Rust as a second language to the Linux kernel.
If you are interested in following this effort, please join us in the mailing list at:
and take a look at the project itself at:
https://github.com/Rust-for-Linux
As usual, special thanks go to ISRG (Internet Security Research Group) and Google for their financial support on this endeavor.
Cheers,
Miguel
--
# Rust support
This cover letter explains the major changes and updates done since the previous ones. For those, please see:
RFC: https://lore.kernel.org/lkml/[email protected]/ v1: https://lore.kernel.org/lkml/[email protected]/ v2: https://lore.kernel.org/lkml/[email protected]/ v3: https://lore.kernel.org/lkml/[email protected]/ v4: https://lore.kernel.org/lkml/[email protected]/
## Infrastructure updates
There have been several improvements to the overall Rust support:
- The toolchain and alloc have been upgraded to Rust 1.59.0. This version stabilized feature(global_asm) as well as the -Csymbol-mangling-version=v0 flag.
- Added support for host programs written in Rust. This should only be used in scenarios where Rust is required to be available.
- Target specification files are now generated on the fly based on the kernel configuration, via a Rust script, instead of having a few predefined files.
The content of the generated file has been simplified and, for x86, all the options that can be specified through the command-line have been moved to the architecture Makefile.
The goal is to reduce the content of the file as much as possible for all architectures, and eventually, stop needing such a file.
- Added HAVE_RUST kernel option. This symbol should be selected by an architecture if it supports Rust.
- Added documentation on RUSTFLAGS* and KBUILD_RUST* variables.
- Simplified tags and cross-references in the documentation.
- Other cleanups, fixes and improvements on the build system.
## Abstractions and driver updates
Some of the improvements to the abstractions and example drivers are:
- Added abstraction for the Hardware Random Number Generator.
- %pA rework in vsprintf following the review.
- The sync sample now shows how to use static mutexes and conditional variables.
- Error codes can now be used without prefixing them with
`Error::`, which makes using them closer to C. For instance:
fn f(...) -> Result {
if ... {
return Err(EINVAL);
}
...
Ok(())
} - Added CString type for owned C strings.
- miscdev registration now holds an owned C string, which enables scenarios when the device name is constructed at runtime.
- Added Bool trait meant to be used in type states to allow boolean constraints in implementation blocks.
- Added LockInfo trait that lock "type states" must implement. This allows the definition of additional writable type states.
- Simplification of the spin lock implementation by splitting acquisition types. Type states are used to implement two versions of the Lock trait: one which never modifies the interrupt state and one that disables them (if they are enabled, then re-enables on unlock).
- Result::unwrap can now be used in examples that are compiled, linked and run.
- Merged Formatter and Buffer types.
- Added IoMem::offset_ok for runtime sizes.
- Other cleanups, fixes and improvements.
## Patch series status
The Rust support is still to be considered experimental. However, support is good enough that kernel developers can start working on the Rust abstractions for subsystems and write drivers and other modules.
The current series has just arrived in linux-next, as usual. Similarly, the preview docs for this series can be seen at:
https://rust-for-linux.github.io/docs/kernel/
As usual, please see the following link for the
live list of unstable Rust features we are using:
https://github.com/Rust-for-Linux/linux/issues/2
Note that this time the series depends on a patch queued in powerpc-next:
https://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git/commit/?h=next&id=d4be60fe66b7380530868ceebe549f8eebccacc5
## Acknowledgements
The signatures in the main commits correspond to the people that wrote code that has ended up in them at the present time. For details on contributions to code and discussions, please see our repository:
https://github.com/Rust-for-Linux/linux
However, we would like to give credit to everyone that has contributed in one way or another to the Rust for Linux project. Since the previous cover letter:
- Akira Yokosawa for a detailed review of the documentation and suggesting several improvements.
- Petr Mladek and Rasmus Villemoes for their printing/formatting review and suggestions.
- Russell King for his review of the Kconfig changes.
- Andy Shevchenko, Sergey Senozhatsky, John Paul Adrian Glaubitz and David Laight for their reviews and feedback on the previous round.
- bjorn3 for reviewing many PRs.
- As usual, bjorn3 and Gary Guo for all the input on Rust compiler details and suggestions.
- Philip Li, Yujie Liu et al. for continuing their work on adding Rust support to the Intel 0DAY/LKP kernel test robot. Also, thanks to Nathan Chancellor and Nick Desaulniers for their input.
- Wei Liu for taking the time to answer questions from newcomers in Zulip.
- Antoni Boucher (and his supporters) et al. for their ongoing work on rustc_codegen_gcc.
- Philip Herrons (and his supporters Open Source Security and Embecosm) et al. for their ongoing work on GCC Rust.
- Mats Larsen, Marc Poulhiès et al. for their ongoing work on improving Rust support in Compiler Explorer.
- Many folks that have reported issues, tested the project, helped spread the word, joined discussions and contributed in other ways!
Please see also the acknowledgements on the previous cover letters.
Boqun Feng (1):
kallsyms: use the correct buffer size for symbols
Gary Guo (2):
rust: add build_error crate
vsprintf: add new %pA format specifier
Miguel Ojeda (13):
kallsyms: support "big" kernel symbols
kallsyms: increase maximum kernel symbol length to 512
rust: add C helpers
rust: add compiler_builtins crate
rust: add alloc crate
rust: add macros crate
rust: export generated symbols
scripts: add generate_rust_analyzer.py
scripts: decode_stacktrace: demangle Rust symbols
docs: add Rust documentation
Kbuild: add Rust support
samples: add Rust examples
MAINTAINERS: Rust
Wedson Almeida Filho (4):
rust: add kernel crate's sync module
rust: add kernel crate
[RFC] drivers: gpio: PrimeCell PL061 in Rust
[RFC] drivers: android: Binder IPC in Rust
.gitignore | 5 + .rustfmt.toml | 12 + Documentation/doc-guide/kernel-doc.rst | 3 + Documentation/index.rst | 1 + Documentation/kbuild/kbuild.rst | 17 + Documentation/kbuild/makefiles.rst | 50 +- Documentation/process/changes.rst | 41 + Documentation/rust/arch-support.rst | 34 + Documentation/rust/coding-guidelines.rst | 214 ++ Documentation/rust/general-information.rst | 77 + Documentation/rust/index.rst | 20 + Documentation/rust/logo.svg | 357 ++ Documentation/rust/quick-start.rst | 230 ++ MAINTAINERS | 15 + Makefile | 173 +- arch/Kconfig | 6 + arch/arm/Kconfig | 1 + arch/arm64/Kconfig | 1 + arch/powerpc/Kconfig | 1 + arch/riscv/Kconfig | 1 + arch/riscv/Makefile | 5 + arch/x86/Kconfig | 1 + arch/x86/Makefile | 14 + drivers/android/Kconfig | 6 + drivers/android/Makefile | 2 + drivers/android/allocation.rs | 266 ++ drivers/android/context.rs | 80 + drivers/android/defs.rs | 99 + drivers/android/node.rs | 476 +++ drivers/android/process.rs | 960 +++++ drivers/android/range_alloc.rs | 189 + drivers/android/rust_binder.rs | 111 + drivers/android/thread.rs | 870 +++++ drivers/android/transaction.rs | 326 ++ drivers/gpio/Kconfig | 8 + drivers/gpio/Makefile | 1 + drivers/gpio/gpio_pl061_rust.rs | 370 ++ include/linux/kallsyms.h | 2 +- include/linux/spinlock.h | 17 +- include/uapi/linux/android/binder.h | 28 +- init/Kconfig | 44 +- kernel/kallsyms.c | 26 +- kernel/livepatch/core.c | 4 +- lib/Kconfig.debug | 143 + lib/vsprintf.c | 13 + rust/.gitignore | 8 + rust/Makefile | 376 ++ rust/alloc/README.md | 32 + rust/alloc/alloc.rs | 440 +++ rust/alloc/borrow.rs | 498 +++ rust/alloc/boxed.rs | 2008 +++++++++++ rust/alloc/collections/mod.rs | 156 + rust/alloc/fmt.rs | 601 ++++ rust/alloc/lib.rs | 231 ++ rust/alloc/macros.rs | 126 + rust/alloc/raw_vec.rs | 561 +++ rust/alloc/slice.rs | 1279 +++++++ rust/alloc/str.rs | 632 ++++ rust/alloc/string.rs | 2862 +++++++++++++++ rust/alloc/vec/drain.rs | 186 + rust/alloc/vec/drain_filter.rs | 145 + rust/alloc/vec/into_iter.rs | 356 ++ rust/alloc/vec/is_zero.rs | 106 + rust/alloc/vec/mod.rs | 3353 ++++++++++++++++++ rust/alloc/vec/partial_eq.rs | 49 + rust/alloc/vec/set_len_on_drop.rs | 30 + rust/alloc/vec/spec_extend.rs | 174 + rust/bindgen_parameters | 13 + rust/build_error.rs | 29 + rust/compiler_builtins.rs | 57 + rust/exports.c | 20 + rust/helpers.c | 531 +++ rust/kernel/allocator.rs | 65 + rust/kernel/amba.rs | 259 ++ rust/kernel/bindings.rs | 47 + rust/kernel/bindings_helper.h | 37 + rust/kernel/build_assert.rs | 80 + rust/kernel/c_types.rs | 119 + rust/kernel/chrdev.rs | 207 ++ rust/kernel/clk.rs | 75 + rust/kernel/cred.rs | 73 + rust/kernel/device.rs | 554 +++ rust/kernel/driver.rs | 440 +++ rust/kernel/error.rs | 560 +++ rust/kernel/file.rs | 873 +++++ rust/kernel/gpio.rs | 478 +++ rust/kernel/hwrng.rs | 242 ++ rust/kernel/io_buffer.rs | 153 + rust/kernel/io_mem.rs | 237 ++ rust/kernel/iov_iter.rs | 81 + rust/kernel/irq.rs | 409 +++ rust/kernel/lib.rs | 260 ++ rust/kernel/linked_list.rs | 247 ++ rust/kernel/miscdev.rs | 291 ++ rust/kernel/mm.rs | 149 + rust/kernel/module_param.rs | 498 +++ rust/kernel/of.rs | 63 + rust/kernel/pages.rs | 144 + rust/kernel/platform.rs | 224 ++ rust/kernel/power.rs | 118 + rust/kernel/prelude.rs | 36 + rust/kernel/print.rs | 414 +++ rust/kernel/random.rs | 50 + rust/kernel/raw_list.rs | 361 ++ rust/kernel/rbtree.rs | 562 +++ rust/kernel/revocable.rs | 163 + rust/kernel/security.rs | 36 + rust/kernel/static_assert.rs | 39 + rust/kernel/std_vendor.rs | 150 + rust/kernel/str.rs | 592 ++++ rust/kernel/sync/arc.rs | 500 +++ rust/kernel/sync/condvar.rs | 138 + rust/kernel/sync/guard.rs | 166 + rust/kernel/sync/locked_by.rs | 112 + rust/kernel/sync/mod.rs | 157 + rust/kernel/sync/mutex.rs | 114 + rust/kernel/sync/revocable_mutex.rs | 184 + rust/kernel/sync/rwsem.rs | 149 + rust/kernel/sync/seqlock.rs | 202 ++ rust/kernel/sync/spinlock.rs | 192 + rust/kernel/sysctl.rs | 199 ++ rust/kernel/task.rs | 182 + rust/kernel/types.rs | 569 +++ rust/kernel/user_ptr.rs | 175 + rust/macros/helpers.rs | 79 + rust/macros/lib.rs | 94 + rust/macros/module.rs | 631 ++++ samples/Kconfig | 2 + samples/Makefile | 1 + samples/rust/Kconfig | 130 + samples/rust/Makefile | 15 + samples/rust/hostprogs/.gitignore | 3 + samples/rust/hostprogs/Makefile | 5 + samples/rust/hostprogs/a.rs | 7 + samples/rust/hostprogs/b.rs | 5 + samples/rust/hostprogs/single.rs | 12 + samples/rust/rust_chrdev.rs | 50 + samples/rust/rust_minimal.rs | 35 + samples/rust/rust_miscdev.rs | 143 + samples/rust/rust_module_parameters.rs | 69 + samples/rust/rust_platform.rs | 22 + samples/rust/rust_print.rs | 54 + samples/rust/rust_random.rs | 60 + samples/rust/rust_semaphore.rs | 171 + samples/rust/rust_semaphore_c.c | 212 ++ samples/rust/rust_stack_probing.rs | 36 + samples/rust/rust_sync.rs | 93 + scripts/.gitignore | 1 + scripts/Kconfig.include | 6 +- scripts/Makefile | 3 + scripts/Makefile.build | 60 + scripts/Makefile.debug | 10 + scripts/Makefile.host | 34 +- scripts/Makefile.lib | 12 + scripts/Makefile.modfinal | 8 +- scripts/cc-version.sh | 12 +- scripts/decode_stacktrace.sh | 14 + scripts/generate_rust_analyzer.py | 133 + scripts/generate_rust_target.rs | 227 ++ scripts/is_rust_module.sh | 13 + scripts/kallsyms.c | 40 +- scripts/kconfig/confdata.c | 75 + scripts/min-tool-version.sh | 6 + scripts/rust-is-available-bindgen-libclang.h | 2 + scripts/rust-is-available.sh | 158 + tools/include/linux/kallsyms.h | 2 +- tools/lib/perf/include/perf/event.h | 2 +- tools/lib/symbol/kallsyms.h | 2 +- 168 files changed, 35290 insertions(+), 63 deletions(-) create mode 100644 .rustfmt.toml create mode 100644 Documentation/rust/arch-support.rst create mode 100644 Documentation/rust/coding-guidelines.rst create mode 100644 Documentation/rust/general-information.rst create mode 100644 Documentation/rust/index.rst create mode 100644 Documentation/rust/logo.svg create mode 100644 Documentation/rust/quick-start.rst create mode 100644 drivers/android/allocation.rs create mode 100644 drivers/android/context.rs create mode 100644 drivers/android/defs.rs create mode 100644 drivers/android/node.rs create mode 100644 drivers/android/process.rs create mode 100644 drivers/android/range_alloc.rs create mode 100644 drivers/android/rust_binder.rs create mode 100644 drivers/android/thread.rs create mode 100644 drivers/android/transaction.rs create mode 100644 drivers/gpio/gpio_pl061_rust.rs create mode 100644 rust/.gitignore create mode 100644 rust/Makefile create mode 100644 rust/alloc/README.md create mode 100644 rust/alloc/alloc.rs create mode 100644 rust/alloc/borrow.rs create mode 100644 rust/alloc/boxed.rs create mode 100644 rust/alloc/collections/mod.rs create mode 100644 rust/alloc/fmt.rs create mode 100644 rust/alloc/lib.rs create mode 100644 rust/alloc/macros.rs create mode 100644 rust/alloc/raw_vec.rs create mode 100644 rust/alloc/slice.rs create mode 100644 rust/alloc/str.rs create mode 100644 rust/alloc/string.rs create mode 100644 rust/alloc/vec/drain.rs create mode 100644 rust/alloc/vec/drain_filter.rs create mode 100644 rust/alloc/vec/into_iter.rs create mode 100644 rust/alloc/vec/is_zero.rs create mode 100644 rust/alloc/vec/mod.rs create mode 100644 rust/alloc/vec/partial_eq.rs create mode 100644 rust/alloc/vec/set_len_on_drop.rs create mode 100644 rust/alloc/vec/spec_extend.rs create mode 100644 rust/bindgen_parameters create mode 100644 rust/build_error.rs create mode 100644 rust/compiler_builtins.rs create mode 100644 rust/exports.c create mode 100644 rust/helpers.c create mode 100644 rust/kernel/allocator.rs create mode 100644 rust/kernel/amba.rs create mode 100644 rust/kernel/bindings.rs create mode 100644 rust/kernel/bindings_helper.h create mode 100644 rust/kernel/build_assert.rs create mode 100644 rust/kernel/c_types.rs create mode 100644 rust/kernel/chrdev.rs create mode 100644 rust/kernel/clk.rs create mode 100644 rust/kernel/cred.rs create mode 100644 rust/kernel/device.rs create mode 100644 rust/kernel/driver.rs create mode 100644 rust/kernel/error.rs create mode 100644 rust/kernel/file.rs create mode 100644 rust/kernel/gpio.rs create mode 100644 rust/kernel/hwrng.rs create mode 100644 rust/kernel/io_buffer.rs create mode 100644 rust/kernel/io_mem.rs create mode 100644 rust/kernel/iov_iter.rs create mode 100644 rust/kernel/irq.rs create mode 100644 rust/kernel/lib.rs create mode 100644 rust/kernel/linked_list.rs create mode 100644 rust/kernel/miscdev.rs create mode 100644 rust/kernel/mm.rs create mode 100644 rust/kernel/module_param.rs create mode 100644 rust/kernel/of.rs create mode 100644 rust/kernel/pages.rs create mode 100644 rust/kernel/platform.rs create mode 100644 rust/kernel/power.rs create mode 100644 rust/kernel/prelude.rs create mode 100644 rust/kernel/print.rs create mode 100644 rust/kernel/random.rs create mode 100644 rust/kernel/raw_list.rs create mode 100644 rust/kernel/rbtree.rs create mode 100644 rust/kernel/revocable.rs create mode 100644 rust/kernel/security.rs create mode 100644 rust/kernel/static_assert.rs create mode 100644 rust/kernel/std_vendor.rs create mode 100644 rust/kernel/str.rs create mode 100644 rust/kernel/sync/arc.rs create mode 100644 rust/kernel/sync/condvar.rs create mode 100644 rust/kernel/sync/guard.rs create mode 100644 rust/kernel/sync/locked_by.rs create mode 100644 rust/kernel/sync/mod.rs create mode 100644 rust/kernel/sync/mutex.rs create mode 100644 rust/kernel/sync/revocable_mutex.rs create mode 100644 rust/kernel/sync/rwsem.rs create mode 100644 rust/kernel/sync/seqlock.rs create mode 100644 rust/kernel/sync/spinlock.rs create mode 100644 rust/kernel/sysctl.rs create mode 100644 rust/kernel/task.rs create mode 100644 rust/kernel/types.rs create mode 100644 rust/kernel/user_ptr.rs create mode 100644 rust/macros/helpers.rs create mode 100644 rust/macros/lib.rs create mode 100644 rust/macros/module.rs create mode 100644 samples/rust/Kconfig create mode 100644 samples/rust/Makefile create mode 100644 samples/rust/hostprogs/.gitignore create mode 100644 samples/rust/hostprogs/Makefile create mode 100644 samples/rust/hostprogs/a.rs create mode 100644 samples/rust/hostprogs/b.rs create mode 100644 samples/rust/hostprogs/single.rs create mode 100644 samples/rust/rust_chrdev.rs create mode 100644 samples/rust/rust_minimal.rs create mode 100644 samples/rust/rust_miscdev.rs create mode 100644 samples/rust/rust_module_parameters.rs create mode 100644 samples/rust/rust_platform.rs create mode 100644 samples/rust/rust_print.rs create mode 100644 samples/rust/rust_random.rs create mode 100644 samples/rust/rust_semaphore.rs create mode 100644 samples/rust/rust_semaphore_c.c create mode 100644 samples/rust/rust_stack_probing.rs create mode 100644 samples/rust/rust_sync.rs create mode 100755 scripts/generate_rust_analyzer.py create mode 100644 scripts/generate_rust_target.rs create mode 100755 scripts/is_rust_module.sh create mode 100644 scripts/rust-is-available-bindgen-libclang.h create mode 100755 scripts/rust-is-available.sh
base-commit: 09688c0166e76ce2fb85e86b9d99be8b0084cdf9
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 1/20 kallsyms: support "big" kernel symbols
Rust symbols can become quite long due to namespacing introduced by modules, types, traits, generics, etc.
Increasing to 255 is not enough in some cases, and therefore we need to introduce longer lengths to the symbol table.
In order to avoid increasing all lengths to 2 bytes (since most of them are small, including many Rust ones), we use ULEB128 to keep smaller symbols in 1 byte, with the rest in 2 bytes.
--- kernel/kallsyms.c | 26 ++++++++++++++++++++++---- scripts/kallsyms.c | 29 ++++++++++++++++++++++++++--- 2 files changed, 48 insertions(+), 7 deletions(-)
kernel/kallsyms.c +22 -4
@@ -69,12 +69,20 @@ static unsigned int kallsyms_expand_symbol(unsigned int off, data = &kallsyms_names[off]; len = *data; data++; + off++; + +/* If MSB is 1, it is a "big" symbol, so needs an additional byte. */ +if ((len &0x80 ) !=0 ) { + len = (len &0x7F ) | (*data <<7 ); + data++; + off++; + }/* * Update the offset to return the offset for the next symbol on * the compressed stream. */ - off += len +1 ; + off += len;/* * For every byte on the compressed symbol data, copy the table
@@ -127,7 +135,7 @@ static char kallsyms_get_symbol_type(unsigned int off)static unsigned int get_symbol_offset (unsigned long pos) {const u8 *name; -int i; +int i, len;/* * Use the closest marker we have. We have markers every 256 positions,
@@ -141,8 +149,18 @@ static unsigned int get_symbol_offset(unsigned long pos)* so we just need to add the len to the current pointer for every * symbol we wish to skip. */ -for (i =0 ; i < (pos &0xFF ); i++) - name = name + (*name) +1 ; +for (i =0 ; i < (pos &0xFF ); i++) { + len = *name; + +/* +* If MSB is 1, it is a "big" symbol, so we need to look into +* the next byte (and skip it, too). +*/ +if ((len &0x80 ) !=0 ) + len = ((len &0x7F ) | (name[1 ] <<7 )) +1 ; + + name = name + len +1 ; + }return name - kallsyms_names; }
scripts/kallsyms.c +26 -3
@@ -470,12 +470,35 @@ static void write_src(void)if ((i &0xFF ) ==0 ) markers[i >>8 ] = off; -printf ("\t.byte 0x%02x" , table[i]->len); +/* There cannot be any symbol of length zero. */ +if (table[i]->len ==0 ) { +fprintf (stderr,"kallsyms failure: " +"unexpected zero symbol length\n" ); +exit (EXIT_FAILURE ); + } + +/* Only lengths that fit in up-to-two-byte ULEB128 are supported. */ +if (table[i]->len >0x3FFF ) { +fprintf (stderr,"kallsyms failure: " +"unexpected huge symbol length\n" ); +exit (EXIT_FAILURE ); + } + +/* Encode length with ULEB128. */ +if (table[i]->len <=0x7F ) { +/* Most symbols use a single byte for the length. */ +printf ("\t.byte 0x%02x" , table[i]->len); + off += table[i]->len +1 ; + }else { +/* "Big" symbols use two bytes. */ +printf ("\t.byte 0x%02x, 0x%02x" , + (table[i]->len &0x7F ) |0x80 , + (table[i]->len >>7 ) &0x7F ); + off += table[i]->len +2 ; + }for (k =0 ; k < table[i]->len; k++)printf (", 0x%02x" , table[i]->sym[k]);printf ("\n" ); - - off += table[i]->len +1 ; }printf ("\n" );
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 2/20 kallsyms: increase maximum kernel symbol length to 512
In reply to Miguel OjedaRust symbols can become quite long due to namespacing introduced by modules, types, traits, generics, etc. For instance, the following code:
pub mod my_module {
pub struct MyType;
pub struct MyGenericType<T>(T);
pub trait MyTrait {
fn my_method() -> u32;
}
impl MyTrait for MyGenericType<MyType> {
fn my_method() -> u32 {
42
}
}
}generates a symbol of length 96 when using the upcoming v0 mangling scheme:
_RNvXNtCshGpAVYOtgW1_7example9my_moduleINtB2_13MyGenericTypeNtB2_6MyTypeENtB2_7MyTrait9my_method
At the moment, Rust symbols may reach up to 300 in length. Setting 512 as the maximum seems like a reasonable choice to keep some headroom.
--- include/linux/kallsyms.h | 2 +- kernel/livepatch/core.c | 4 ++-- scripts/kallsyms.c | 2 +- tools/include/linux/kallsyms.h | 2 +- tools/lib/perf/include/perf/event.h | 2 +- tools/lib/symbol/kallsyms.h | 2 +- 6 files changed, 7 insertions(+), 7 deletions(-)
include/linux/kallsyms.h +1 -1
@@ -15,7 +15,7 @@#include <asm/sections.h> -#define KSYM_NAME_LEN 128 +#define KSYM_NAME_LEN 512#define KSYM_SYMBOL_LEN (sizeof("%s+%#lx/%#lx [%s %s]") + \ (KSYM_NAME_LEN - 1) + \ 2*(BITS_PER_LONG*3/10) + (MODULE_NAME_LEN - 1) + \
kernel/livepatch/core.c +2 -2
@@ -213,7 +213,7 @@ static int klp_resolve_symbols(Elf64_Shdr *sechdrs, const char *strtab,* we use the smallest/strictest upper bound possible (56, based on * the current definition of MODULE_NAME_LEN) to prevent overflows. */ -BUILD_BUG_ON (MODULE_NAME_LEN <56 ||KSYM_NAME_LEN !=128 ); +BUILD_BUG_ON (MODULE_NAME_LEN <56 ||KSYM_NAME_LEN !=512 ); relas = (Elf_Rela *) relasec->sh_addr;/* For each rela in this klp relocation section */
@@ -227,7 +227,7 @@ static int klp_resolve_symbols(Elf64_Shdr *sechdrs, const char *strtab,/* Format: .klp.sym.sym_objname.sym_name,sympos */ cnt =sscanf (strtab + sym->st_name, -".klp.sym.%55[^.].%127[^,],%lu" , +".klp.sym.%55[^.].%511[^,],%lu" , sym_objname, sym_name, &sympos);if (cnt !=3 ) { pr_err("symbol %s has an incorrectly formatted name\n",
scripts/kallsyms.c +1 -1
@@ -27,7 +27,7 @@#define ARRAY_SIZE (arr) (sizeof(arr) / sizeof(arr[0])) -#define KSYM_NAME_LEN 128 +#define KSYM_NAME_LEN 512struct sym_entry {unsigned long long addr;
tools/include/linux/kallsyms.h +1 -1
@@ -6,7 +6,7 @@#include <stdio.h> #include <unistd.h> -#define KSYM_NAME_LEN 128 +#define KSYM_NAME_LEN 512struct module ;
tools/lib/perf/include/perf/event.h +1 -1
@@ -95,7 +95,7 @@ struct perf_record_throttle { };#ifndef KSYM_NAME_LEN -#define KSYM_NAME_LEN 256 +#define KSYM_NAME_LEN 512#endif struct perf_record_ksymbol {
tools/lib/symbol/kallsyms.h +1 -1
@@ -7,7 +7,7 @@#include <linux/types.h> #ifndef KSYM_NAME_LEN -#define KSYM_NAME_LEN 256 +#define KSYM_NAME_LEN 512#endif static inline u8 kallsyms2elf_binding (char type)
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 3/20 kallsyms: use the correct buffer size for symbols
In reply to Miguel OjedaFrom: Boqun Feng <[email protected]>
The buffered name size should be larger than KSYM_NAME_LEN, otherwise we cannot tell whether the size of a symbol name is too long.
--- scripts/kallsyms.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
scripts/kallsyms.c +6 -3
@@ -27,6 +27,9 @@#define ARRAY_SIZE (arr) (sizeof(arr) / sizeof(arr[0])) +#define _stringify_1 (x) #x +#define _stringify (x) _stringify_1(x) +#define KSYM_NAME_LEN 512struct sym_entry {
@@ -197,15 +200,15 @@ static void check_symbol_range(const char *sym, unsigned long long addr,static struct sym_entry *read_symbol (FILE *in) { -char name[500 ], type; +char name[KSYM_NAME_LEN +1 ], type;unsigned long long addr;unsigned int len;struct sym_entry *sym;int rc; - rc =fscanf (in,"%llx %c %499s\n" , &addr, &type, name); + rc = fscanf(in, "%llx %c %" _stringify(KSYM_NAME_LEN) "s\n", &addr, &type, name);if (rc !=3 ) { -if (rc !=EOF &&fgets (name,500 , in) ==NULL ) +if (rc !=EOF &&fgets (name,KSYM_NAME_LEN +1 , in) ==NULL )fprintf (stderr,"Read error or end of file.\n" );return NULL ; }
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 4/20 rust: add C helpers
In reply to Miguel OjedaThis source file contains forwarders to C macros and inlined functions.
--- rust/helpers.c | 531 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 531 insertions(+) create mode 100644 rust/helpers.c
rust/helpers.c new file +531 -0
@@ -0,0 +1,531 @@ +// 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. +*/ + +#include <linux/bug.h> +#include <linux/build_bug.h> +#include <linux/clk.h> +#include <linux/uaccess.h> +#include <linux/sched/signal.h> +#include <linux/gfp.h> +#include <linux/highmem.h> +#include <linux/uio.h> +#include <linux/errname.h> +#include <linux/mutex.h> +#include <linux/platform_device.h> +#include <linux/security.h> +#include <asm/io.h> +#include <linux/irq.h> +#include <linux/irqchip/chained_irq.h> +#include <linux/irqdomain.h> +#include <linux/amba/bus.h> +#include <linux/of_device.h> + +__noreturn void rust_helper_BUG (void ) +{ +BUG (); +} +EXPORT_SYMBOL_GPL (rust_helper_BUG); + +void rust_helper_clk_disable_unprepare (struct clk *clk) +{ +return clk_disable_unprepare (clk); +} +EXPORT_SYMBOL_GPL (rust_helper_clk_disable_unprepare); + +int rust_helper_clk_prepare_enable (struct clk *clk) +{ +return clk_prepare_enable (clk); +} +EXPORT_SYMBOL_GPL (rust_helper_clk_prepare_enable); + +unsigned long rust_helper_copy_from_user (void *to,const void __user *from,unsigned long n) +{ +return copy_from_user (to, from, n); +} +EXPORT_SYMBOL_GPL (rust_helper_copy_from_user); + +unsigned long rust_helper_copy_to_user (void __user *to,const void *from,unsigned long n) +{ +return copy_to_user (to, from, n); +} +EXPORT_SYMBOL_GPL (rust_helper_copy_to_user); + +unsigned long rust_helper_clear_user (void __user *to,unsigned long n) +{ +return clear_user (to, n); +} +EXPORT_SYMBOL_GPL (rust_helper_clear_user); + +void __iomem *rust_helper_ioremap (resource_size_t offset,unsigned long size) +{ +return ioremap (offset, size); +} +EXPORT_SYMBOL_GPL (rust_helper_ioremap); + +u8 rust_helper_readb (const volatile void __iomem *addr) +{ +return readb (addr); +} +EXPORT_SYMBOL_GPL (rust_helper_readb); + +u16 rust_helper_readw (const volatile void __iomem *addr) +{ +return readw (addr); +} +EXPORT_SYMBOL_GPL (rust_helper_readw); + +u32 rust_helper_readl (const volatile void __iomem *addr) +{ +return readl (addr); +} +EXPORT_SYMBOL_GPL (rust_helper_readl); + +#ifdef CONFIG_64BIT +u64 rust_helper_readq (const volatile void __iomem *addr) +{ +return readq (addr); +} +EXPORT_SYMBOL_GPL (rust_helper_readq); +#endif + +void rust_helper_writeb (u8 value,volatile void __iomem *addr) +{ +writeb (value, addr); +} +EXPORT_SYMBOL_GPL (rust_helper_writeb); + +void rust_helper_writew (u16 value,volatile void __iomem *addr) +{ +writew (value, addr); +} +EXPORT_SYMBOL_GPL (rust_helper_writew); + +void rust_helper_writel (u32 value,volatile void __iomem *addr) +{ +writel (value, addr); +} +EXPORT_SYMBOL_GPL (rust_helper_writel); + +#ifdef CONFIG_64BIT +void rust_helper_writeq (u64 value,volatile void __iomem *addr) +{ +writeq (value, addr); +} +EXPORT_SYMBOL_GPL (rust_helper_writeq); +#endif + +u8 rust_helper_readb_relaxed (const volatile void __iomem *addr) +{ +return readb_relaxed (addr); +} +EXPORT_SYMBOL_GPL (rust_helper_readb_relaxed); + +u16 rust_helper_readw_relaxed (const volatile void __iomem *addr) +{ +return readw_relaxed (addr); +} +EXPORT_SYMBOL_GPL (rust_helper_readw_relaxed); + +u32 rust_helper_readl_relaxed (const volatile void __iomem *addr) +{ +return readl_relaxed (addr); +} +EXPORT_SYMBOL_GPL (rust_helper_readl_relaxed); + +#ifdef CONFIG_64BIT +u64 rust_helper_readq_relaxed (const volatile void __iomem *addr) +{ +return readq_relaxed (addr); +} +EXPORT_SYMBOL_GPL (rust_helper_readq_relaxed); +#endif + +void rust_helper_writeb_relaxed (u8 value,volatile void __iomem *addr) +{ +writeb_relaxed (value, addr); +} +EXPORT_SYMBOL_GPL (rust_helper_writeb_relaxed); + +void rust_helper_writew_relaxed (u16 value,volatile void __iomem *addr) +{ +writew_relaxed (value, addr); +} +EXPORT_SYMBOL_GPL (rust_helper_writew_relaxed); + +void rust_helper_writel_relaxed (u32 value,volatile void __iomem *addr) +{ +writel_relaxed (value, addr); +} +EXPORT_SYMBOL_GPL (rust_helper_writel_relaxed); + +#ifdef CONFIG_64BIT +void rust_helper_writeq_relaxed (u64 value,volatile void __iomem *addr) +{ +writeq_relaxed (value, addr); +} +EXPORT_SYMBOL_GPL (rust_helper_writeq_relaxed); +#endif +void rust_helper___spin_lock_init (spinlock_t *lock,const char *name, +struct lock_class_key *key) +{ +#ifdef CONFIG_DEBUG_SPINLOCK +__spin_lock_init (lock, name, key); +#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); + +unsigned long rust_helper_spin_lock_irqsave (spinlock_t *lock) +{ +unsigned long flags; +spin_lock_irqsave (lock, flags); +return flags; +} +EXPORT_SYMBOL_GPL (rust_helper_spin_lock_irqsave); + +void rust_helper_spin_unlock_irqrestore (spinlock_t *lock,unsigned long flags) +{ +spin_unlock_irqrestore (lock, flags); +} +EXPORT_SYMBOL_GPL (rust_helper_spin_unlock_irqrestore); + +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); + +struct page *rust_helper_alloc_pages (gfp_t gfp_mask,unsigned int order) +{ +return alloc_pages (gfp_mask, order); +} +EXPORT_SYMBOL_GPL (rust_helper_alloc_pages); + +void *rust_helper_kmap (struct page *page) +{ +return kmap (page); +} +EXPORT_SYMBOL_GPL (rust_helper_kmap); + +void rust_helper_kunmap (struct page *page) +{ +return kunmap (page); +} +EXPORT_SYMBOL_GPL (rust_helper_kunmap); + +int rust_helper_cond_resched (void ) +{ +return cond_resched (); +} +EXPORT_SYMBOL_GPL (rust_helper_cond_resched); + +size_t rust_helper_copy_from_iter (void *addr,size_t bytes,struct iov_iter *i) +{ +return copy_from_iter (addr, bytes, i); +} +EXPORT_SYMBOL_GPL (rust_helper_copy_from_iter); + +size_t rust_helper_copy_to_iter (const void *addr,size_t bytes,struct iov_iter *i) +{ +return copy_to_iter (addr, bytes, i); +} +EXPORT_SYMBOL_GPL (rust_helper_copy_to_iter); + +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); + +void rust_helper_mutex_lock (struct mutex *lock) +{ +mutex_lock (lock); +} +EXPORT_SYMBOL_GPL (rust_helper_mutex_lock); + +void rust_helper_amba_set_drvdata (struct amba_device *dev,void *data) +{ +amba_set_drvdata (dev, data); +} +EXPORT_SYMBOL_GPL (rust_helper_amba_set_drvdata); + +void *rust_helper_amba_get_drvdata (struct amba_device *dev) +{ +return amba_get_drvdata (dev); +} +EXPORT_SYMBOL_GPL (rust_helper_amba_get_drvdata); + +void * +rust_helper_platform_get_drvdata (const struct platform_device *pdev) +{ +return platform_get_drvdata (pdev); +} +EXPORT_SYMBOL_GPL (rust_helper_platform_get_drvdata); + +void +rust_helper_platform_set_drvdata (struct platform_device *pdev, +void *data) +{ +return platform_set_drvdata (pdev, data); +} +EXPORT_SYMBOL_GPL (rust_helper_platform_set_drvdata); + +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); + +void rust_helper_rb_link_node (struct rb_node *node,struct rb_node *parent, +struct rb_node **rb_link) +{ +rb_link_node (node, parent, rb_link); +} +EXPORT_SYMBOL_GPL (rust_helper_rb_link_node); + +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); + +int rust_helper_security_binder_set_context_mgr (const struct cred *mgr) +{ +return security_binder_set_context_mgr (mgr); +} +EXPORT_SYMBOL_GPL (rust_helper_security_binder_set_context_mgr); + +int rust_helper_security_binder_transaction (const struct cred *from, +const struct cred *to) +{ +return security_binder_transaction (from, to); +} +EXPORT_SYMBOL_GPL (rust_helper_security_binder_transaction); + +int rust_helper_security_binder_transfer_binder (const struct cred *from, +const struct cred *to) +{ +return security_binder_transfer_binder (from, to); +} +EXPORT_SYMBOL_GPL (rust_helper_security_binder_transfer_binder); + +int rust_helper_security_binder_transfer_file (const struct cred *from, +const struct cred *to, +struct file *file) +{ +return security_binder_transfer_file (from, to, file); +} +EXPORT_SYMBOL_GPL (rust_helper_security_binder_transfer_file); + +void rust_helper_rcu_read_lock (void ) +{ +rcu_read_lock (); +} +EXPORT_SYMBOL_GPL (rust_helper_rcu_read_lock); + +void rust_helper_rcu_read_unlock (void ) +{ +rcu_read_unlock (); +} +EXPORT_SYMBOL_GPL (rust_helper_rcu_read_unlock); + +void rust_helper_synchronize_rcu (void ) +{ +synchronize_rcu (); +} +EXPORT_SYMBOL_GPL (rust_helper_synchronize_rcu); + +void *rust_helper_dev_get_drvdata (struct device *dev) +{ +return dev_get_drvdata (dev); +} +EXPORT_SYMBOL_GPL (rust_helper_dev_get_drvdata); + +const char *rust_helper_dev_name (const struct device *dev) +{ +return dev_name (dev); +} +EXPORT_SYMBOL_GPL (rust_helper_dev_name); + +void rust_helper___seqcount_init (seqcount_t *s,const char *name, +struct lock_class_key *key) +{ +__seqcount_init (s, name, key); +} +EXPORT_SYMBOL_GPL (rust_helper___seqcount_init); + +unsigned rust_helper_read_seqcount_begin (seqcount_t *s) +{ +return read_seqcount_begin (s); +} +EXPORT_SYMBOL_GPL (rust_helper_read_seqcount_begin); + +int rust_helper_read_seqcount_retry (seqcount_t *s,unsigned start) +{ +return read_seqcount_retry (s, start); +} +EXPORT_SYMBOL_GPL (rust_helper_read_seqcount_retry); + +void rust_helper_write_seqcount_begin (seqcount_t *s) +{ +do_write_seqcount_begin (s); +} +EXPORT_SYMBOL_GPL (rust_helper_write_seqcount_begin); + +void rust_helper_write_seqcount_end (seqcount_t *s) +{ +do_write_seqcount_end (s); +} +EXPORT_SYMBOL_GPL (rust_helper_write_seqcount_end); + +void rust_helper_irq_set_handler_locked (struct irq_data *data, +irq_flow_handler_t handler) +{ +irq_set_handler_locked (data, handler); +} +EXPORT_SYMBOL_GPL (rust_helper_irq_set_handler_locked); + +void *rust_helper_irq_data_get_irq_chip_data (struct irq_data *d) +{ +return irq_data_get_irq_chip_data (d); +} +EXPORT_SYMBOL_GPL (rust_helper_irq_data_get_irq_chip_data); + +struct irq_chip *rust_helper_irq_desc_get_chip (struct irq_desc *desc) +{ +return irq_desc_get_chip (desc); +} +EXPORT_SYMBOL_GPL (rust_helper_irq_desc_get_chip); + +void *rust_helper_irq_desc_get_handler_data (struct irq_desc *desc) +{ +return irq_desc_get_handler_data (desc); +} +EXPORT_SYMBOL_GPL (rust_helper_irq_desc_get_handler_data); + +void rust_helper_chained_irq_enter (struct irq_chip *chip, +struct irq_desc *desc) +{ +chained_irq_enter (chip, desc); +} +EXPORT_SYMBOL_GPL (rust_helper_chained_irq_enter); + +void rust_helper_chained_irq_exit (struct irq_chip *chip, +struct irq_desc *desc) +{ +chained_irq_exit (chip, desc); +} +EXPORT_SYMBOL_GPL (rust_helper_chained_irq_exit); + +const struct cred *rust_helper_get_cred (const struct cred *cred) +{ +return get_cred (cred); +} +EXPORT_SYMBOL_GPL (rust_helper_get_cred); + +void rust_helper_put_cred (const struct cred *cred) { +put_cred (cred); +} +EXPORT_SYMBOL_GPL (rust_helper_put_cred); + +const struct of_device_id *rust_helper_of_match_device ( +const struct of_device_id *matches,const struct device *dev) +{ +return of_match_device (matches, dev); +} +EXPORT_SYMBOL_GPL (rust_helper_of_match_device); + +/* +* We use `bindgen`'s `--size_t-is-usize` option to bind 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 remove +* `--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`" +);
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 5/20 rust: add `compiler_builtins` crate
In reply to Miguel OjedaRust provides compiler_builtins as a port of LLVM's compiler-rt. Since we do not need the vast majority of them, we avoid the dependency by providing our own crate.
--- rust/compiler_builtins.rs | 57 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 rust/compiler_builtins.rs
rust/compiler_builtins.rs new file +57 -0
@@ -0,0 +1,57 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Our own `compiler_builtins`. +//! +//! Rust provides [`compiler_builtins`] as a port of LLVM's [`compiler-rt`]. +//! Since we do not need the vast majority of them, we avoid the dependency +//! by providing this file. +//! +//! At the moment, some builtins are required that should not be. For instance, +//! [`core`] has 128-bit integers functionality which we should not be compiling +//! in. We will work with upstream [`core`] to provide feature flags to disable +//! the parts we do not need. For the moment, we define them to [`panic!`] at +//! runtime for simplicity to catch mistakes, instead of performing surgery +//! on `core.o`. +//! +//! In any case, all these symbols are weakened to ensure we do not override +//! those that may be provided by the rest of the kernel. +//! +//! [`compiler_builtins`]: https://github.com/rust-lang/compiler-builtins +//! [`compiler-rt`]: https://compiler-rt.llvm.org/ + +#![feature(compiler_builtins)] +#![compiler_builtins] +#![no_builtins] +#![no_std] + +macro_rules! define_panicking_intrinsics( + ($reason: tt, { $($ident: ident, )* }) => { + $( +#[doc(hidden)] +#[no_mangle] +pub extern"C" fn $ident() { +panic! ($reason); + } + )* + } +); + +define_panicking_intrinsics! ("`i128` should not be used" , { + __ashrti3, + __muloti4, + __multi3, +}); + +define_panicking_intrinsics! ("`u128` should not be used" , { + __ashlti3, + __lshrti3, + __udivmodti4, + __udivti3, + __umodti3, +}); + +#[cfg(target_arch = "arm" )] +define_panicking_intrinsics! ("`u64` division/modulo should not be used" , { + __aeabi_uldivmod, + __mulodi4, +});
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 6/20 rust: add `alloc` crate
In reply to Miguel OjedaThis crate is a subset of the Rust standard library alloc, with some additions on top.
This is needed because upstream support for fallible allocations is a work in progress (i.e. the try_* versions of methods which return a Result instead of panicking).
Having the library in-tree also gives us a bit more freedom to experiment with new interfaces and allows us to iterate quickly.
Eventually, the goal is to have everything the kernel needs in upstream alloc and drop it from the kernel tree.
--- rust/alloc/README.md | 32 + rust/alloc/alloc.rs | 440 ++++ rust/alloc/borrow.rs | 498 +++++ rust/alloc/boxed.rs | 2008 +++++++++++++++++ rust/alloc/collections/mod.rs | 156 ++ rust/alloc/fmt.rs | 601 ++++++ rust/alloc/lib.rs | 231 ++ rust/alloc/macros.rs | 126 ++ rust/alloc/raw_vec.rs | 561 +++++ rust/alloc/slice.rs | 1279 +++++++++++ rust/alloc/str.rs | 632 ++++++ rust/alloc/string.rs | 2862 ++++++++++++++++++++++++ rust/alloc/vec/drain.rs | 186 ++ rust/alloc/vec/drain_filter.rs | 145 ++ rust/alloc/vec/into_iter.rs | 356 +++ rust/alloc/vec/is_zero.rs | 106 + rust/alloc/vec/mod.rs | 3353 +++++++++++++++++++++++++++++ rust/alloc/vec/partial_eq.rs | 49 + rust/alloc/vec/set_len_on_drop.rs | 30 + rust/alloc/vec/spec_extend.rs | 174 ++ 20 files changed, 13825 insertions(+) create mode 100644 rust/alloc/README.md create mode 100644 rust/alloc/alloc.rs create mode 100644 rust/alloc/borrow.rs create mode 100644 rust/alloc/boxed.rs create mode 100644 rust/alloc/collections/mod.rs create mode 100644 rust/alloc/fmt.rs create mode 100644 rust/alloc/lib.rs create mode 100644 rust/alloc/macros.rs create mode 100644 rust/alloc/raw_vec.rs create mode 100644 rust/alloc/slice.rs create mode 100644 rust/alloc/str.rs create mode 100644 rust/alloc/string.rs create mode 100644 rust/alloc/vec/drain.rs create mode 100644 rust/alloc/vec/drain_filter.rs create mode 100644 rust/alloc/vec/into_iter.rs create mode 100644 rust/alloc/vec/is_zero.rs create mode 100644 rust/alloc/vec/mod.rs create mode 100644 rust/alloc/vec/partial_eq.rs create mode 100644 rust/alloc/vec/set_len_on_drop.rs create mode 100644 rust/alloc/vec/spec_extend.rs
rust/alloc/README.md new file +32 -0
@@ -0,0 +1,32 @@ +# `alloc` + +These source files come from the Rust standard library, hosted in +the https://github.com/rust-lang/rust repository. For copyright +details, see https://github.com/rust-lang/rust/blob/master/COPYRIGHT. + +Please note that these files should be kept as close as possible to +upstream. In general, only additions should be performed (e.g. new +methods). Eventually, changes should make it into upstream so that, +at some point, this fork can be dropped from the kernel tree. + + +## Rationale + +On one hand, kernel folks wanted to keep `alloc` in-tree to have more +freedom in both workflow and actual features if actually needed +(e.g. receiver types if we ended up using them), which is reasonable. + +On the other hand, Rust folks wanted to keep `alloc` as close as +upstream as possible and avoid as much divergence as possible, which +is also reasonable. + +We agreed on a middle-ground: we would keep a subset of `alloc` +in-tree that would be as small and as close as possible to upstream. +Then, upstream can start adding the functions that we add to `alloc` +etc., until we reach a point where the kernel already knows exactly +what it needs in `alloc` and all the new methods are merged into +upstream, so that we can drop `alloc` from the kernel tree and go back +to using the upstream one. + +By doing this, the kernel can go a bit faster now, and Rust can +slowly incorporate and discuss the changes as needed.
rust/alloc/alloc.rs new file +440 -0
440 lines not on this page · raw message
rust/alloc/borrow.rs new file +498 -0
498 lines not on this page · raw message
rust/alloc/boxed.rs new file +2008 -0
2,008 lines not on this page · raw message
rust/alloc/collections/mod.rs new file +156 -0
22 lines not on this page · raw message
rust/alloc/fmt.rs new file +601 -0
601 lines not on this page · raw message
rust/alloc/lib.rs new file +231 -0
231 lines not on this page · raw message
rust/alloc/macros.rs new file +126 -0
126 lines not on this page · raw message
rust/alloc/raw_vec.rs new file +561 -0
561 lines not on this page · raw message
rust/alloc/slice.rs new file +1279 -0
1,279 lines not on this page · raw message
rust/alloc/str.rs new file +632 -0
632 lines not on this page · raw message
rust/alloc/string.rs new file +2862 -0
2,862 lines not on this page · raw message
rust/alloc/vec/drain.rs new file +186 -0
186 lines not on this page · raw message
rust/alloc/vec/drain_filter.rs new file +145 -0
145 lines not on this page · raw message
rust/alloc/vec/into_iter.rs new file +356 -0
356 lines not on this page · raw message
rust/alloc/vec/is_zero.rs new file +106 -0
106 lines not on this page · raw message
rust/alloc/vec/mod.rs new file +3353 -0
3,353 lines not on this page · raw message
rust/alloc/vec/partial_eq.rs new file +49 -0
49 lines not on this page · raw message
rust/alloc/vec/set_len_on_drop.rs new file +30 -0
Lines of this file are not shown. View the raw message.
rust/alloc/vec/spec_extend.rs new file +174 -0
174 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.35.1
Part of the diff is not shown here. View the raw message.
Greg Kroah-Hartman
maintainerRe: [PATCH v5 06/20] rust: add `alloc` crate
Quoted 36 lines · Miguel Ojeda
This crate is a subset of the Rust standard library
alloc, with some additions on top.This is needed because upstream support for fallible allocations is a work in progress (i.e. the
try_*versions of methods which return aResultinstead of panicking).Having the library in-tree also gives us a bit more freedom to experiment with new interfaces and allows us to iterate quickly.
Eventually, the goal is to have everything the kernel needs in upstream
allocand drop it from the kernel tree.Co-developed-by Alex Gaynor <[email protected]>Signed-off-by Alex Gaynor <[email protected]>Co-developed-by Wedson Almeida Filho <[email protected]>Signed-off-by Wedson Almeida Filho <[email protected]>Co-developed-by Gary Guo <[email protected]>Signed-off-by Gary Guo <[email protected]>Co-developed-by Matthew Bakhtiari <[email protected]>Signed-off-by Matthew Bakhtiari <[email protected]>Signed-off-by Miguel Ojeda <[email protected]>--- rust/alloc/README.md | 32 + rust/alloc/alloc.rs | 440 ++++ rust/alloc/borrow.rs | 498 +++++ rust/alloc/boxed.rs | 2008 +++++++++++++++++ rust/alloc/collections/mod.rs | 156 ++ rust/alloc/fmt.rs | 601 ++++++ rust/alloc/lib.rs | 231 ++ rust/alloc/macros.rs | 126 ++ rust/alloc/raw_vec.rs | 561 +++++ rust/alloc/slice.rs | 1279 +++++++++++ rust/alloc/str.rs | 632 ++++++ rust/alloc/string.rs | 2862 ++++++++++++++++++++++++ rust/alloc/vec/drain.rs | 186 ++
Quoted 8 lines
rust/alloc/vec/drain_filter.rs | 145 ++ rust/alloc/vec/into_iter.rs | 356 +++ rust/alloc/vec/is_zero.rs | 106 + rust/alloc/vec/mod.rs | 3353 +++++++++++++++++++++++++++++ rust/alloc/vec/partial_eq.rs | 49 + rust/alloc/vec/set_len_on_drop.rs | 30 + rust/alloc/vec/spec_extend.rs | 174 ++ 20 files changed, 13825 insertions(+)
This is a huge patch. Why not break it into 2, one that adds what is upstream, and then the second adds the "stuff on top" that you need for the kernel. Otherwise it's hard to know what is, and is not, upstream for us to be able to review from a kernel point of view.
I think you are trying to do this with the "kernel" keyword, but if so, why are you picking a "since" of 1.0? None of that is described in the changelog :(
thanks,
greg k-h
Re: [PATCH v5 06/20] rust: add `alloc` crate
Hi Greg,
Quoted 5 lines · Greg Kroah-Hartman
This is a huge patch. Why not break it into 2, one that adds what is upstream, and then the second adds the "stuff on top" that you need for the kernel. Otherwise it's hard to know what is, and is not, upstream for us to be able to review from a kernel point of view.
That is a good idea, will do.
There are some files from upstream that we do not need, so they are already deleted here (e.g. collections), thus what I will do is send the first patch without those already and then another patch with the modifications/additions we did. If you prefer to see the deleted files in an intermediate step, I can also do that.
Quoted 3 lines
I think you are trying to do this with the "kernel" keyword, but if so, why are you picking a "since" of 1.0? None of that is described in the changelog :(
Exactly, I used the "kernel" string to have the additions clearly marked. The stable/unstable attributes are required in the standard library -- here the "1.0" is just a placeholder.
I will expand a bit on this in the split patches approach that you suggest above.
Thanks for taking a look!
Cheers,
Miguel
Greg Kroah-Hartman
maintainerRe: [PATCH v5 06/20] rust: add `alloc` crate
Quoted 10 lines · Miguel Ojeda
Hi Greg,
Quoted 5 lines · Greg Kroah-Hartman
This is a huge patch. Why not break it into 2, one that adds what is upstream, and then the second adds the "stuff on top" that you need for the kernel. Otherwise it's hard to know what is, and is not, upstream for us to be able to review from a kernel point of view.
Quoted 7 lines
That is a good idea, will do.
There are some files from upstream that we do not need, so they are already deleted here (e.g. collections), thus what I will do is send the first patch without those already and then another patch with the modifications/additions we did. If you prefer to see the deleted files in an intermediate step, I can also do that.
Nah, I don't care about deleted files :)
thanks,
greg k-h
Miguel Ojeda
maintainerPATCH v5 7/20 rust: add `build_error` crate
In reply to Miguel OjedaFrom: Gary Guo <[email protected]>
The build_error crate provides the build_error function which is then used to provide the build_error! and the build_assert! macros.
build_assert! is intended to be used when static_assert! cannot be used, e.g. when the condition refers to generic parameters or parameters of an inline function.
--- rust/build_error.rs | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 rust/build_error.rs
rust/build_error.rs new file +29 -0
@@ -0,0 +1,29 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Build-time error. +//! +//! This crate provides a function `build_error`, which will panic in +//! compile-time if executed in const context, and will cause a build error +//! if not executed at compile time and the optimizer does not optimise away the +//! call. +//! +//! It is used by `build_assert!` in the kernel crate, allowing checking of +//! conditions that could be checked statically, but could not be enforced in +//! Rust yet (e.g. perform some checks in const functions, but those +//! functions could still be called in the runtime). + +#![no_std] + +/// Panics if executed in const context, or triggers a build error if not. +#[inline(never)] +#[cold] +#[no_mangle] +#[track_caller] +pub const fn build_error (msg: &'staticstr ) -> ! { +panic! ("{}" , msg); +} + +#[cfg( CONFIG_RUST_BUILD_ASSERT_WARN )] +#[link_section = ".gnu.warning.build_error" ] +#[used] +static BUILD_ERROR_WARNING : [u8 ;45 ] = *b"call to build_error present after compilation" ;
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 8/20 rust: add `macros` crate
In reply to Miguel OjedaThis crate contains all the procedural macros ("proc macros") shared by all the kernel.
Procedural macros allow to create syntax extensions. They run at compile-time and can consume as well as produce Rust syntax.
For instance, the module! macro that is used by Rust modules is implemented here. It allows to easily declare the equivalent information to the MODULE_* macros in C modules, e.g.:
module! {
type: RustMinimal,
name: b"rust_minimal",
author: b"Rust for Linux Contributors",
description: b"Rust minimal sample",
license: b"GPL v2",
}--- rust/macros/helpers.rs | 79 ++++++ rust/macros/lib.rs | 94 ++++++ rust/macros/module.rs | 631 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 804 insertions(+) create mode 100644 rust/macros/helpers.rs create mode 100644 rust/macros/lib.rs create mode 100644 rust/macros/module.rs
rust/macros/helpers.rs new file +79 -0
@@ -0,0 +1,79 @@ +// SPDX-License-Identifier: GPL-2.0 + +use proc_macro::{token_stream,Group ,TokenTree }; + +pub (crate )fn try_ident (it: &mut token_stream::IntoIter ) ->Option <String > { +if let Some (TokenTree ::Ident (ident)) = it.next () { +Some (ident.to_string ()) + }else { +None + } +} + +pub (crate )fn try_literal (it: &mut token_stream::IntoIter ) ->Option <String > { +if let Some (TokenTree ::Literal (literal)) = it.next () { +Some (literal.to_string ()) + }else { +None + } +} + +pub (crate )fn try_byte_string (it: &mut token_stream::IntoIter ) ->Option <String > { +try_literal (it).and_then (|byte_string| { +if byte_string.starts_with ("b\"" ) && byte_string.ends_with ('\"' ) { +Some (byte_string[2 ..byte_string.len () -1 ].to_string ()) + }else { +None + } + }) +} + +pub (crate )fn expect_ident (it: &mut token_stream::IntoIter ) ->String { +try_ident (it).expect ("Expected Ident" ) +} + +pub (crate )fn expect_punct (it: &mut token_stream::IntoIter ) ->char { +if let TokenTree ::Punct (punct) = it.next ().expect ("Reached end of token stream for Punct" ) { + punct.as_char () + }else { +panic! ("Expected Punct" ); + } +} + +pub (crate )fn expect_literal (it: &mut token_stream::IntoIter ) ->String { +try_literal (it).expect ("Expected Literal" ) +} + +pub (crate )fn expect_group (it: &mut token_stream::IntoIter ) ->Group { +if let TokenTree ::Group (group) = it.next ().expect ("Reached end of token stream for Group" ) { + group + }else { +panic! ("Expected Group" ); + } +} + +pub (crate )fn expect_byte_string (it: &mut token_stream::IntoIter ) ->String { +try_byte_string (it).expect ("Expected byte string" ) +} + +pub (crate )fn expect_end (it: &mut token_stream::IntoIter ) { +if it.next ().is_some () { +panic! ("Expected end" ); + } +} + +pub (crate )fn get_literal (it: &mut token_stream::IntoIter , expected_name: &str ) ->String { +assert_eq! (expect_ident (it), expected_name); +assert_eq! (expect_punct (it),':' ); +let literal =expect_literal (it); +assert_eq! (expect_punct (it),',' ); + literal +} + +pub (crate )fn get_byte_string (it: &mut token_stream::IntoIter , expected_name: &str ) ->String { +assert_eq! (expect_ident (it), expected_name); +assert_eq! (expect_punct (it),':' ); +let byte_string =expect_byte_string (it); +assert_eq! (expect_punct (it),',' ); + byte_string +}
rust/macros/lib.rs new file +94 -0
94 lines not on this page · raw message
rust/macros/module.rs new file +631 -0
631 lines not on this page · raw message
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 9/20 rust: add `kernel` crate's `sync` module
In reply to Miguel OjedaFrom: Wedson Almeida Filho <[email protected]>
This module contains the kernel APIs related to synchronisation that have been ported or wrapped for usage by Rust code in the kernel and is shared by all of them.
--- include/linux/spinlock.h | 17 +- rust/kernel/sync/arc.rs | 500 ++++++++++++++++++++++++++++ rust/kernel/sync/condvar.rs | 138 ++++++++ rust/kernel/sync/guard.rs | 166 +++++++++ rust/kernel/sync/locked_by.rs | 112 +++++++ rust/kernel/sync/mod.rs | 157 +++++++++ rust/kernel/sync/mutex.rs | 114 +++++++ rust/kernel/sync/revocable_mutex.rs | 184 ++++++++++ rust/kernel/sync/rwsem.rs | 149 +++++++++ rust/kernel/sync/seqlock.rs | 202 +++++++++++ rust/kernel/sync/spinlock.rs | 192 +++++++++++ 11 files changed, 1925 insertions(+), 6 deletions(-) create mode 100644 rust/kernel/sync/arc.rs create mode 100644 rust/kernel/sync/condvar.rs create mode 100644 rust/kernel/sync/guard.rs create mode 100644 rust/kernel/sync/locked_by.rs create mode 100644 rust/kernel/sync/mod.rs create mode 100644 rust/kernel/sync/mutex.rs create mode 100644 rust/kernel/sync/revocable_mutex.rs create mode 100644 rust/kernel/sync/rwsem.rs create mode 100644 rust/kernel/sync/seqlock.rs create mode 100644 rust/kernel/sync/spinlock.rs
include/linux/spinlock.h +11 -6
@@ -326,12 +326,17 @@ static __always_inline raw_spinlock_t *spinlock_check(spinlock_t *lock)#ifdef CONFIG_DEBUG_SPINLOCK -# define spin_lock_init (lock) \ -do { \ - static struct lock_class_key __key; \ - \ - __raw_spin_lock_init(spinlock_check(lock), \ - #lock, &__key, LD_WAIT_CONFIG); \ +static inline void __spin_lock_init (spinlock_t *lock,const char *name, +struct lock_class_key *key) +{ +__raw_spin_lock_init (spinlock_check (lock), name, key,LD_WAIT_CONFIG ); +} + +# define spin_lock_init (lock) \ +do { \ + static struct lock_class_key __key; \ + \ + __spin_lock_init(lock, #lock, &__key); \ } while (0)#else
rust/kernel/sync/arc.rs new file +500 -0
500 lines not on this page · raw message
rust/kernel/sync/condvar.rs new file +138 -0
138 lines not on this page · raw message
rust/kernel/sync/guard.rs new file +166 -0
166 lines not on this page · raw message
rust/kernel/sync/locked_by.rs new file +112 -0
112 lines not on this page · raw message
rust/kernel/sync/mod.rs new file +157 -0
157 lines not on this page · raw message
rust/kernel/sync/mutex.rs new file +114 -0
114 lines not on this page · raw message
rust/kernel/sync/revocable_mutex.rs new file +184 -0
184 lines not on this page · raw message
rust/kernel/sync/rwsem.rs new file +149 -0
149 lines not on this page · raw message
rust/kernel/sync/seqlock.rs new file +202 -0
202 lines not on this page · raw message
rust/kernel/sync/spinlock.rs new file +192 -0
192 lines not on this page · raw message
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 10/20 rust: add `kernel` crate
In reply to Miguel OjedaFrom: Wedson Almeida Filho <[email protected]>
The kernel crate currently includes all the abstractions that wrap kernel features written in C.
These abstractions call the C side of the kernel via the generated bindings with the bindgen tool. Modules developed in Rust should never call the bindings themselves.
In the future, as the abstractions grow in number, we may need to split this crate into several, possibly following a similar subdivision in subsystems as the kernel itself and/or moving the code to the actual subsystems.
--- rust/kernel/allocator.rs | 65 +++ rust/kernel/amba.rs | 259 ++++++++++ rust/kernel/bindings.rs | 47 ++ rust/kernel/bindings_helper.h | 37 ++ rust/kernel/build_assert.rs | 80 ++++ rust/kernel/c_types.rs | 119 +++++ rust/kernel/chrdev.rs | 207 ++++++++ rust/kernel/clk.rs | 75 +++ rust/kernel/cred.rs | 73 +++ rust/kernel/device.rs | 554 +++++++++++++++++++++ rust/kernel/driver.rs | 440 +++++++++++++++++ rust/kernel/error.rs | 560 ++++++++++++++++++++++ rust/kernel/file.rs | 873 ++++++++++++++++++++++++++++++++++ rust/kernel/gpio.rs | 478 +++++++++++++++++++ rust/kernel/hwrng.rs | 242 ++++++++++ rust/kernel/io_buffer.rs | 153 ++++++ rust/kernel/io_mem.rs | 237 +++++++++ rust/kernel/iov_iter.rs | 81 ++++ rust/kernel/irq.rs | 409 ++++++++++++++++ rust/kernel/lib.rs | 260 ++++++++++ rust/kernel/linked_list.rs | 247 ++++++++++ rust/kernel/miscdev.rs | 291 ++++++++++++ rust/kernel/mm.rs | 149 ++++++ rust/kernel/module_param.rs | 498 +++++++++++++++++++ rust/kernel/of.rs | 63 +++ rust/kernel/pages.rs | 144 ++++++ rust/kernel/platform.rs | 224 +++++++++ rust/kernel/power.rs | 118 +++++ rust/kernel/prelude.rs | 36 ++ rust/kernel/print.rs | 414 ++++++++++++++++ rust/kernel/random.rs | 50 ++ rust/kernel/raw_list.rs | 361 ++++++++++++++ rust/kernel/rbtree.rs | 562 ++++++++++++++++++++++ rust/kernel/revocable.rs | 163 +++++++ rust/kernel/security.rs | 36 ++ rust/kernel/static_assert.rs | 39 ++ rust/kernel/std_vendor.rs | 150 ++++++ rust/kernel/str.rs | 592 +++++++++++++++++++++++ rust/kernel/sysctl.rs | 199 ++++++++ rust/kernel/task.rs | 182 +++++++ rust/kernel/types.rs | 569 ++++++++++++++++++++++ rust/kernel/user_ptr.rs | 175 +++++++ 42 files changed, 10511 insertions(+) create mode 100644 rust/kernel/allocator.rs create mode 100644 rust/kernel/amba.rs create mode 100644 rust/kernel/bindings.rs create mode 100644 rust/kernel/bindings_helper.h create mode 100644 rust/kernel/build_assert.rs create mode 100644 rust/kernel/c_types.rs create mode 100644 rust/kernel/chrdev.rs create mode 100644 rust/kernel/clk.rs create mode 100644 rust/kernel/cred.rs create mode 100644 rust/kernel/device.rs create mode 100644 rust/kernel/driver.rs create mode 100644 rust/kernel/error.rs create mode 100644 rust/kernel/file.rs create mode 100644 rust/kernel/gpio.rs create mode 100644 rust/kernel/hwrng.rs create mode 100644 rust/kernel/io_buffer.rs create mode 100644 rust/kernel/io_mem.rs create mode 100644 rust/kernel/iov_iter.rs create mode 100644 rust/kernel/irq.rs create mode 100644 rust/kernel/lib.rs create mode 100644 rust/kernel/linked_list.rs create mode 100644 rust/kernel/miscdev.rs create mode 100644 rust/kernel/mm.rs create mode 100644 rust/kernel/module_param.rs create mode 100644 rust/kernel/of.rs create mode 100644 rust/kernel/pages.rs create mode 100644 rust/kernel/platform.rs create mode 100644 rust/kernel/power.rs create mode 100644 rust/kernel/prelude.rs create mode 100644 rust/kernel/print.rs create mode 100644 rust/kernel/random.rs create mode 100644 rust/kernel/raw_list.rs create mode 100644 rust/kernel/rbtree.rs create mode 100644 rust/kernel/revocable.rs create mode 100644 rust/kernel/security.rs create mode 100644 rust/kernel/static_assert.rs create mode 100644 rust/kernel/std_vendor.rs create mode 100644 rust/kernel/str.rs create mode 100644 rust/kernel/sysctl.rs create mode 100644 rust/kernel/task.rs create mode 100644 rust/kernel/types.rs create mode 100644 rust/kernel/user_ptr.rs
rust/kernel/allocator.rs new file +65 -0
@@ -0,0 +1,65 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Allocator support. + +use core::alloc::{GlobalAlloc ,Layout }; +use core::ptr; + +use crate ::bindings; +use crate ::c_types; + +struct KernelAllocator ; + +unsafe impl GlobalAlloc for KernelAllocator { +unsafe fn alloc (&self, layout:Layout ) -> *mut u8 { +// `krealloc()` is used instead of `kmalloc()` because the latter is +// an inline function and cannot be bound to as a result. +unsafe { bindings::krealloc (ptr::null (), layout.size (), bindings::GFP_KERNEL )as *mut u8 } + } + +unsafe fn dealloc (&self, ptr: *mut u8 , _layout:Layout ) { +unsafe { + bindings::kfree (ptras *const c_types::c_void ); + } + } +} + +#[global_allocator] +static ALLOCATOR :KernelAllocator =KernelAllocator ; + +// `rustc` only generates these for some crate types. Even then, we would need +// to extract the object file that has them from the archive. For the moment, +// let's generate them ourselves instead. +// +// Note that `#[no_mangle]` implies exported too, nowadays. +#[no_mangle] +fn __rust_alloc (size:usize , _align:usize ) -> *mut u8 { +unsafe { bindings::krealloc (core::ptr::null (), size, bindings::GFP_KERNEL )as *mut u8 } +} + +#[no_mangle] +fn __rust_dealloc (ptr: *mut u8 , _size:usize , _align:usize ) { +unsafe { bindings::kfree (ptras *const c_types::c_void ) }; +} + +#[no_mangle] +fn __rust_realloc (ptr: *mut u8 , _old_size:usize , _align:usize , new_size:usize ) -> *mut u8 { +unsafe { + bindings::krealloc ( + ptras *const c_types::c_void , + new_size, + bindings::GFP_KERNEL , + )as *mut u8 + } +} + +#[no_mangle] +fn __rust_alloc_zeroed (size:usize , _align:usize ) -> *mut u8 { +unsafe { + bindings::krealloc ( + core::ptr::null (), + size, + bindings::GFP_KERNEL | bindings::__GFP_ZERO, + )as *mut u8 + } +}
rust/kernel/amba.rs new file +259 -0
259 lines not on this page · raw message
rust/kernel/bindings.rs new file +47 -0
47 lines not on this page · raw message
rust/kernel/bindings_helper.h new file +37 -0
@@ -0,0 +1,37 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Header that contains the code (mostly headers) for which Rust bindings +* will be automatically generated by `bindgen`. +* +* Sorted alphabetically. +*/ + +#include <asm/io.h> +#include <linux/amba/bus.h> +#include <linux/cdev.h> +#include <linux/clk.h> +#include <linux/errname.h> +#include <linux/file.h> +#include <linux/fs.h> +#include <linux/gpio/driver.h> +#include <linux/hw_random.h> +#include <linux/interrupt.h> +#include <linux/irqdomain.h> +#include <linux/irq.h> +#include <linux/miscdevice.h> +#include <linux/mm.h> +#include <linux/module.h> +#include <linux/of_platform.h> +#include <linux/platform_device.h> +#include <linux/poll.h> +#include <linux/random.h> +#include <linux/security.h> +#include <linux/slab.h> +#include <linux/sysctl.h> +#include <linux/uaccess.h> +#include <linux/uio.h> +#include <uapi/linux/android/binder.h> + +/* `bindgen` gets confused at certain things. */ +const gfp_t BINDINGS_GFP_KERNEL =GFP_KERNEL ; +const gfp_t BINDINGS___GFP_ZERO = __GFP_ZERO;
rust/kernel/build_assert.rs new file +80 -0
80 lines not on this page · raw message
rust/kernel/c_types.rs new file +119 -0
119 lines not on this page · raw message
rust/kernel/chrdev.rs new file +207 -0
207 lines not on this page · raw message
rust/kernel/clk.rs new file +75 -0
75 lines not on this page · raw message
rust/kernel/cred.rs new file +73 -0
73 lines not on this page · raw message
rust/kernel/device.rs new file +554 -0
554 lines not on this page · raw message
rust/kernel/driver.rs new file +440 -0
440 lines not on this page · raw message
rust/kernel/error.rs new file +560 -0
560 lines not on this page · raw message
rust/kernel/file.rs new file +873 -0
484 lines not on this page · raw message
rust/kernel/gpio.rs new file +478 -0
478 lines not on this page · raw message
rust/kernel/hwrng.rs new file +242 -0
242 lines not on this page · raw message
rust/kernel/io_buffer.rs new file +153 -0
153 lines not on this page · raw message
rust/kernel/io_mem.rs new file +237 -0
237 lines not on this page · raw message
rust/kernel/iov_iter.rs new file +81 -0
81 lines not on this page · raw message
rust/kernel/irq.rs new file +409 -0
409 lines not on this page · raw message
rust/kernel/lib.rs new file +260 -0
260 lines not on this page · raw message
rust/kernel/linked_list.rs new file +247 -0
247 lines not on this page · raw message
rust/kernel/miscdev.rs new file +291 -0
291 lines not on this page · raw message
rust/kernel/mm.rs new file +149 -0
149 lines not on this page · raw message
rust/kernel/module_param.rs new file +498 -0
498 lines not on this page · raw message
rust/kernel/of.rs new file +63 -0
63 lines not on this page · raw message
rust/kernel/pages.rs new file +144 -0
144 lines not on this page · raw message
rust/kernel/platform.rs new file +224 -0
224 lines not on this page · raw message
rust/kernel/power.rs new file +118 -0
118 lines not on this page · raw message
rust/kernel/print.rs new file +414 -0
414 lines not on this page · raw message
rust/kernel/random.rs new file +50 -0
50 lines not on this page · raw message
rust/kernel/raw_list.rs new file +361 -0
361 lines not on this page · raw message
rust/kernel/rbtree.rs new file +562 -0
562 lines not on this page · raw message
rust/kernel/revocable.rs new file +163 -0
163 lines not on this page · raw message
rust/kernel/std_vendor.rs new file +150 -0
150 lines not on this page · raw message
rust/kernel/str.rs new file +592 -0
592 lines not on this page · raw message
rust/kernel/sysctl.rs new file +199 -0
199 lines not on this page · raw message
rust/kernel/task.rs new file +182 -0
182 lines not on this page · raw message
rust/kernel/types.rs new file +569 -0
569 lines not on this page · raw message
rust/kernel/user_ptr.rs new file +175 -0
175 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.35.1
Part of the diff is not shown here. View the raw message.
Miguel Ojeda
maintainerPATCH v5 11/20 rust: export generated symbols
In reply to Miguel OjedaAll symbols are reexported reusing the EXPORT_SYMBOL_GPL macro from C. The lists of symbols are generated on the fly.
There are three main sets of symbols to distinguish:
- The ones from the core and alloc crates (from the Rust standard library). The code is licensed as Apache/MIT.
- The ones from our abstractions in the kernel crate.
- The helpers (already exported since they are not generated).
We export everything as GPL. This ensures we do not mistakenly expose GPL kernel symbols/features as non-GPL, even indirectly.
--- rust/exports.c | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 rust/exports.c
rust/exports.c new file +20 -0
@@ -0,0 +1,20 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* A hack to export Rust symbols for loadable modules without having to redo +* the entire `include/linux/export.h` logic in Rust. +* +* This requires the Rust's new/future `v0` mangling scheme because the default +* one ("legacy") uses invalid characters for C identifiers (thus we cannot use +* the `EXPORT_SYMBOL_*` macros). +* +* All symbols are exported as GPL-only to guarantee no GPL-only feature is +* accidentally exposed. +*/ + +#include <linux/module.h> + +#define EXPORT_SYMBOL_RUST_GPL (sym) extern int sym; EXPORT_SYMBOL_GPL(sym); + +#include "exports_core_generated.h" +#include "exports_alloc_generated.h" +#include "exports_kernel_generated.h"
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 12/20 vsprintf: add new `%pA` format specifier
In reply to Miguel OjedaFrom: Gary Guo <[email protected]>
This patch adds a format specifier %pA to vsprintf which formats a pointer as core::fmt::Arguments. Doing so allows us to directly format to the internal buffer of printf, so we do not have to use a temporary buffer on the stack to pre-assemble the message on the Rust side.
This specifier is intended only to be used from Rust and not for C, so checkpatch.pl is intentionally unchanged to catch any misuse.
--- lib/vsprintf.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
lib/vsprintf.c +13 -0
@@ -2252,6 +2252,9 @@ int __init no_hash_pointers_enable(char *str) }early_param ("no_hash_pointers" , no_hash_pointers_enable); +/* Used for Rust formatting ('%pA'). */ +char *rust_fmt_argument (char * buf,char * end,void *ptr); +/* * Show a '%p' thing. A kernel extension is that the '%p' is followed * by an extra set of alphanumeric characters that are extended format
@@ -2378,6 +2381,10 @@ early_param("no_hash_pointers", no_hash_pointers_enable);* * Note: The default behaviour (unadorned %p) is to hash the address, * rendering it useful as a unique identifier. +* +* There is also a '%pA' format specifier, but it is only intended to be used +* from Rust code to format core::fmt::Arguments. Do *not* use it from C. +* See rust/kernel/print.rs for details. */ static noinline_for_stack char *pointer(const char *fmt, char *buf, char *end, void *ptr,
@@ -2450,6 +2457,12 @@ char *pointer(const char *fmt, char *buf, char *end, void *ptr,return device_node_string (buf, end, ptr, spec, fmt +1 );case 'f' :return fwnode_string (buf, end, ptr, spec, fmt +1 ); +case 'A' : +if (!IS_ENABLED (CONFIG_RUST )) { +WARN_ONCE (1 ,"Please remove %%pA from non-Rust code\n" ); +return error_string (buf, end,"(%pA?)" , spec); + } +return rust_fmt_argument (buf, end, ptr);case 'x' :return pointer_string (buf, end, ptr, spec);case 'e' :
Signature · 1 line
2.35.1
Andy Shevchenko
reviewerRe: [PATCH v5 12/20] vsprintf: add new `%pA` format specifier
Quoted 10 lines · Miguel Ojeda
From: Gary Guo <[email protected]>
This patch adds a format specifier
%pAtovsprintfwhich formats a pointer ascore::fmt::Arguments. Doing so allows us to directly format to the internal buffer ofprintf, so we do not have to use a temporary buffer on the stack to pre-assemble the message on the Rust side.This specifier is intended only to be used from Rust and not for C, so
checkpatch.plis intentionally unchanged to catch any misuse.
...
lib/vsprintf.c char *pointer(const char *fmt, char *buf, char *end, void *ptr, · line 2464
Quoted 5 lines
lib/vsprintf.c +5
-0+case 'A' : +if (!IS_ENABLED (CONFIG_RUST )) { +WARN_ONCE (1 ,"Please remove %%pA from non-Rust code\n" ); +return error_string (buf, end,"(%pA?)" , spec); + }
I'm wondering if the Big Scary Banner as trace_printk() does would be better (in case we can tell that %pA is used in the code when RUST=n).
Signature · 2 lines
With Best Regards, Andy Shevchenko
Petr Mladek
maintainerRe: [PATCH v5 12/20] vsprintf: add new `%pA` format specifier
Quoted 14 lines · Andy Shevchenko
Quoted 10 lines · Miguel Ojeda
From: Gary Guo <[email protected]>
This patch adds a format specifier
%pAtovsprintfwhich formats a pointer ascore::fmt::Arguments. Doing so allows us to directly format to the internal buffer ofprintf, so we do not have to use a temporary buffer on the stack to pre-assemble the message on the Rust side.This specifier is intended only to be used from Rust and not for C, so
checkpatch.plis intentionally unchanged to catch any misuse....
Quoted 8 lines
lib/vsprintf.c char *pointer(const char *fmt, char *buf, char *end, void *ptr, · line 2464
Quoted 5 lines
lib/vsprintf.c +5
-0+case 'A' : +if (!IS_ENABLED (CONFIG_RUST )) { +WARN_ONCE (1 ,"Please remove %%pA from non-Rust code\n" ); +return error_string (buf, end,"(%pA?)" , spec); + }I'm wondering if the Big Scary Banner as
trace_printk()does would be better (in case we can tell that %pA is used in the code when RUST=n).
Good question!
The advantage of WARN_ONCE() is that it shows the stack so that it is easier to locate the caller.
On the other hand, WARN_ONCE() is a bit misused here. It should be used only in situations that might be potentially fatal. It might even cause panic() with "panic_on_warn" kernel parameter.
Well, I am not sure if it is worth huge effort. WARN_ONCE() is practical in this case because of the backtrace. We could always create something better if people hit it more frequently and it causes real life problems.
Best Regards,
Petr
Sergey Senozhatsky
reviewerRe: [PATCH v5 12/20] vsprintf: add new `%pA` format specifier
Quoted 12 lines · Petr Mladek
Quoted 10 lines · Andy Shevchenko
lib/vsprintf.c char *pointer(const char *fmt, char *buf, char *end, void *ptr, · line 2464
Quoted 6 lines · Miguel Ojeda
From: Gary Guo <[email protected]>
lib/vsprintf.c +5
-0+case 'A' : +if (!IS_ENABLED (CONFIG_RUST )) { +WARN_ONCE (1 ,"Please remove %%pA from non-Rust code\n" ); +return error_string (buf, end,"(%pA?)" , spec); + }I'm wondering if the Big Scary Banner as
trace_printk()does would be better (in case we can tell that %pA is used in the code when RUST=n).
Quoted 8 lines
Good question!
The advantage of
WARN_ONCE()is that it shows the stack so that it is easier to locate the caller.On the other hand,
WARN_ONCE()is a bit misused here. It should be used only in situations that might be potentially fatal. It might even causepanic()with "panic_on_warn" kernel parameter.
Stack trace is certainly helpful here. So maybe dump_stack() instead of WARN_ONCE()? I guess I don't mind WARN_ONCE().
Miguel Ojeda
maintainerPATCH v5 13/20 scripts: add `generate_rust_analyzer.py`
In reply to Miguel OjedaThe generate_rust_analyzer.py script generates the configuration file (rust-project.json) for rust-analyzer.
rust-analyzer is a modular compiler frontend for the Rust language. It provides an LSP server which can be used in editors such as VS Code, Emacs or Vim.
--- scripts/generate_rust_analyzer.py | 133 ++++++++++++++++++++++++++++++ 1 file changed, 133 insertions(+) create mode 100755 scripts/generate_rust_analyzer.py
scripts/generate_rust_analyzer.py new file +133 -0
@@ -0,0 +1,133 @@ +#!/usr/bin/env python3 +"""generate_rust_analyzer - Generates the `rust-project.json` file for `rust-analyzer`. +""" + +import argparse +import json +import logging +import pathlib +import sys + +def generate_crates(srctree, objtree, sysroot_src): + # Generate the configuration list. + cfg = [] + with open(objtree / "include" / "generated" / "rustc_cfg") as fd: + for line in fd: + line = line.replace("--cfg=", "") + line = line.replace("\n", "") + cfg.append(line) + + # Now fill the crates list -- dependencies need to come first. + # + # Avoid O(n^2) iterations by keeping a map of indexes. + crates = [] + crates_indexes = {} + + def append_crate(display_name, root_module, deps, cfg=[], is_workspace_member=True, is_proc_macro=False): + crates_indexes[display_name] = len(crates) + crates.append({ + "display_name": display_name, + "root_module": str(root_module), + "is_workspace_member": is_workspace_member, + "is_proc_macro": is_proc_macro, + "deps": [{"crate": crates_indexes[dep], "name": dep} for dep in deps], + "cfg": cfg, + "edition": "2021", + "env": { + "RUST_MODFILE": "This is only for rust-analyzer" + } + }) + + # First, the ones in `rust/` since they are a bit special. + append_crate( + "core", + sysroot_src / "core" / "src" / "lib.rs", + [], + is_workspace_member=False, + ) + + append_crate( + "compiler_builtins", + srctree / "rust" / "compiler_builtins.rs", + [], + ) + + append_crate( + "alloc", + srctree / "rust" / "alloc" / "lib.rs", + ["core", "compiler_builtins"], + ) + + append_crate( + "macros", + srctree / "rust" / "macros" / "lib.rs", + [], + is_proc_macro=True, + ) + crates[-1]["proc_macro_dylib_path"] = "rust/libmacros.so" + + append_crate( + "build_error", + srctree / "rust" / "build_error.rs", + ["core", "compiler_builtins"], + ) + + append_crate( + "kernel", + srctree / "rust" / "kernel" / "lib.rs", + ["core", "alloc", "macros", "build_error"], + cfg=cfg, + ) + crates[-1]["env"]["OBJTREE"] = str(objtree.resolve(True)) + crates[-1]["source"] = { + "include_dirs": [ + str(srctree / "rust" / "kernel"), + str(objtree / "rust") + ], + "exclude_dirs": [], + } + + # Then, the rest outside of `rust/`. + # + # We explicitly mention the top-level folders we want to cover. + for folder in ("samples", "drivers"): + for path in (srctree / folder).rglob("*.rs"): + logging.info("Checking %s", path) + name = path.name.replace(".rs", "") + + # Skip those that are not crate roots. + if f"{name}.o" not in open(path.parent / "Makefile").read(): + continue + + logging.info("Adding %s", name) + append_crate( + name, + path, + ["core", "alloc", "kernel"], + cfg=cfg, + ) + + return crates + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--verbose', '-v', action='store_true') + parser.add_argument("srctree", type=pathlib.Path) + parser.add_argument("objtree", type=pathlib.Path) + parser.add_argument("sysroot_src", type=pathlib.Path) + args = parser.parse_args() + + logging.basicConfig( + format="[%(asctime)s] [%(levelname)s] %(message)s", + level=logging.INFO if args.verbose else logging.WARNING + ) + + rust_project = { + "crates": generate_crates(args.srctree, args.objtree, args.sysroot_src), + "sysroot_src": str(args.sysroot_src), + } + + json.dump(rust_project, sys.stdout, sort_keys=True, indent=4) + +if __name__ == "__main__": + main()
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 14/20 scripts: decode_stacktrace: demangle Rust symbols
In reply to Miguel OjedaRecent versions of both Binutils (c++filt) and LLVM (llvm-cxxfilt) provide Rust v0 mangling support.
---
I would like to use this patch for discussing the demangling topic.
The following discusses the different approaches we could take.
# Leave demangling to userspace
This is the easiest and less invasive approach, the one implemented by this patch.
The decode_stacktrace.sh script is already needed to map the offsets to the source code. Therefore, we could also take the chance to demangle the symbols here.
With this approach, we do not need to introduce any change in the vsprintf machinery and we minimize the risk of breaking user tools.
Note that, if we take this approach, it is likely we want to ask for a minimum version of either of the tools (since there may be users of the script that do not have recent enough toolchains).
# Demangling in kernelspace on-the-fly
That is, at backtrace print time, we demangle the Rust symbols.
The size of the code that would be needed is fairly small; around 5 KiB using the "official" library (written in Rust), e.g.:
text data bss dec hex filename
7799976 1689820 2129920 11619716 b14d84 vmlinux
7801111 1693916 2129920 11624947 b161f3 vmlinux + demanglingWe can remove a few bits from the official library, e.g. punycode support that we do not need (all our identifiers will be ASCII), but it does not make a substantial difference.
The official library performs the demangling without requiring allocations. However, of course, it will increased our stack usage and complexity, specially considering a stack dump may be requested in not ideal conditions.
Furthermore, this approach (and the ones below) likely require adding a new %p specifier (or a new modifier to existing ones) if we do not want to affect non-backtrace uses of the B/S ones. Also, it is unclear whether we should write the demangled versions in an extra, different line or replace the real symbol -- we could be breaking user tools relying on parsing backtraces (e.g. our own decode_stacktrace.sh). For instance, they could be relying on having real symbols there, or may break due to e.g. spaces.
# Demangling at compile-time
This implies having kallsyms demangle all the Rust symbols.
The size of this data is around the same order of magnitude of the non-demangled ones. However, this is notably more than the demangling code (see previous point), e.g. 120 KiB (uncompressed) in a small kernel.
This approach also brings the same concerns regarding modifying the backtrace printing (see previous point).
# Demangling at compile-time and substituting symbols by hashes
One variation of the previous alternative is avoiding the mangled names inside the kernel, by hashing them. This would avoid having to support "big symbols" and would also reduce the size of the kallsyms tables, while still allowing to link modules.
However, if we do not have the real symbols around, then we do not have the possibility of providing both the mangled and demangled versions in the backtrace, which brings us back to the issues related to breaking userspace tools. There are also other places other than backtraces using "real" symbols that users may be relying on, such as /proc/*/stack.
scripts/decode_stacktrace.sh | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
scripts/decode_stacktrace.sh +14 -0
@@ -8,6 +8,14 @@ usage() { echo " $0 -r <release> | <vmlinux> [<base path>|auto] [<modules path>]" } +# Try to find a Rust demangler +if type llvm-cxxfilt >/dev/null 2>&1 ; then + cppfilt=llvm-cxxfilt +elif type c++filt >/dev/null 2>&1 ; then + cppfilt=c++filt + cppfilt_opts=-i +fi + if [[ $1 == "-r" ]] ; then vmlinux="" basepath="auto"
@@ -169,6 +177,12 @@ parse_symbol() { # In the case of inlines, move everything to same line code=${code//$'\n'/' '} + # Demangle if the name looks like a Rust symbol and if + # we got a Rust demangler + if [[ $name =~ ^_R && $cppfilt != "" ]] ; then + name=$("$cppfilt" "$cppfilt_opts" "$name") + fi + # Replace old address with pretty line numbers symbol="$segment$name ($code)" }
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 15/20 docs: add Rust documentation
In reply to Miguel OjedaMost of the documentation for Rust is written within the source code itself, as it is idiomatic for Rust projects. This applies to both the shared infrastructure at rust/ as well as any other Rust module (e.g. drivers) written across the kernel.
However, these documents contain general information that does not fit particularly well in the source code, like the Quick Start guide.
It also contains an asset (SVG logo) used for the rustdoc target and a few other small changes elsewhere in the documentation folder.
--- Documentation/doc-guide/kernel-doc.rst | 3 + Documentation/index.rst | 1 + Documentation/kbuild/kbuild.rst | 17 + Documentation/kbuild/makefiles.rst | 50 ++- Documentation/process/changes.rst | 41 +++ Documentation/rust/arch-support.rst | 34 ++ Documentation/rust/coding-guidelines.rst | 214 ++++++++++++ Documentation/rust/general-information.rst | 77 +++++ Documentation/rust/index.rst | 20 ++ Documentation/rust/logo.svg | 357 +++++++++++++++++++++ Documentation/rust/quick-start.rst | 230 +++++++++++++ 11 files changed, 1040 insertions(+), 4 deletions(-) create mode 100644 Documentation/rust/arch-support.rst create mode 100644 Documentation/rust/coding-guidelines.rst create mode 100644 Documentation/rust/general-information.rst create mode 100644 Documentation/rust/index.rst create mode 100644 Documentation/rust/logo.svg create mode 100644 Documentation/rust/quick-start.rst
Documentation/doc-guide/kernel-doc.rst +3 -0
@@ -11,6 +11,9 @@ when it is embedded in source files. reasons. The kernel source contains tens of thousands of kernel-doc comments. Please stick to the style described here. +.. note:: kernel-doc does not cover Rust code: please see + Documentation/rust/docs.rst instead. + The kernel-doc structure is extracted from the comments, and proper `Sphinx C Domain`_ function and type descriptions with anchors are generated from them. The descriptions are filtered for special kernel-doc
Documentation/index.rst +1 -0
@@ -82,6 +82,7 @@ merged much easier. maintainer/index fault-injection/index livepatch/index + rust/index Kernel API documentation
Documentation/kbuild/kbuild.rst +17 -0
@@ -48,6 +48,10 @@ KCFLAGS ------- Additional options to the C compiler (for built-in and modules). +KRUSTFLAGS +---------- +Additional options to the Rust compiler (for built-in and modules). + CFLAGS_KERNEL ------------- Additional options for $(CC) when used to compile
@@ -57,6 +61,15 @@ CFLAGS_MODULE ------------- Additional module specific options to use for $(CC). +RUSTFLAGS_KERNEL +---------------- +Additional options for $(RUSTC) when used to compile +code that is compiled as built-in. + +RUSTFLAGS_MODULE +---------------- +Additional module specific options to use for $(RUSTC). + LDFLAGS_MODULE -------------- Additional options used for $(LD) when linking modules.
@@ -69,6 +82,10 @@ HOSTCXXFLAGS ------------ Additional flags to be passed to $(HOSTCXX) when building host programs. +HOSTRUSTFLAGS +------------- +Additional flags to be passed to $(HOSTRUSTC) when building host programs. + HOSTLDFLAGS ----------- Additional flags to be passed when linking host programs.
Documentation/kbuild/makefiles.rst +46 -4
80 lines not on this page · raw message
Documentation/process/changes.rst +41 -0
65 lines not on this page · raw message
Documentation/rust/arch-support.rst new file +34 -0
@@ -0,0 +1,34 @@ +Arch Support +============ + +Currently, the Rust compiler (``rustc``) uses LLVM for code generation, +which limits the supported architectures that can be targeted. In addition, +support for building the kernel with LLVM/Clang varies (please see +Documentation/kbuild/llvm.rst). This support is needed for ``bindgen`` +which uses ``libclang``. + +Below is a general summary of architectures that currently work. Level of +support corresponds to ``S`` values in the ``MAINTAINERS`` file. + +.. list-table:: + :widths: 10 10 10 + :header-rows: 1 + + * - Architecture + - Level of support + - Constraints + * - ``arm`` + - Maintained + - ``armv6`` and compatible only, ``RUST_OPT_LEVEL >= 2`` + * - ``arm64`` + - Maintained + - None + * - ``powerpc`` + - Maintained + - ``ppc64le`` only, ``RUST_OPT_LEVEL < 2`` requires ``CONFIG_THREAD_SHIFT=15`` + * - ``riscv`` + - Maintained + - ``riscv64`` only + * - ``x86`` + - Maintained + - ``x86_64`` only
Documentation/rust/coding-guidelines.rst new file +214 -0
214 lines not on this page · raw message
Documentation/rust/general-information.rst new file +77 -0
77 lines not on this page · raw message
Documentation/rust/index.rst new file +20 -0
@@ -0,0 +1,20 @@ +Rust +==== + +Documentation related to Rust within the kernel. To start using Rust +in the kernel, please read the quick-start.rst guide. + +.. toctree:: + :maxdepth: 1 + + quick-start + general-information + coding-guidelines + arch-support + +.. only:: subproject and html + + Indices + ======= + + * :ref:`genindex`
Documentation/rust/logo.svg new file +357 -0
357 lines not on this page · raw message
Documentation/rust/quick-start.rst new file +230 -0
230 lines not on this page · raw message
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 16/20 Kbuild: add Rust support
In reply to Miguel OjedaHaving all the new files in place, we now enable Rust support in the build system, including Kconfig entries related to Rust, the Rust configuration printer, the target specification generation script, the version detection script and a few other bits.
--- .gitignore | 5 + .rustfmt.toml | 12 + Makefile | 173 ++++++++- arch/Kconfig | 6 + arch/arm/Kconfig | 1 + arch/arm64/Kconfig | 1 + arch/powerpc/Kconfig | 1 + arch/riscv/Kconfig | 1 + arch/riscv/Makefile | 5 + arch/x86/Kconfig | 1 + arch/x86/Makefile | 14 + init/Kconfig | 44 ++- lib/Kconfig.debug | 143 +++++++ rust/.gitignore | 8 + rust/Makefile | 376 +++++++++++++++++++ rust/bindgen_parameters | 13 + scripts/.gitignore | 1 + scripts/Kconfig.include | 6 +- scripts/Makefile | 3 + scripts/Makefile.build | 60 +++ scripts/Makefile.debug | 10 + scripts/Makefile.host | 34 +- scripts/Makefile.lib | 12 + scripts/Makefile.modfinal | 8 +- scripts/cc-version.sh | 12 +- scripts/generate_rust_target.rs | 227 +++++++++++ scripts/is_rust_module.sh | 13 + scripts/kconfig/confdata.c | 75 ++++ scripts/min-tool-version.sh | 6 + scripts/rust-is-available-bindgen-libclang.h | 2 + scripts/rust-is-available.sh | 158 ++++++++ 31 files changed, 1408 insertions(+), 23 deletions(-) create mode 100644 .rustfmt.toml create mode 100644 rust/.gitignore create mode 100644 rust/Makefile create mode 100644 rust/bindgen_parameters create mode 100644 scripts/generate_rust_target.rs create mode 100755 scripts/is_rust_module.sh create mode 100644 scripts/rust-is-available-bindgen-libclang.h create mode 100755 scripts/rust-is-available.sh
.gitignore +5 -0
@@ -37,6 +37,7 @@ *.o *.o.* *.patch +*.rmeta *.s *.so *.so.dbg
@@ -96,6 +97,7 @@ modules.order !.gitattributes !.gitignore !.mailmap +!.rustfmt.toml # # Generated include files
@@ -161,3 +163,6 @@ x509.genkey # Documentation toolchain sphinx_*/ + +# Rust analyzer configuration +/rust-project.json
.rustfmt.toml new file +12 -0
@@ -0,0 +1,12 @@ +edition = "2021" +newline_style = "Unix" + +# Unstable options that help catching some mistakes in formatting and that we may want to enable +# when they become stable. +# +# They are kept here since they are useful to run from time to time. +#format_code_in_doc_comments = true +#reorder_impl_items = true +#comment_width = 100 +#wrap_comments = true +#normalize_comments = true
Makefile +166 -7
330 lines not on this page · raw message
arch/Kconfig +6 -0
@@ -339,6 +339,12 @@ config HAVE_RSEQ This symbol should be selected by an architecture if it supports an implementation of restartable sequences. +config HAVE_RUST + bool + help + This symbol should be selected by an architecture if it + supports Rust. + config HAVE_FUNCTION_ARG_ACCESS_API bool help
arch/arm/Kconfig +1 -0
@@ -113,6 +113,7 @@ config ARM select MMU_GATHER_RCU_TABLE_FREE if SMP && ARM_LPAE select HAVE_REGS_AND_STACK_ACCESS_API select HAVE_RSEQ + select HAVE_RUST if CPU_32v6 || CPU_32v6K select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS select HAVE_UID16
arch/arm64/Kconfig +1 -0
@@ -197,6 +197,7 @@ config ARM64 select HAVE_FUNCTION_ARG_ACCESS_API select MMU_GATHER_RCU_TABLE_FREE select HAVE_RSEQ + select HAVE_RUST select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS select HAVE_KPROBES
arch/powerpc/Kconfig +1 -0
@@ -232,6 +232,7 @@ config PPC select HAVE_REGS_AND_STACK_ACCESS_API select HAVE_RELIABLE_STACKTRACE select HAVE_RSEQ + select HAVE_RUST if PPC64 && CPU_LITTLE_ENDIAN select HAVE_SETUP_PER_CPU_AREA if PPC64 select HAVE_SOFTIRQ_ON_OWN_STACK select HAVE_STACKPROTECTOR if PPC32 && $(cc-option,-mstack-protector-guard=tls -mstack-protector-guard-reg=r2)
arch/riscv/Kconfig +1 -0
@@ -98,6 +98,7 @@ config RISCV select HAVE_PERF_REGS select HAVE_PERF_USER_STACK_DUMP select HAVE_REGS_AND_STACK_ACCESS_API + select HAVE_RUST if 64BIT select HAVE_FUNCTION_ARG_ACCESS_API select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS
arch/riscv/Makefile +5 -0
@@ -26,6 +26,8 @@ ifeq ($(CONFIG_ARCH_RV64I),y) KBUILD_CFLAGS += -mabi=lp64 KBUILD_AFLAGS += -mabi=lp64 + KBUILD_RUSTFLAGS += -Ctarget-cpu=generic-rv64 + KBUILD_LDFLAGS += -melf64lriscv else BITS := 32
@@ -33,6 +35,9 @@ else KBUILD_CFLAGS += -mabi=ilp32 KBUILD_AFLAGS += -mabi=ilp32 + + KBUILD_RUSTFLAGS += -Ctarget-cpu=generic-rv32 + KBUILD_LDFLAGS += -melf32lriscv endif
arch/x86/Kconfig +1 -0
@@ -248,6 +248,7 @@ config X86 select HAVE_STATIC_CALL_INLINE if HAVE_STACK_VALIDATION select HAVE_PREEMPT_DYNAMIC select HAVE_RSEQ + select HAVE_RUST if X86_64 select HAVE_SYSCALL_TRACEPOINTS select HAVE_UNSTABLE_SCHED_CLOCK select HAVE_USER_RETURN_NOTIFIER
arch/x86/Makefile +14 -0
@@ -21,6 +21,8 @@ ifdef CONFIG_CC_IS_CLANG RETPOLINE_CFLAGS := -mretpoline-external-thunk RETPOLINE_VDSO_CFLAGS := -mretpoline endif +RETPOLINE_RUSTFLAGS := -Ctarget-feature=+retpoline-external-thunk + export RETPOLINE_CFLAGS export RETPOLINE_VDSO_CFLAGS
@@ -61,6 +63,8 @@ export BITS # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53383 # KBUILD_CFLAGS += -mno-sse -mno-mmx -mno-sse2 -mno-3dnow -mno-avx +KBUILD_RUSTFLAGS += -Ctarget-feature=-mmx,-sse,-sse2,-sse3,-ssse3,-sse4.1,-sse4.2 +KBUILD_RUSTFLAGS += -Ctarget-feature=-3dnow,-3dnowa,-avx,-avx2,+soft-float # Intel CET isn't enabled in the kernel KBUILD_CFLAGS += $(call cc-option,-fcf-protection=none)
@@ -136,8 +140,17 @@ else cflags-$(CONFIG_GENERIC_CPU) += -mtune=generic KBUILD_CFLAGS += $(cflags-y) + rustflags-$(CONFIG_MK8) += -Ctarget-cpu=k8 + rustflags-$(CONFIG_MPSC) += -Ctarget-cpu=nocona + rustflags-$(CONFIG_MCORE2) += -Ctarget-cpu=core2 + rustflags-$(CONFIG_MATOM) += -Ctarget-cpu=atom + rustflags-$(CONFIG_GENERIC_CPU) += -Ztune-cpu=generic + KBUILD_RUSTFLAGS += $(rustflags-y) + KBUILD_CFLAGS += -mno-red-zone KBUILD_CFLAGS += -mcmodel=kernel + KBUILD_RUSTFLAGS += -Cno-redzone=y + KBUILD_RUSTFLAGS += -Ccode-model=kernel endif ifdef CONFIG_X86_X32
@@ -189,6 +202,7 @@ ifdef CONFIG_RETPOLINE ifndef CONFIG_CC_IS_CLANG KBUILD_CFLAGS += -fno-jump-tables endif + KBUILD_RUSTFLAGS += $(RETPOLINE_RUSTFLAGS) endif ifdef CONFIG_SLS
init/Kconfig +43 -1
62 lines not on this page · raw message
lib/Kconfig.debug +143 -0
149 lines not on this page · raw message
rust/.gitignore new file +8 -0
@@ -0,0 +1,8 @@ +# SPDX-License-Identifier: GPL-2.0 + +target.json +bindings_generated.rs +bindings_helpers_generated.rs +exports_*_generated.h +doc/ +test/
rust/Makefile new file +376 -0
376 lines not on this page · raw message
rust/bindgen_parameters new file +13 -0
@@ -0,0 +1,13 @@ +# SPDX-License-Identifier: GPL-2.0 + +--opaque-type xregs_state +--opaque-type desc_struct +--opaque-type arch_lbr_state +--opaque-type local_apic + +# If SMP is disabled, `arch_spinlock_t` is defined as a ZST which triggers a Rust +# warning. We don't need to peek into it anyway. +--opaque-type spinlock + +# `seccomp`'s comment gets understood as a doctest +--no-doc-comments
scripts/.gitignore +1 -0
@@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0-only /asn1_compiler /bin2c +/generate_rust_target /insert-sys-cert /kallsyms /module.lds
scripts/Kconfig.include +3 -3
@@ -36,12 +36,12 @@ ld-option = $(success,$(LD) -v $(1)) as-instr = $(success,printf "%b\n" "$(1)" | $(CC) $(CLANG_FLAGS) -c -x assembler -o /dev/null -) # check if $(CC) and $(LD) exist -$(error-if,$(failure,command -v $(CC)),compiler '$(CC)' not found) +$(error-if,$(failure,command -v $(CC)),C compiler '$(CC)' not found) $(error-if,$(failure,command -v $(LD)),linker '$(LD)' not found) -# Get the compiler name, version, and error out if it is not supported. +# Get the C compiler name, version, and error out if it is not supported. cc-info := $(shell,$(srctree)/scripts/cc-version.sh $(CC)) -$(error-if,$(success,test -z "$(cc-info)"),Sorry$(comma) this compiler is not supported.) +$(error-if,$(success,test -z "$(cc-info)"),Sorry$(comma) this C compiler is not supported.) cc-name := $(shell,set -- $(cc-info) && echo $1) cc-version := $(shell,set -- $(cc-info) && echo $2)
scripts/Makefile +3 -0
@@ -10,6 +10,9 @@ hostprogs-always-$(CONFIG_BUILDTIME_TABLE_SORT) += sorttable hostprogs-always-$(CONFIG_ASN1) += asn1_compiler hostprogs-always-$(CONFIG_MODULE_SIG_FORMAT) += sign-file hostprogs-always-$(CONFIG_SYSTEM_EXTRA_CERTIFICATE) += insert-sys-cert +hostprogs-always-$(CONFIG_RUST) += generate_rust_target + +generate_rust_target-rust := y HOSTCFLAGS_sorttable.o = -I$(srctree)/tools/include HOSTLDLIBS_sorttable = -lpthread
scripts/Makefile.build +60 -0
72 lines not on this page · raw message
scripts/Makefile.debug +10 -0
@@ -1,4 +1,5 @@ DEBUG_CFLAGS := +DEBUG_RUSTFLAGS := ifdef CONFIG_DEBUG_INFO_SPLIT DEBUG_CFLAGS += -gsplit-dwarf
@@ -10,6 +11,12 @@ ifndef CONFIG_AS_IS_LLVM KBUILD_AFLAGS += -Wa,-gdwarf-2 endif +ifdef CONFIG_DEBUG_INFO_REDUCED +DEBUG_RUSTFLAGS += -Cdebuginfo=1 +else +DEBUG_RUSTFLAGS += -Cdebuginfo=2 +endif + ifndef CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT dwarf-version-$(CONFIG_DEBUG_INFO_DWARF4) := 4 dwarf-version-$(CONFIG_DEBUG_INFO_DWARF5) := 5
@@ -31,3 +38,6 @@ endif KBUILD_CFLAGS += $(DEBUG_CFLAGS) export DEBUG_CFLAGS + +KBUILD_RUSTFLAGS += $(DEBUG_RUSTFLAGS) +export DEBUG_RUSTFLAGS
scripts/Makefile.host +31 -3
@@ -22,6 +22,8 @@ $(obj)/%.tab.c $(obj)/%.tab.h: $(src)/%.y FORCE # to preprocess a data file. # # Both C and C++ are supported, but preferred language is C for such utilities. +# Rust is also supported, but it may only be used in scenarios where a Rust +# toolchain is required to be available (e.g. when `CONFIG_RUST` is enabled). # # Sample syntax (see Documentation/kbuild/makefiles.rst for reference) # hostprogs := bin2hex
@@ -37,15 +39,20 @@ $(obj)/%.tab.c $(obj)/%.tab.h: $(src)/%.y FORCE # qconf-objs := menu.o # Will compile qconf as a C++ program, and menu as a C program. # They are linked as C++ code to the executable qconf +# +# hostprogs := target +# target-rust := y +# Will compile `target` as a Rust program, using `target.rs` as the crate root. +# The crate may consist of several source files. # C code # Executables compiled from a single .c file host-csingle := $(foreach m,$(hostprogs), \ - $(if $($(m)-objs)$($(m)-cxxobjs),,$(m))) + $(if $($(m)-objs)$($(m)-cxxobjs)$($(m)-rust),,$(m))) # C executables linked based on several .o files host-cmulti := $(foreach m,$(hostprogs),\ - $(if $($(m)-cxxobjs),,$(if $($(m)-objs),$(m)))) + $(if $($(m)-cxxobjs)$($(m)-rust),,$(if $($(m)-objs),$(m)))) # Object (.o) files compiled from .c files host-cobjs := $(sort $(foreach m,$(hostprogs),$($(m)-objs)))
@@ -58,11 +65,17 @@ host-cxxmulti := $(foreach m,$(hostprogs),$(if $($(m)-cxxobjs),$(m))) # C++ Object (.o) files compiled from .cc files host-cxxobjs := $(sort $(foreach m,$(host-cxxmulti),$($(m)-cxxobjs))) +# Rust code +# Executables compiled from a single Rust crate (which may consist of +# one or more .rs files) +host-rust := $(foreach m,$(hostprogs),$(if $($(m)-rust),$(m))) + host-csingle := $(addprefix $(obj)/,$(host-csingle)) host-cmulti := $(addprefix $(obj)/,$(host-cmulti)) host-cobjs := $(addprefix $(obj)/,$(host-cobjs)) host-cxxmulti := $(addprefix $(obj)/,$(host-cxxmulti)) host-cxxobjs := $(addprefix $(obj)/,$(host-cxxobjs)) +host-rust := $(addprefix $(obj)/,$(host-rust)) ##### # Handle options to gcc. Support building with separate output directory
@@ -71,6 +84,8 @@ _hostc_flags = $(KBUILD_HOSTCFLAGS) $(HOST_EXTRACFLAGS) \ $(HOSTCFLAGS_$(target-stem).o) _hostcxx_flags = $(KBUILD_HOSTCXXFLAGS) $(HOST_EXTRACXXFLAGS) \ $(HOSTCXXFLAGS_$(target-stem).o) +_hostrust_flags = $(KBUILD_HOSTRUSTFLAGS) $(HOST_EXTRARUSTFLAGS) \ + $(HOSTRUSTFLAGS_$(target-stem)) # $(objtree)/$(obj) for including generated headers from checkin source files ifeq ($(KBUILD_EXTMOD),)
@@ -82,6 +97,7 @@ endif hostc_flags = -Wp,-MMD,$(depfile) $(_hostc_flags) hostcxx_flags = -Wp,-MMD,$(depfile) $(_hostcxx_flags) +hostrust_flags = $(_hostrust_flags) ##### # Compile programs on the host
@@ -128,5 +144,17 @@ quiet_cmd_host-cxxobjs = HOSTCXX $@ $(host-cxxobjs): $(obj)/%.o: $(src)/%.cc FORCE $(call if_changed_dep,host-cxxobjs) +# Create executable from a single Rust crate (which may consist of +# one or more `.rs` files) +# host-rust -> Executable +quiet_cmd_host-rust = HOSTRUSTC $@ + cmd_host-rust = \ + $(HOSTRUSTC) $(hostrust_flags) --emit=dep-info,link \ + --out-dir=$(obj)/ $<; \ + mv $(obj)/$(target-stem).d $(depfile); \ + sed -i '/^\#/d' $(depfile) +$(host-rust): $(obj)/%: $(src)/%.rs FORCE + $(call if_changed_dep,host-rust) + targets += $(host-csingle) $(host-cmulti) $(host-cobjs) \ - $(host-cxxmulti) $(host-cxxobjs) + $(host-cxxmulti) $(host-cxxobjs) $(host-rust)
scripts/Makefile.lib +12 -0
@@ -8,6 +8,7 @@ ldflags-y += $(EXTRA_LDFLAGS) # flags that take effect in current and sub directories KBUILD_AFLAGS += $(subdir-asflags-y) KBUILD_CFLAGS += $(subdir-ccflags-y) +KBUILD_RUSTFLAGS += $(subdir-rustflags-y) # Figure out what we need to build from the various variables # ===========================================================================
@@ -133,6 +134,10 @@ _c_flags = $(filter-out $(CFLAGS_REMOVE_$(target-stem).o), \ $(filter-out $(ccflags-remove-y), \ $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) $(ccflags-y)) \ $(CFLAGS_$(target-stem).o)) +_rust_flags = $(filter-out $(RUSTFLAGS_REMOVE_$(target-stem).o), \ + $(filter-out $(rustflags-remove-y), \ + $(KBUILD_RUSTFLAGS) $(rustflags-y)) \ + $(RUSTFLAGS_$(target-stem).o)) _a_flags = $(filter-out $(AFLAGS_REMOVE_$(target-stem).o), \ $(filter-out $(asflags-remove-y), \ $(KBUILD_CPPFLAGS) $(KBUILD_AFLAGS) $(asflags-y)) \
@@ -207,6 +212,11 @@ modkern_cflags = \ $(KBUILD_CFLAGS_MODULE) $(CFLAGS_MODULE), \ $(KBUILD_CFLAGS_KERNEL) $(CFLAGS_KERNEL) $(modfile_flags)) +modkern_rustflags = \ + $(if $(part-of-module), \ + $(KBUILD_RUSTFLAGS_MODULE) $(RUSTFLAGS_MODULE), \ + $(KBUILD_RUSTFLAGS_KERNEL) $(RUSTFLAGS_KERNEL)) + modkern_aflags = $(if $(part-of-module), \ $(KBUILD_AFLAGS_MODULE) $(AFLAGS_MODULE), \ $(KBUILD_AFLAGS_KERNEL) $(AFLAGS_KERNEL))
@@ -216,6 +226,8 @@ c_flags = -Wp,-MMD,$(depfile) $(NOSTDINC_FLAGS) $(LINUXINCLUDE) \ $(_c_flags) $(modkern_cflags) \ $(basename_flags) $(modname_flags) +rust_flags = $(_rust_flags) $(modkern_rustflags) @$(objtree)/include/generated/rustc_cfg + a_flags = -Wp,-MMD,$(depfile) $(NOSTDINC_FLAGS) $(LINUXINCLUDE) \ $(_a_flags) $(modkern_aflags)
scripts/Makefile.modfinal +5 -3
@@ -39,11 +39,13 @@ quiet_cmd_ld_ko_o = LD [M] $@ quiet_cmd_btf_ko = BTF [M] $@ cmd_btf_ko = \ - if [ -f vmlinux ]; then \ + if [ ! -f vmlinux ]; then \ + printf "Skipping BTF generation for %s due to unavailability of vmlinux\n" $@ 1>&2; \ + elif [ -n "$(CONFIG_RUST)" ] && $(srctree)/scripts/is_rust_module.sh $@; then \ + printf "Skipping BTF generation for %s because it's a Rust module\n" $@ 1>&2; \ + else \ LLVM_OBJCOPY="$(OBJCOPY)" $(PAHOLE) -J $(PAHOLE_FLAGS) --btf_base vmlinux $@; \ $(RESOLVE_BTFIDS) -b vmlinux $@; \ - else \ - printf "Skipping BTF generation for %s due to unavailability of vmlinux\n" $@ 1>&2; \ fi; # Same as newer-prereqs, but allows to exclude specified extra dependencies
scripts/cc-version.sh +6 -6
@@ -1,13 +1,13 @@ #!/bin/sh # SPDX-License-Identifier: GPL-2.0 # -# Print the compiler name and its version in a 5 or 6-digit form. +# Print the C compiler name and its version in a 5 or 6-digit form. # Also, perform the minimum version check. set -e -# Print the compiler name and some version components. -get_compiler_info() +# Print the C compiler name and some version components. +get_c_compiler_info() { cat <<- EOF | "$@" -E -P -x c - 2>/dev/null #if defined(__clang__)
@@ -32,7 +32,7 @@ get_canonical_version() # $@ instead of $1 because multiple words might be given, e.g. CC="ccache gcc". orig_args="$@" -set -- $(get_compiler_info "$@") +set -- $(get_c_compiler_info "$@") name=$1
@@ -52,7 +52,7 @@ ICC) min_version=$($min_tool_version icc) ;; *) - echo "$orig_args: unknown compiler" >&2 + echo "$orig_args: unknown C compiler" >&2 exit 1 ;; esac
@@ -62,7 +62,7 @@ min_cversion=$(get_canonical_version $min_version) if [ "$cversion" -lt "$min_cversion" ]; then echo >&2 "***" - echo >&2 "*** Compiler is too old." + echo >&2 "*** C compiler is too old." echo >&2 "*** Your $name version: $version" echo >&2 "*** Minimum $name version: $min_version" echo >&2 "***"
scripts/generate_rust_target.rs new file +227 -0
227 lines not on this page · raw message
scripts/is_rust_module.sh new file +13 -0
@@ -0,0 +1,13 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# +# is_rust_module.sh module.ko +# +# Returns `0` if `module.ko` is a Rust module, `1` otherwise. + +set -e + +# Using the `16_` prefix ensures other symbols with the same substring +# are not picked up (even if it would be unlikely). The last part is +# used just in case LLVM decides to use the `.` suffix. +${NM} "$*" | grep -qE '^[0-9a-fA-F]+ r _R[^[:space:]]+16___IS_RUST_MODULE[^[:space:]]*$'
scripts/kconfig/confdata.c +75 -0
99 lines not on this page · raw message
scripts/min-tool-version.sh +6 -0
@@ -31,6 +31,12 @@ llvm) echo 11.0.0 fi ;; +rustc) + echo 1.59.0 + ;; +bindgen) + echo 0.56.0 + ;; *) echo "$1: unknown tool" >&2 exit 1
scripts/rust-is-available-bindgen-libclang.h new file +2 -0
@@ -0,0 +1,2 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#pragma message("clang version " __clang_version__)
scripts/rust-is-available.sh new file +158 -0
158 lines not on this page · raw message
Signature · 7 lines
2.35.1 _______________________________________________ linux-riscv mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-riscv
Miguel Ojeda
maintainerPATCH v5 17/20 samples: add Rust examples
In reply to Miguel OjedaA set of Rust modules that showcase how Rust modules look like and how to use the abstracted kernel features, as well as an example of a Rust host program with several modules.
These samples also double as tests in the CI.
The semaphore sample comes with a C version for comparison.
--- samples/Kconfig | 2 + samples/Makefile | 1 + samples/rust/Kconfig | 130 +++++++++++++++ samples/rust/Makefile | 15 ++ samples/rust/hostprogs/.gitignore | 3 + samples/rust/hostprogs/Makefile | 5 + samples/rust/hostprogs/a.rs | 7 + samples/rust/hostprogs/b.rs | 5 + samples/rust/hostprogs/single.rs | 12 ++ samples/rust/rust_chrdev.rs | 50 ++++++ samples/rust/rust_minimal.rs | 35 ++++ samples/rust/rust_miscdev.rs | 143 +++++++++++++++++ samples/rust/rust_module_parameters.rs | 69 ++++++++ samples/rust/rust_platform.rs | 22 +++ samples/rust/rust_print.rs | 54 +++++++ samples/rust/rust_random.rs | 60 +++++++ samples/rust/rust_semaphore.rs | 171 ++++++++++++++++++++ samples/rust/rust_semaphore_c.c | 212 +++++++++++++++++++++++++ samples/rust/rust_stack_probing.rs | 36 +++++ samples/rust/rust_sync.rs | 93 +++++++++++ 20 files changed, 1125 insertions(+) create mode 100644 samples/rust/Kconfig create mode 100644 samples/rust/Makefile create mode 100644 samples/rust/hostprogs/.gitignore create mode 100644 samples/rust/hostprogs/Makefile create mode 100644 samples/rust/hostprogs/a.rs create mode 100644 samples/rust/hostprogs/b.rs create mode 100644 samples/rust/hostprogs/single.rs create mode 100644 samples/rust/rust_chrdev.rs create mode 100644 samples/rust/rust_minimal.rs create mode 100644 samples/rust/rust_miscdev.rs create mode 100644 samples/rust/rust_module_parameters.rs create mode 100644 samples/rust/rust_platform.rs create mode 100644 samples/rust/rust_print.rs create mode 100644 samples/rust/rust_random.rs create mode 100644 samples/rust/rust_semaphore.rs create mode 100644 samples/rust/rust_semaphore_c.c create mode 100644 samples/rust/rust_stack_probing.rs create mode 100644 samples/rust/rust_sync.rs
samples/Kconfig +2 -0
@@ -250,6 +250,8 @@ config SAMPLE_CORESIGHT_SYSCFG This demonstrates how a user may create their own CoreSight configurations and easily load them into the system at runtime. +source "samples/rust/Kconfig" + endif # SAMPLES config HAVE_SAMPLE_FTRACE_DIRECT
samples/Makefile +1 -0
@@ -33,3 +33,4 @@ subdir-$(CONFIG_SAMPLE_WATCHDOG) += watchdog subdir-$(CONFIG_SAMPLE_WATCH_QUEUE) += watch_queue obj-$(CONFIG_DEBUG_KMEMLEAK_TEST) += kmemleak/ obj-$(CONFIG_SAMPLE_CORESIGHT_SYSCFG) += coresight/ +obj-$(CONFIG_SAMPLES_RUST) += rust/
samples/rust/Kconfig new file +130 -0
130 lines not on this page · raw message
samples/rust/Makefile new file +15 -0
@@ -0,0 +1,15 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_SAMPLE_RUST_MINIMAL) += rust_minimal.o +obj-$(CONFIG_SAMPLE_RUST_PRINT) += rust_print.o +obj-$(CONFIG_SAMPLE_RUST_MODULE_PARAMETERS) += rust_module_parameters.o +obj-$(CONFIG_SAMPLE_RUST_SYNC) += rust_sync.o +obj-$(CONFIG_SAMPLE_RUST_CHRDEV) += rust_chrdev.o +obj-$(CONFIG_SAMPLE_RUST_MISCDEV) += rust_miscdev.o +obj-$(CONFIG_SAMPLE_RUST_STACK_PROBING) += rust_stack_probing.o +obj-$(CONFIG_SAMPLE_RUST_SEMAPHORE) += rust_semaphore.o +obj-$(CONFIG_SAMPLE_RUST_SEMAPHORE_C) += rust_semaphore_c.o +obj-$(CONFIG_SAMPLE_RUST_RANDOM) += rust_random.o +obj-$(CONFIG_SAMPLE_RUST_PLATFORM) += rust_platform.o + +subdir-$(CONFIG_SAMPLE_RUST_HOSTPROGS) += hostprogs
samples/rust/hostprogs/.gitignore new file +3 -0
@@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0 + +single
samples/rust/hostprogs/Makefile new file +5 -0
@@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0 + +hostprogs-always-y := single + +single-rust := y
samples/rust/hostprogs/a.rs new file +7 -0
@@ -0,0 +1,7 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Rust single host program sample: module `a`. + +pub (crate )fn f (x:i32 ) { +println! ("The number is {}." , x); +}
samples/rust/hostprogs/b.rs new file +5 -0
@@ -0,0 +1,5 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Rust single host program sample: module `b`. + +pub (crate )const CONSTANT :i32 =42 ;
samples/rust/hostprogs/single.rs new file +12 -0
@@ -0,0 +1,12 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Rust single host program sample. + +mod a; +mod b; + +fn main () { +println! ("Hello world!" ); + + a::f (b::CONSTANT ); +}
samples/rust/rust_chrdev.rs new file +50 -0
50 lines not on this page · raw message
samples/rust/rust_minimal.rs new file +35 -0
@@ -0,0 +1,35 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Rust minimal sample. + +use kernel::prelude::*; + +module! { +type :RustMinimal , +name :b"rust_minimal" , + author:b"Rust for Linux Contributors" , + description:b"Rust minimal sample" , + license:b"GPL v2" , +} + +struct RustMinimal { + message:String , +} + +impl KernelModule for RustMinimal { +fn init (_name: &'staticCStr , _module: &'staticThisModule ) ->Result <Self > { +pr_info! ("Rust minimal sample (init)\n" ); +pr_info! ("Am I built-in? {}\n" , !cfg! (MODULE )); + +Ok (RustMinimal { + message:"on the heap!" .try_to_owned ()?, + }) + } +} + +impl Drop for RustMinimal { +fn drop (&mut self) { +pr_info! ("My message is {}\n" , self.message); +pr_info! ("Rust minimal sample (exit)\n" ); + } +}
samples/rust/rust_miscdev.rs new file +143 -0
143 lines not on this page · raw message
samples/rust/rust_module_parameters.rs new file +69 -0
69 lines not on this page · raw message
samples/rust/rust_platform.rs new file +22 -0
@@ -0,0 +1,22 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Rust platform device driver sample. + +use kernel::{module_platform_driver, of, platform, prelude::*}; + +module_platform_driver! { +type :Driver , +name :b"rust_platform" , + license:b"GPL v2" , +} + +struct Driver ; +impl platform::Driver for Driver { + kernel::define_of_id_table! {(), [ + (of::DeviceId ::Compatible (b"rust,sample" ),None ), + ]} + +fn probe (_dev: &mut platform::Device , _id_info:Option <&Self ::IdInfo >) ->Result { +Ok (()) + } +}
samples/rust/rust_print.rs new file +54 -0
54 lines not on this page · raw message
samples/rust/rust_random.rs new file +60 -0
60 lines not on this page · raw message
samples/rust/rust_semaphore.rs new file +171 -0
171 lines not on this page · raw message
samples/rust/rust_semaphore_c.c new file +212 -0
212 lines not on this page · raw message
samples/rust/rust_stack_probing.rs new file +36 -0
@@ -0,0 +1,36 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Rust stack probing sample. + +use kernel::prelude::*; + +module! { +type :RustStackProbing , +name :b"rust_stack_probing" , + author:b"Rust for Linux Contributors" , + description:b"Rust stack probing sample" , + license:b"GPL v2" , +} + +struct RustStackProbing ; + +impl KernelModule for RustStackProbing { +fn init (_name: &'staticCStr , _module: &'staticThisModule ) ->Result <Self > { +pr_info! ("Rust stack probing sample (init)\n" ); + +// Including this large variable on the stack will trigger +// stack probing on the supported archs. +// This will verify that stack probing does not lead to +// any errors if we need to link `__rust_probestack`. +let x: [u64 ;514 ] = core::hint::black_box ([5 ;514 ]); +pr_info! ("Large array has length: {}\n" , x.len ()); + +Ok (RustStackProbing ) + } +} + +impl Drop for RustStackProbing { +fn drop (&mut self) { +pr_info! ("Rust stack probing sample (exit)\n" ); + } +}
samples/rust/rust_sync.rs new file +93 -0
93 lines not on this page · raw message
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerPATCH v5 18/20 MAINTAINERS: Rust
In reply to Miguel OjedaMiguel, Alex and Wedson will be maintaining the Rust support.
--- MAINTAINERS | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
MAINTAINERS +15 -0
@@ -16809,6 +16809,21 @@ L: [email protected] S: Maintained F: drivers/infiniband/ulp/rtrs/ +RUST +M: Miguel Ojeda <[email protected]> +M: Alex Gaynor <[email protected]> +M: Wedson Almeida Filho <[email protected]> +L: [email protected] +S: Supported +W: https://github.com/Rust-for-Linux/linux +B: https://github.com/Rust-for-Linux/linux/issues +T: git https://github.com/Rust-for-Linux/linux.git rust-next +F: rust/ +F: samples/rust/ +F: Documentation/rust/ +F: scripts/*rust* +K: \b(?i:rust)\b + RXRPC SOCKETS (AF_RXRPC) M: David Howells <[email protected]> M: Marc Dionne <[email protected]>
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerRFC PATCH v5 19/20 drivers: gpio: PrimeCell PL061 in Rust
In reply to Miguel OjedaFrom: Wedson Almeida Filho <[email protected]>
A port to Rust of the PrimeCell PL061 GPIO driver.
This module is a work in progress and will be sent for review later on, as well as separately from the Rust support.
However, it is included to show how an actual working module written in Rust may look like.
--- drivers/gpio/Kconfig | 8 + drivers/gpio/Makefile | 1 + drivers/gpio/gpio_pl061_rust.rs | 370 ++++++++++++++++++++++++++++++++ 3 files changed, 379 insertions(+) create mode 100644 drivers/gpio/gpio_pl061_rust.rs
drivers/gpio/Kconfig +8 -0
@@ -471,6 +471,14 @@ config GPIO_PL061 help Say yes here to support the PrimeCell PL061 GPIO device. +config GPIO_PL061_RUST + tristate "PrimeCell PL061 GPIO support written in Rust" + depends on ARM_AMBA && RUST + select IRQ_DOMAIN + select GPIOLIB_IRQCHIP + help + Say yes here to support the PrimeCell PL061 GPIO device + config GPIO_PMIC_EIC_SPRD tristate "Spreadtrum PMIC EIC support" depends on MFD_SC27XX_PMIC || COMPILE_TEST
drivers/gpio/Makefile +1 -0
@@ -117,6 +117,7 @@ obj-$(CONFIG_GPIO_PCIE_IDIO_24) += gpio-pcie-idio-24.o obj-$(CONFIG_GPIO_PCI_IDIO_16) += gpio-pci-idio-16.o obj-$(CONFIG_GPIO_PISOSR) += gpio-pisosr.o obj-$(CONFIG_GPIO_PL061) += gpio-pl061.o +obj-$(CONFIG_GPIO_PL061_RUST) += gpio_pl061_rust.o obj-$(CONFIG_GPIO_PMIC_EIC_SPRD) += gpio-pmic-eic-sprd.o obj-$(CONFIG_GPIO_PXA) += gpio-pxa.o obj-$(CONFIG_GPIO_RASPBERRYPI_EXP) += gpio-raspberrypi-exp.o
drivers/gpio/gpio_pl061_rust.rs new file +370 -0
370 lines not on this page · raw message
Signature · 1 line
2.35.1
Miguel Ojeda
maintainerRFC PATCH v5 20/20 drivers: android: Binder IPC in Rust
In reply to Miguel OjedaFrom: Wedson Almeida Filho <[email protected]>
A port to Rust of the Android Binder IPC mechanism.
This module is a work in progress and will be sent for review later on, as well as separately from the Rust support.
However, it is included to show how an actual working module written in Rust may look like.
--- drivers/android/Kconfig | 6 + drivers/android/Makefile | 2 + drivers/android/allocation.rs | 266 ++++++++ drivers/android/context.rs | 80 +++ drivers/android/defs.rs | 99 +++ drivers/android/node.rs | 476 ++++++++++++++ drivers/android/process.rs | 960 ++++++++++++++++++++++++++++ drivers/android/range_alloc.rs | 189 ++++++ drivers/android/rust_binder.rs | 111 ++++ drivers/android/thread.rs | 870 +++++++++++++++++++++++++ drivers/android/transaction.rs | 326 ++++++++++ include/uapi/linux/android/binder.h | 28 +- 12 files changed, 3400 insertions(+), 13 deletions(-) create mode 100644 drivers/android/allocation.rs create mode 100644 drivers/android/context.rs create mode 100644 drivers/android/defs.rs create mode 100644 drivers/android/node.rs create mode 100644 drivers/android/process.rs create mode 100644 drivers/android/range_alloc.rs create mode 100644 drivers/android/rust_binder.rs create mode 100644 drivers/android/thread.rs create mode 100644 drivers/android/transaction.rs
drivers/android/Kconfig +6 -0
@@ -20,6 +20,12 @@ config ANDROID_BINDER_IPC Android process, using Binder to identify, invoke and pass arguments between said processes. +config ANDROID_BINDER_IPC_RUST + bool "Android Binder IPC Driver in Rust" + depends on MMU && RUST + help + Implementation of the Binder IPC in Rust. + config ANDROID_BINDERFS bool "Android Binderfs filesystem" depends on ANDROID_BINDER_IPC
drivers/android/Makefile +2 -0
@@ -4,3 +4,5 @@ ccflags-y += -I$(src) # needed for trace events obj-$(CONFIG_ANDROID_BINDERFS) += binderfs.o obj-$(CONFIG_ANDROID_BINDER_IPC) += binder.o binder_alloc.o obj-$(CONFIG_ANDROID_BINDER_IPC_SELFTEST) += binder_alloc_selftest.o + +obj-$(CONFIG_ANDROID_BINDER_IPC_RUST) += rust_binder.o
drivers/android/allocation.rs new file +266 -0
266 lines not on this page · raw message
drivers/android/context.rs new file +80 -0
80 lines not on this page · raw message
drivers/android/defs.rs new file +99 -0
99 lines not on this page · raw message
drivers/android/node.rs new file +476 -0
476 lines not on this page · raw message
drivers/android/process.rs new file +960 -0
960 lines not on this page · raw message
drivers/android/range_alloc.rs new file +189 -0
189 lines not on this page · raw message
drivers/android/rust_binder.rs new file +111 -0
111 lines not on this page · raw message
drivers/android/thread.rs new file +870 -0
802 lines not on this page · raw message
drivers/android/transaction.rs new file +326 -0
326 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
2.35.1
Part of the diff is not shown here. View the raw message.