* [PATCH v8 00/31] Rust support
@ 2022-08-02 1:49 Miguel Ojeda
2022-08-02 1:50 ` [PATCH v8 30/31] [RFC] drivers: gpio: PrimeCell PL061 in Rust Miguel Ojeda
2022-08-02 12:26 ` [PATCH v8 00/31] Rust support Matthew Wilcox
0 siblings, 2 replies; 9+ messages in thread
From: Miguel Ojeda @ 2022-08-02 1:49 UTC (permalink / raw)
To: Linus Torvalds, Greg Kroah-Hartman
Cc: rust-for-linux, linux-kernel, Jarkko Sakkinen, Miguel Ojeda,
linux-arm-kernel, linux-doc, linux-gpio, linux-kbuild,
linux-perf-users, linuxppc-dev, linux-riscv, linux-um,
live-patching
Rust support
This is the patch series (v8) 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:
rust-for-linux@vger.kernel.org
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/20210414184604.23473-1-ojeda@kernel.org/
v1: https://lore.kernel.org/lkml/20210704202756.29107-1-ojeda@kernel.org/
v2: https://lore.kernel.org/lkml/20211206140313.5653-1-ojeda@kernel.org/
v3: https://lore.kernel.org/lkml/20220117053349.6804-1-ojeda@kernel.org/
v4: https://lore.kernel.org/lkml/20220212130410.6901-1-ojeda@kernel.org/
v5: https://lore.kernel.org/lkml/20220317181032.15436-1-ojeda@kernel.org/
v6: https://lore.kernel.org/lkml/20220507052451.12890-1-ojeda@kernel.org/
v7: https://lore.kernel.org/lkml/20220523020209.11810-1-ojeda@kernel.org/
## Infrastructure updates
There have been several improvements to the overall Rust support:
- Upgraded toolchain and `alloc` to Rust 1.62.0 from 1.60.0.
Rust 1.61.0 stabilized `feature(const_fn_trait_bound)` that
we are using.
- Moved bindings into their own crate, `bindings`. This greatly
improves build time when only the `kernel` crate changes (which
previously contained the bindings).
- Disabled unused `bindgen`'s layout test generation, which makes
rust-analyzer significantly faster to run.
- `bindgen` can now be detected via the `__BINDGEN__` macro, which
we currently use to workaround an issue with the `btf_type_tag`
attribute.
- Reimplemented `concat_idents!` (an unstable standard library
macro) as a proc macro, which means we no longer rely on
`feature(concat_idents)`. Furthermore, the proc macro allows
to refer to local variables.
- Reimplemented `static_assert!` in a more idiomatic way, now that
`core::assert!()` is supported in const contexts.
- Made `build_error!`' work under `RUST_BUILD_ASSERT_{WARN,ALLOW}`
for modules.
- Removed `__mulodi4` panicking stub.
- Added `kernel/configs/rust.config`.
- Added a (temporary) self-test module for "pure" Rust tests.
- Changed `.i` macro expanded files to the `.rsi` extension and
clarified that they are not intended to be compilable.
- Dropped support for compiling the Rust side with a different
optimization level than the C side.
- The Linux/Tux SVG logo (recently upstreamed) is used for
the generated Rust documentation, instead of the GIF one.
The `COPYING-logo` file is bundled too.
- Other cleanups, fixes and improvements.
## Abstractions and driver updates
Some of the improvements to the abstractions and example drivers are:
- Filesystem support (`fs` module), including:
+ `INode` type (which wraps `struct inode`).
+ `DEntry` type (which wraps `struct dentry`).
+ `Filename` type (which wraps `struct filename`).
+ `Registration` type.
+ `Type` and `Context` traits.
+ `SuperBlock` type (which wraps `struct super_block` and takes
advantage of typestates for its initialization).
+ File system parameters support (with a `Value` enum; `Spec*`
and `Constant*` types, `define_fs_params!` macro...).
+ File system flags.
+ `module_fs!` macro to simplify registering kernel modules that
only implement a single file system.
+ A file system sample.
- Workqueues support (`workqueue` module), including a `Work` type
(which wraps `struct work_struct`), a `Queue` type (which wraps
`struct workqueue_struct`), access to different system queues as
well as macros to simplify usage, e.g.:
spawn_work_item!(workqueue::system(), || pr_info!("Hi!\n"))?;
- More asynchronous support (`kasync` module), including:
+ Executor support (including `Task` and `Executor` traits, a
`AutoStopHandle` type that automatically stops the executor on
drop, a `spawn_task!` macro that automatically defines a new
lockdep lock class...).
+ A workqueue-based executor, which allows to run tasks on
dedicated or shared thread pools that are managed by existing
C kernel infrastructure, e.g.:
let mut handle = Executor::try_new(workqueue::system())?;
spawn_task!(handle.executor(), async {
pr_info!("First workqueue task\n");
})?;
spawn_task!(handle.executor(), async {
pr_info!("Second workqueue task\n");
})?;
handle.detach();
+ A `yield_now()` function that yields execution of the current
task so that other ones may execute (but keeps it runnable so
that it will run again as soon as the executor is available
again), e.g.:
async fn example() {
pr_info!("Before yield\n");
yield_now().await;
pr_info!("After yield\n");
}
+ `AsyncRevocable` type (in the `revocable` module), which
allows access to objects to be revoked without having to wait
for existing users to complete. This is useful to drop futures
in tasks when executors are being torn down.
+ An asynchronous TCP echo server sample.
- Introduced support for handling interrupts: `[Threaded]Handler`
traits, `[Threaded]Registration` types, a `Return` enum (as the
return value from handlers) and flags:
struct Example;
impl irq::Handler for Example {
type Data = Box<u32>;
fn handle_irq(_data: &u32) -> irq::Return {
irq::Return::None
}
}
fn request_irq(irq: u32, data: Box<u32>)
-> Result<irq::Registration<Example>> {
irq::Registration::try_new(
irq, data, irq::flags::SHARED,
fmt!("example_{irq}")
)
}
- Introduced the `#[vtable]` proc macro attribute to simplify how
function pointer tables like `struct file_operations` are used
by Rust kernel modules.
Previously, users had to call a `declare_*_operations!` macro
which required passing the defined operations:
impl file::Operations for SomeFile {
...
declare_file_operations!(read, write, ioctl, ...);
...
}
Instead, now it is only required that they annotate the `impl`
block with the attribute:
#[vtable]
impl file::Operations for SomeFile {
...
}
The proc macro will generate a boolean `HAS_*` associated constant
for each method in the trait, indicating if the implementer has
overridden a method.
- Added `unsafe_list::List`, an intrusive circular doubly-linked
list, meant to be used as the basis for other linked lists.
It is also used in the workqueue-based executor to keep track of
all tasks since it is cheaper than other options.
- Initial RCU support: a `Guard` type that represents evidence that
the RCU read side lock is held on the current thread/CPU.
In addition, `Revocable` now uses this new abstraction so that
users can provide evidence of the RCU read side lock being held
when accessing the protected object, e.g.:
fn add_pair(value: &Revocable<(u32, u32)>) -> Option<u32> {
let guard = rcu::read_lock();
let pair = value.try_access_with_guard(&guard)?;
Some(pair.0 + pair.1)
}
- Added `StaticRef` which allows the creation of "reference-counted"
globals; i.e. allows to define static variables that can be used
when `Ref<T>` or `RefBorrow<'_, T>` are expected.
This, in turn, allows to have functions that return shared
resources (e.g. a global workqueue) without allocations (the
shared object is statically allocated).
- Added `Task::spawn()` function to create and automatically run
kernel threads easily, e.g.:
for i in 0..10 {
Task::spawn(fmt!("test{i}"), threadfn).unwrap();
}
- Added `Task::wake_up()` method.
- Converted `Task` to use `ARef` to unify the usage of all
ref-counted C structures.
- Initial support for delays/sleeps (`delay` module) with a basic
`coarse_sleep()` function that wraps the C side `msleep()` and
takes advantage of the `Duration` standard library type:
coarse_sleep(Duration::from_millis(20));
- Added file flags (to further reduce `bindings::*` usage), e.g.:
let blocking = (file.flags() & file::flags::O_NONBLOCK) == 0;
- Added `gpio_chip_register!` and `gpio_irq_chip_register!` macros
which automatically define the required lock classes.
- Removal of `bindings::lock_class_key` from drivers. This gets us
closer to eventually make bindings private to the `kernel` crate.
- Moved usage of `ManuallyDrop` to `MaybeUninit` in `Revocable`,
which was unsound.
- Other cleanups, fixes and improvements.
## Patch series updates
The patch series has been reorganized a bit since last time:
- The `include/linux/` changes for the C helpers have been moved
into their own small patches, which can be taken independently
as prerequisite patches if needed.
- Now that the bindings are in their own `bindings` crate,
they also get their own patch.
- There is a new patch that adds the `kernel/configs/rust.config`.
- One of the `kallsyms` patches has been split into three smaller
ones.
- Cleaned up some "exceeds 100 columns" `checkpatch.pl` warnings.
With this final cleanup, the remaining warnings (of all kinds)
are either false positives, or cannot be changed without diverging
with upstream `alloc` or would make things look worse.
## 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 will appear in the next `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
## Conferences, meetings and liaisons
Join us in LPC 2022 (Linux Plumbers Conference) for the Rust MC
(microconference)! The schedule is available at:
https://lpc.events/event/16/sessions/150/
We will be talking about GCC Rust (the Rust frontend for GCC),
`rustc_codegen_gcc` (the GCC backend for `rustc`), Rust for Linux,
the Rust NVMe driver, the integration of Rust with the Kernel Testing
Service and Rust in the Kernel (via eBPF).
In addition, I would like to personally thank Google and ISRG
(Internet Security Research Group) for sponsoring Kangrejos,
the Rust for Linux workshop:
https://kangrejos.com
Furthermore, we would like to thank the venues we were invited to:
- Linux Foundation Live Mentorship Series
- Open Source Summit North America
- Huawei Global Software Technology Summit
## Related news
The GCC Steering Committee accepted the contribution of the Rust
frontend (GCC Rust). Its first released version (experimental,
disabled by default) should appear in GCC 13. The first round of
patches has been posted to the gcc-patches mailing list.
`rustc_codegen_gcc` (the GCC backend for `rustc`) has seen enough
progress on SIMD support to compile `stdarch`. In addition, more
prerequisite patches are making their way into GCC.
## 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:
- Nick Desaulniers, Joe Perches, Masahiro Yamada and Jarkko Sakkinen
for their reviews of some of the v7 patches.
- Daniel Latypov, Brendan Higgins and Shuah Khan for picking up
the KUnit prerequisite patch.
- As usual, Björn Roy Baron (bjorn3) and Gary Guo for all the input
on Rust compiler details, reviews and suggestions.
- Andreas Hindborg for working on the NVMe driver, as well as
adding atomic allocations for `Box` and allowing to use GFP flags
for `KernelAllocator`.
- Li Hongyu for working on a virtio abstraction.
- Boqun Feng for working on adding an alloc alignment test.
- Andreas Reindl for working on adding missing `SAFETY` comments.
- Anhad Singh for working on adding the `new_with_flags` method
to `Pages`.
- Finn Behrens for working on making it possible to compile
the kernel on macOS with Rust enabled.
- Roel Kluin for working on code refactorings.
- Wei Liu for taking the time to answer questions from newcomers
in Zulip.
- Philip Li, Yujie Liu et al. for continuing their work on adding
Rust support to the Intel 0DAY/LKP kernel test robot.
- Philip Herron and Arthur Cohen (and his supporters Open Source
Security and Embecosm) et al. for their ongoing work on GCC Rust.
- Antoni Boucher (and his supporters) et al. for their ongoing
work on `rustc_codegen_gcc`.
- Emilio Cobos Álvarez et. al. for their work on `bindgen`,
including on issues that affect the kernel.
- 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 (2):
kallsyms: use `sizeof` instead of hardcoded size
kallsyms: avoid hardcoding buffer size
Gary Guo (2):
rust: add `build_error` crate
vsprintf: add new `%pA` format specifier
Miguel Ojeda (19):
kallsyms: add static relationship between `KSYM_NAME_LEN{,_BUFFER}`
kallsyms: support "big" kernel symbols
kallsyms: increase maximum kernel symbol length to 512
rust: add C helpers
rust: add `compiler_builtins` crate
rust: import upstream `alloc` crate
rust: adapt `alloc` crate to the kernel
rust: add `macros` crate
rust: add `bindings` crate
rust: export generated symbols
scripts: checkpatch: diagnose uses of `%pA` in the C side as errors
scripts: checkpatch: enable language-independent checks for Rust
scripts: add `rustdoc_test_{builder,gen}.py` scripts
scripts: add `generate_rust_analyzer.py` scripts
scripts: decode_stacktrace: demangle Rust symbols
docs: add Rust documentation
Kbuild: add Rust support
samples: add Rust examples
MAINTAINERS: Rust
Wedson Almeida Filho (8):
workqueue: introduce `__INIT_WORK_WITH_KEY`
locking/spinlock: introduce `__spin_lock_init`
locking/spinlock: introduce `_raw_spin_lock_init`
rust: add `kernel` crate's `sync` module
rust: add `kernel` crate
configs: add `rust` config
[RFC] drivers: gpio: PrimeCell PL061 in Rust
[RFC] drivers: android: Binder IPC in Rust
.gitignore | 6 +
.rustfmt.toml | 12 +
Documentation/core-api/printk-formats.rst | 10 +
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 | 23 +
Documentation/rust/coding-guidelines.rst | 216 ++
Documentation/rust/general-information.rst | 79 +
Documentation/rust/index.rst | 22 +
Documentation/rust/quick-start.rst | 232 ++
MAINTAINERS | 15 +
Makefile | 172 +-
arch/Kconfig | 6 +
arch/arm/Kconfig | 1 +
arch/arm64/Kconfig | 1 +
arch/powerpc/Kconfig | 1 +
arch/riscv/Kconfig | 1 +
arch/riscv/Makefile | 5 +
arch/um/Kconfig | 1 +
arch/x86/Kconfig | 1 +
arch/x86/Makefile | 10 +
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 | 961 +++++
drivers/android/range_alloc.rs | 189 +
drivers/android/rust_binder.rs | 106 +
drivers/android/thread.rs | 871 +++++
drivers/android/transaction.rs | 326 ++
drivers/gpio/Kconfig | 8 +
drivers/gpio/Makefile | 1 +
drivers/gpio/gpio_pl061_rust.rs | 367 ++
include/linux/compiler_types.h | 6 +-
include/linux/kallsyms.h | 2 +-
include/linux/spinlock.h | 17 +-
include/linux/workqueue.h | 21 +-
include/uapi/linux/android/binder.h | 30 +-
init/Kconfig | 46 +-
kernel/configs/rust.config | 1 +
kernel/kallsyms.c | 26 +-
kernel/livepatch/core.c | 4 +-
lib/Kconfig.debug | 82 +
lib/vsprintf.c | 13 +
rust/.gitignore | 10 +
rust/Makefile | 415 +++
rust/alloc/README.md | 33 +
rust/alloc/alloc.rs | 440 +++
rust/alloc/borrow.rs | 498 +++
rust/alloc/boxed.rs | 2026 +++++++++++
rust/alloc/boxed/thin.rs | 219 ++
rust/alloc/collections/mod.rs | 156 +
rust/alloc/ffi/c_str.rs | 1203 ++++++
rust/alloc/ffi/mod.rs | 93 +
rust/alloc/fmt.rs | 614 ++++
rust/alloc/lib.rs | 239 ++
rust/alloc/macros.rs | 128 +
rust/alloc/raw_vec.rs | 567 +++
rust/alloc/slice.rs | 1295 +++++++
rust/alloc/str.rs | 641 ++++
rust/alloc/string.rs | 2944 +++++++++++++++
rust/alloc/vec/drain.rs | 186 +
rust/alloc/vec/drain_filter.rs | 145 +
rust/alloc/vec/into_iter.rs | 365 ++
rust/alloc/vec/is_zero.rs | 120 +
rust/alloc/vec/mod.rs | 3420 ++++++++++++++++++
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 | 21 +
rust/bindings/bindings_helper.h | 49 +
rust/bindings/lib.rs | 57 +
rust/build_error.rs | 29 +
rust/compiler_builtins.rs | 79 +
rust/exports.c | 21 +
rust/helpers.c | 679 ++++
rust/kernel/allocator.rs | 64 +
rust/kernel/amba.rs | 261 ++
rust/kernel/build_assert.rs | 83 +
rust/kernel/chrdev.rs | 206 ++
rust/kernel/clk.rs | 79 +
rust/kernel/cred.rs | 46 +
rust/kernel/delay.rs | 104 +
rust/kernel/device.rs | 527 +++
rust/kernel/driver.rs | 442 +++
rust/kernel/error.rs | 564 +++
rust/kernel/file.rs | 887 +++++
rust/kernel/fs.rs | 846 +++++
rust/kernel/fs/param.rs | 553 +++
rust/kernel/gpio.rs | 505 +++
rust/kernel/hwrng.rs | 210 ++
rust/kernel/io_buffer.rs | 153 +
rust/kernel/io_mem.rs | 278 ++
rust/kernel/iov_iter.rs | 81 +
rust/kernel/irq.rs | 681 ++++
rust/kernel/kasync.rs | 50 +
rust/kernel/kasync/executor.rs | 154 +
rust/kernel/kasync/executor/workqueue.rs | 291 ++
rust/kernel/kasync/net.rs | 322 ++
rust/kernel/kunit.rs | 91 +
rust/kernel/lib.rs | 267 ++
rust/kernel/linked_list.rs | 247 ++
rust/kernel/miscdev.rs | 290 ++
rust/kernel/mm.rs | 149 +
rust/kernel/module_param.rs | 499 +++
rust/kernel/net.rs | 392 ++
rust/kernel/net/filter.rs | 447 +++
rust/kernel/of.rs | 63 +
rust/kernel/pages.rs | 144 +
rust/kernel/platform.rs | 223 ++
rust/kernel/power.rs | 118 +
rust/kernel/prelude.rs | 36 +
rust/kernel/print.rs | 406 +++
rust/kernel/random.rs | 42 +
rust/kernel/raw_list.rs | 361 ++
rust/kernel/rbtree.rs | 563 +++
rust/kernel/revocable.rs | 425 +++
rust/kernel/security.rs | 38 +
rust/kernel/static_assert.rs | 34 +
rust/kernel/std_vendor.rs | 161 +
rust/kernel/str.rs | 597 +++
rust/kernel/sync.rs | 169 +
rust/kernel/sync/arc.rs | 582 +++
rust/kernel/sync/condvar.rs | 140 +
rust/kernel/sync/guard.rs | 159 +
rust/kernel/sync/locked_by.rs | 111 +
rust/kernel/sync/mutex.rs | 149 +
rust/kernel/sync/nowait.rs | 188 +
rust/kernel/sync/rcu.rs | 52 +
rust/kernel/sync/revocable.rs | 246 ++
rust/kernel/sync/rwsem.rs | 196 +
rust/kernel/sync/seqlock.rs | 201 +
rust/kernel/sync/smutex.rs | 290 ++
rust/kernel/sync/spinlock.rs | 357 ++
rust/kernel/sysctl.rs | 199 +
rust/kernel/task.rs | 239 ++
rust/kernel/types.rs | 705 ++++
rust/kernel/unsafe_list.rs | 680 ++++
rust/kernel/user_ptr.rs | 175 +
rust/kernel/workqueue.rs | 512 +++
rust/macros/concat_idents.rs | 23 +
rust/macros/helpers.rs | 79 +
rust/macros/lib.rs | 191 +
rust/macros/module.rs | 655 ++++
rust/macros/vtable.rs | 95 +
samples/Kconfig | 2 +
samples/Makefile | 1 +
samples/rust/Kconfig | 165 +
samples/rust/Makefile | 19 +
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 | 49 +
samples/rust/rust_echo_server.rs | 60 +
samples/rust/rust_fs.rs | 59 +
samples/rust/rust_minimal.rs | 35 +
samples/rust/rust_miscdev.rs | 142 +
samples/rust/rust_module_parameters.rs | 69 +
samples/rust/rust_netfilter.rs | 54 +
samples/rust/rust_platform.rs | 22 +
samples/rust/rust_print.rs | 54 +
samples/rust/rust_random.rs | 60 +
samples/rust/rust_selftests.rs | 99 +
samples/rust/rust_semaphore.rs | 170 +
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/checkpatch.pl | 12 +-
scripts/decode_stacktrace.sh | 14 +
scripts/generate_rust_analyzer.py | 141 +
scripts/generate_rust_target.rs | 232 ++
scripts/is_rust_module.sh | 16 +
scripts/kallsyms.c | 47 +-
scripts/kconfig/confdata.c | 75 +
scripts/min-tool-version.sh | 6 +
scripts/rust-is-available-bindgen-libclang.h | 2 +
scripts/rust-is-available.sh | 160 +
scripts/rustdoc_test_builder.py | 59 +
scripts/rustdoc_test_gen.py | 164 +
tools/include/linux/kallsyms.h | 2 +-
tools/lib/perf/include/perf/event.h | 2 +-
tools/lib/symbol/kallsyms.h | 2 +-
198 files changed, 43688 insertions(+), 75 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/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 kernel/configs/rust.config
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/boxed/thin.rs
create mode 100644 rust/alloc/collections/mod.rs
create mode 100644 rust/alloc/ffi/c_str.rs
create mode 100644 rust/alloc/ffi/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/bindings/bindings_helper.h
create mode 100644 rust/bindings/lib.rs
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/build_assert.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/delay.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/fs.rs
create mode 100644 rust/kernel/fs/param.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/kasync.rs
create mode 100644 rust/kernel/kasync/executor.rs
create mode 100644 rust/kernel/kasync/executor/workqueue.rs
create mode 100644 rust/kernel/kasync/net.rs
create mode 100644 rust/kernel/kunit.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/net.rs
create mode 100644 rust/kernel/net/filter.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.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/mutex.rs
create mode 100644 rust/kernel/sync/nowait.rs
create mode 100644 rust/kernel/sync/rcu.rs
create mode 100644 rust/kernel/sync/revocable.rs
create mode 100644 rust/kernel/sync/rwsem.rs
create mode 100644 rust/kernel/sync/seqlock.rs
create mode 100644 rust/kernel/sync/smutex.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/unsafe_list.rs
create mode 100644 rust/kernel/user_ptr.rs
create mode 100644 rust/kernel/workqueue.rs
create mode 100644 rust/macros/concat_idents.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 rust/macros/vtable.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_echo_server.rs
create mode 100644 samples/rust/rust_fs.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_netfilter.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_selftests.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
create mode 100755 scripts/rustdoc_test_builder.py
create mode 100755 scripts/rustdoc_test_gen.py
base-commit: 3d7cb6b04c3f3115719235cc6866b10326de34cd
--
2.37.1
^ permalink raw reply [flat|nested] 9+ messages in thread* [PATCH v8 30/31] [RFC] drivers: gpio: PrimeCell PL061 in Rust 2022-08-02 1:49 [PATCH v8 00/31] Rust support Miguel Ojeda @ 2022-08-02 1:50 ` Miguel Ojeda 2022-08-02 12:26 ` [PATCH v8 00/31] Rust support Matthew Wilcox 1 sibling, 0 replies; 9+ messages in thread From: Miguel Ojeda @ 2022-08-02 1:50 UTC (permalink / raw) To: Linus Torvalds, Greg Kroah-Hartman Cc: rust-for-linux, linux-kernel, Jarkko Sakkinen, Miguel Ojeda, Wedson Almeida Filho, Gary Guo, Linus Walleij, Bartosz Golaszewski, linux-gpio From: Wedson Almeida Filho <wedsonaf@google.com> 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. Co-developed-by: Gary Guo <gary@garyguo.net> Signed-off-by: Gary Guo <gary@garyguo.net> Signed-off-by: Wedson Almeida Filho <wedsonaf@google.com> Co-developed-by: Miguel Ojeda <ojeda@kernel.org> Signed-off-by: Miguel Ojeda <ojeda@kernel.org> --- drivers/gpio/Kconfig | 8 + drivers/gpio/Makefile | 1 + drivers/gpio/gpio_pl061_rust.rs | 367 ++++++++++++++++++++++++++++++++ 3 files changed, 376 insertions(+) create mode 100644 drivers/gpio/gpio_pl061_rust.rs diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig index b01961999ced..bf942f8e9a60 100644 --- a/drivers/gpio/Kconfig +++ b/drivers/gpio/Kconfig @@ -482,6 +482,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 diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile index 14352f6dfe8e..30141fec12be 100644 --- a/drivers/gpio/Makefile +++ b/drivers/gpio/Makefile @@ -118,6 +118,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 diff --git a/drivers/gpio/gpio_pl061_rust.rs b/drivers/gpio/gpio_pl061_rust.rs new file mode 100644 index 000000000000..d417fa3b0abc --- /dev/null +++ b/drivers/gpio/gpio_pl061_rust.rs @@ -0,0 +1,367 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Driver for the ARM PrimeCell(tm) General Purpose Input/Output (PL061). +//! +//! Based on the C driver written by Baruch Siach <baruch@tkos.co.il>. + +use kernel::{ + amba, bit, bits_iter, define_amba_id_table, device, gpio, + io_mem::IoMem, + irq::{self, ExtraResult, IrqData, LockedIrqData}, + power, + prelude::*, + sync::{RawSpinLock, Ref, RefBorrow}, +}; + +const GPIODIR: usize = 0x400; +const GPIOIS: usize = 0x404; +const GPIOIBE: usize = 0x408; +const GPIOIEV: usize = 0x40C; +const GPIOIE: usize = 0x410; +const GPIOMIS: usize = 0x418; +const GPIOIC: usize = 0x41C; +const GPIO_SIZE: usize = 0x1000; + +const PL061_GPIO_NR: u16 = 8; + +#[derive(Default)] +struct ContextSaveRegs { + gpio_data: u8, + gpio_dir: u8, + gpio_is: u8, + gpio_ibe: u8, + gpio_iev: u8, + gpio_ie: u8, +} + +#[derive(Default)] +struct PL061DataInner { + csave_regs: ContextSaveRegs, +} + +struct PL061Data { + dev: device::Device, + inner: RawSpinLock<PL061DataInner>, +} + +struct PL061Resources { + base: IoMem<GPIO_SIZE>, + parent_irq: u32, +} + +type PL061Registrations = gpio::RegistrationWithIrqChip<PL061Device>; + +type DeviceData = device::Data<PL061Registrations, PL061Resources, PL061Data>; + +struct PL061Device; + +#[vtable] +impl gpio::Chip for PL061Device { + type Data = Ref<DeviceData>; + + fn get_direction(data: RefBorrow<'_, DeviceData>, offset: u32) -> Result<gpio::LineDirection> { + let pl061 = data.resources().ok_or(ENXIO)?; + Ok(if pl061.base.readb(GPIODIR) & bit(offset) != 0 { + gpio::LineDirection::Out + } else { + gpio::LineDirection::In + }) + } + + fn direction_input(data: RefBorrow<'_, DeviceData>, offset: u32) -> Result { + let _guard = data.inner.lock_irqdisable(); + let pl061 = data.resources().ok_or(ENXIO)?; + let mut gpiodir = pl061.base.readb(GPIODIR); + gpiodir &= !bit(offset); + pl061.base.writeb(gpiodir, GPIODIR); + Ok(()) + } + + fn direction_output(data: RefBorrow<'_, DeviceData>, offset: u32, value: bool) -> Result { + let woffset = bit(offset + 2).into(); + let _guard = data.inner.lock_irqdisable(); + let pl061 = data.resources().ok_or(ENXIO)?; + pl061.base.try_writeb((value as u8) << offset, woffset)?; + let mut gpiodir = pl061.base.readb(GPIODIR); + gpiodir |= bit(offset); + pl061.base.writeb(gpiodir, GPIODIR); + + // gpio value is set again, because pl061 doesn't allow to set value of a gpio pin before + // configuring it in OUT mode. + pl061.base.try_writeb((value as u8) << offset, woffset)?; + Ok(()) + } + + fn get(data: RefBorrow<'_, DeviceData>, offset: u32) -> Result<bool> { + let pl061 = data.resources().ok_or(ENXIO)?; + Ok(pl061.base.try_readb(bit(offset + 2).into())? != 0) + } + + fn set(data: RefBorrow<'_, DeviceData>, offset: u32, value: bool) { + if let Some(pl061) = data.resources() { + let woffset = bit(offset + 2).into(); + let _ = pl061.base.try_writeb((value as u8) << offset, woffset); + } + } +} + +impl gpio::ChipWithIrqChip for PL061Device { + fn handle_irq_flow( + data: RefBorrow<'_, DeviceData>, + desc: &irq::Descriptor, + domain: &irq::Domain, + ) { + let chained = desc.enter_chained(); + + if let Some(pl061) = data.resources() { + let pending = pl061.base.readb(GPIOMIS); + for offset in bits_iter(pending) { + domain.generic_handle_chained(offset, &chained); + } + } + } +} + +#[vtable] +impl irq::Chip for PL061Device { + type Data = Ref<DeviceData>; + + fn set_type( + data: RefBorrow<'_, DeviceData>, + irq_data: &mut LockedIrqData, + trigger: u32, + ) -> Result<ExtraResult> { + let offset = irq_data.hwirq(); + let bit = bit(offset); + + if offset >= PL061_GPIO_NR.into() { + return Err(EINVAL); + } + + if trigger & (irq::Type::LEVEL_HIGH | irq::Type::LEVEL_LOW) != 0 + && trigger & (irq::Type::EDGE_RISING | irq::Type::EDGE_FALLING) != 0 + { + dev_err!( + data.dev, + "trying to configure line {} for both level and edge detection, choose one!\n", + offset + ); + return Err(EINVAL); + } + + let _guard = data.inner.lock_irqdisable(); + let pl061 = data.resources().ok_or(ENXIO)?; + + let mut gpioiev = pl061.base.readb(GPIOIEV); + let mut gpiois = pl061.base.readb(GPIOIS); + let mut gpioibe = pl061.base.readb(GPIOIBE); + + if trigger & (irq::Type::LEVEL_HIGH | irq::Type::LEVEL_LOW) != 0 { + let polarity = trigger & irq::Type::LEVEL_HIGH != 0; + + // Disable edge detection. + gpioibe &= !bit; + // Enable level detection. + gpiois |= bit; + // Select polarity. + if polarity { + gpioiev |= bit; + } else { + gpioiev &= !bit; + } + irq_data.set_level_handler(); + dev_dbg!( + data.dev, + "line {}: IRQ on {} level\n", + offset, + if polarity { "HIGH" } else { "LOW" } + ); + } else if (trigger & irq::Type::EDGE_BOTH) == irq::Type::EDGE_BOTH { + // Disable level detection. + gpiois &= !bit; + // Select both edges, settings this makes GPIOEV be ignored. + gpioibe |= bit; + irq_data.set_edge_handler(); + dev_dbg!(data.dev, "line {}: IRQ on both edges\n", offset); + } else if trigger & (irq::Type::EDGE_RISING | irq::Type::EDGE_FALLING) != 0 { + let rising = trigger & irq::Type::EDGE_RISING != 0; + + // Disable level detection. + gpiois &= !bit; + // Clear detection on both edges. + gpioibe &= !bit; + // Select edge. + if rising { + gpioiev |= bit; + } else { + gpioiev &= !bit; + } + irq_data.set_edge_handler(); + dev_dbg!( + data.dev, + "line {}: IRQ on {} edge\n", + offset, + if rising { "RISING" } else { "FALLING}" } + ); + } else { + // No trigger: disable everything. + gpiois &= !bit; + gpioibe &= !bit; + gpioiev &= !bit; + irq_data.set_bad_handler(); + dev_warn!(data.dev, "no trigger selected for line {}\n", offset); + } + + pl061.base.writeb(gpiois, GPIOIS); + pl061.base.writeb(gpioibe, GPIOIBE); + pl061.base.writeb(gpioiev, GPIOIEV); + + Ok(ExtraResult::None) + } + + fn mask(data: RefBorrow<'_, DeviceData>, irq_data: &IrqData) { + let mask = bit(irq_data.hwirq() % irq::HwNumber::from(PL061_GPIO_NR)); + let _guard = data.inner.lock(); + if let Some(pl061) = data.resources() { + let gpioie = pl061.base.readb(GPIOIE) & !mask; + pl061.base.writeb(gpioie, GPIOIE); + } + } + + fn unmask(data: RefBorrow<'_, DeviceData>, irq_data: &IrqData) { + let mask = bit(irq_data.hwirq() % irq::HwNumber::from(PL061_GPIO_NR)); + let _guard = data.inner.lock(); + if let Some(pl061) = data.resources() { + let gpioie = pl061.base.readb(GPIOIE) | mask; + pl061.base.writeb(gpioie, GPIOIE); + } + } + + // This gets called from the edge IRQ handler to ACK the edge IRQ in the GPIOIC + // (interrupt-clear) register. For level IRQs this is not needed: these go away when the level + // signal goes away. + fn ack(data: RefBorrow<'_, DeviceData>, irq_data: &IrqData) { + let mask = bit(irq_data.hwirq() % irq::HwNumber::from(PL061_GPIO_NR)); + let _guard = data.inner.lock(); + if let Some(pl061) = data.resources() { + pl061.base.writeb(mask.into(), GPIOIC); + } + } + + fn set_wake(data: RefBorrow<'_, DeviceData>, _irq_data: &IrqData, on: bool) -> Result { + let pl061 = data.resources().ok_or(ENXIO)?; + irq::set_wake(pl061.parent_irq, on) + } +} + +impl amba::Driver for PL061Device { + type Data = Ref<DeviceData>; + type PowerOps = Self; + + define_amba_id_table! {(), [ + ({id: 0x00041061, mask: 0x000fffff}, None), + ]} + + fn probe(dev: &mut amba::Device, _data: Option<&Self::IdInfo>) -> Result<Ref<DeviceData>> { + let res = dev.take_resource().ok_or(ENXIO)?; + let irq = dev.irq(0).ok_or(ENXIO)?; + + let mut data = kernel::new_device_data!( + gpio::RegistrationWithIrqChip::new(), + PL061Resources { + // SAFETY: This device doesn't support DMA. + base: unsafe { IoMem::try_new(res)? }, + parent_irq: irq, + }, + PL061Data { + dev: device::Device::from_dev(dev), + // SAFETY: We call `rawspinlock_init` below. + inner: unsafe { RawSpinLock::new(PL061DataInner::default()) }, + }, + "PL061::Registrations" + )?; + + // SAFETY: General part of the data is pinned when `data` is. + let gen_inner = unsafe { data.as_mut().map_unchecked_mut(|d| &mut (**d).inner) }; + kernel::rawspinlock_init!(gen_inner, "PL061Data::inner"); + + let data = Ref::<DeviceData>::from(data); + + data.resources().ok_or(ENXIO)?.base.writeb(0, GPIOIE); // disable irqs + + kernel::gpio_irq_chip_register!( + data.registrations().ok_or(ENXIO)?.as_pinned_mut(), + Self, + PL061_GPIO_NR, + None, + dev, + data.clone(), + irq + )?; + + dev_info!(data.dev, "PL061 GPIO chip registered\n"); + + Ok(data) + } +} + +impl power::Operations for PL061Device { + type Data = Ref<DeviceData>; + + fn suspend(data: RefBorrow<'_, DeviceData>) -> Result { + let mut inner = data.inner.lock(); + let pl061 = data.resources().ok_or(ENXIO)?; + inner.csave_regs.gpio_data = 0; + inner.csave_regs.gpio_dir = pl061.base.readb(GPIODIR); + inner.csave_regs.gpio_is = pl061.base.readb(GPIOIS); + inner.csave_regs.gpio_ibe = pl061.base.readb(GPIOIBE); + inner.csave_regs.gpio_iev = pl061.base.readb(GPIOIEV); + inner.csave_regs.gpio_ie = pl061.base.readb(GPIOIE); + + for offset in 0..PL061_GPIO_NR { + if inner.csave_regs.gpio_dir & bit(offset) != 0 { + if let Ok(v) = <Self as gpio::Chip>::get(data, offset.into()) { + inner.csave_regs.gpio_data |= (v as u8) << offset; + } + } + } + + Ok(()) + } + + fn resume(data: RefBorrow<'_, DeviceData>) -> Result { + let inner = data.inner.lock(); + let pl061 = data.resources().ok_or(ENXIO)?; + + for offset in 0..PL061_GPIO_NR { + if inner.csave_regs.gpio_dir & bit(offset) != 0 { + let value = inner.csave_regs.gpio_data & bit(offset) != 0; + let _ = <Self as gpio::Chip>::direction_output(data, offset.into(), value); + } else { + let _ = <Self as gpio::Chip>::direction_input(data, offset.into()); + } + } + + pl061.base.writeb(inner.csave_regs.gpio_is, GPIOIS); + pl061.base.writeb(inner.csave_regs.gpio_ibe, GPIOIBE); + pl061.base.writeb(inner.csave_regs.gpio_iev, GPIOIEV); + pl061.base.writeb(inner.csave_regs.gpio_ie, GPIOIE); + + Ok(()) + } + + fn freeze(data: RefBorrow<'_, DeviceData>) -> Result { + Self::suspend(data) + } + + fn restore(data: RefBorrow<'_, DeviceData>) -> Result { + Self::resume(data) + } +} + +module_amba_driver! { + type: PL061Device, + name: b"pl061_gpio", + author: b"Wedson Almeida Filho", + license: b"GPL", +} -- 2.37.1 ^ permalink raw reply related [flat|nested] 9+ messages in thread
* Re: [PATCH v8 00/31] Rust support 2022-08-02 1:49 [PATCH v8 00/31] Rust support Miguel Ojeda 2022-08-02 1:50 ` [PATCH v8 30/31] [RFC] drivers: gpio: PrimeCell PL061 in Rust Miguel Ojeda @ 2022-08-02 12:26 ` Matthew Wilcox 2022-08-02 13:45 ` Miguel Ojeda 1 sibling, 1 reply; 9+ messages in thread From: Matthew Wilcox @ 2022-08-02 12:26 UTC (permalink / raw) To: Miguel Ojeda Cc: Linus Torvalds, Greg Kroah-Hartman, rust-for-linux, linux-kernel, Jarkko Sakkinen, linux-arm-kernel, linux-doc, linux-gpio, linux-kbuild, linux-perf-users, linuxppc-dev, linux-riscv, linux-um, live-patching, linux-fsdevel On Tue, Aug 02, 2022 at 03:49:47AM +0200, Miguel Ojeda wrote: > Some of the improvements to the abstractions and example drivers are: > > - Filesystem support (`fs` module), including: > > + `INode` type (which wraps `struct inode`). > + `DEntry` type (which wraps `struct dentry`). > + `Filename` type (which wraps `struct filename`). > + `Registration` type. > + `Type` and `Context` traits. > + `SuperBlock` type (which wraps `struct super_block` and takes > advantage of typestates for its initialization). > + File system parameters support (with a `Value` enum; `Spec*` > and `Constant*` types, `define_fs_params!` macro...). > + File system flags. > + `module_fs!` macro to simplify registering kernel modules that > only implement a single file system. > + A file system sample. None of this (afaict) has been discussed on linux-fsdevel. And I may have missed somethiing, but I don't see the fs module in this series of patches. Could linux-fsdevel be cc'd on the development of Rust support for filesystems in the future? ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v8 00/31] Rust support 2022-08-02 12:26 ` [PATCH v8 00/31] Rust support Matthew Wilcox @ 2022-08-02 13:45 ` Miguel Ojeda 2022-08-02 13:48 ` Christoph Hellwig 2022-08-02 14:01 ` Matthew Wilcox 0 siblings, 2 replies; 9+ messages in thread From: Miguel Ojeda @ 2022-08-02 13:45 UTC (permalink / raw) To: Matthew Wilcox Cc: Linus Torvalds, Greg Kroah-Hartman, Miguel Ojeda, rust-for-linux, linux-kernel, Jarkko Sakkinen, linux-arm-kernel, linux-doc, linux-gpio, linux-kbuild, linux-perf-users, linuxppc-dev, linux-riscv, linux-um, live-patching, linux-fsdevel Hi Willy, On Tue, Aug 2, 2022 at 2:26 PM Matthew Wilcox <willy@infradead.org> wrote: > > None of this (afaict) has been discussed on linux-fsdevel. And I may > have missed somethiing, but I don't see the fs module in this series > of patches. Could linux-fsdevel be cc'd on the development of Rust > support for filesystems in the future? In order to provide example drivers and kernel modules, we need to have some safe abstractions for them, thus we are adding some as we need them. More importantly, the abstractions also serve as a showcase of how they may be written in the future if Rust support is merged. This does not mean these abstractions are a final design or that we plan to develop them independently of subsystem maintainers. In fact, we would prefer the opposite: in the future, when the support is merged and more people start having more experience with Rust, we hope that the respective kernel maintainers start developing and maintaining the abstractions themselves. But we have to start somewhere, and at least provide enough examples to serve as guidance and to show that it is actually possible to write abstractions that restrict the amount of unsafe code. And, of course, if you are already interested in developing them, that would be actually great and we would love your input and/or that you join us. As for the `fs` module, I see in lore 2 patches didn't make it through, but I didn't get a bounce (I do get bounces for the rust-for-linux ML, but I was told that was fine as long as LKML got them). Sorry about that... I will ask what to do. Meanwhile, you can see the patches in this branch: https://github.com/Rust-for-Linux/linux.git rust-next Cheers, Miguel ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v8 00/31] Rust support 2022-08-02 13:45 ` Miguel Ojeda @ 2022-08-02 13:48 ` Christoph Hellwig 2022-08-02 14:16 ` Miguel Ojeda 2022-08-02 14:01 ` Matthew Wilcox 1 sibling, 1 reply; 9+ messages in thread From: Christoph Hellwig @ 2022-08-02 13:48 UTC (permalink / raw) To: Miguel Ojeda Cc: Matthew Wilcox, Linus Torvalds, Greg Kroah-Hartman, Miguel Ojeda, rust-for-linux, linux-kernel, Jarkko Sakkinen, linux-arm-kernel, linux-doc, linux-gpio, linux-kbuild, linux-perf-users, linuxppc-dev, linux-riscv, linux-um, live-patching, linux-fsdevel Miguel, handwaiving and pointing to git trees is not how Linux development works. Please make sure all the patches go to the relevant lists and maintainers first, and actually do have ACKs. ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v8 00/31] Rust support 2022-08-02 13:48 ` Christoph Hellwig @ 2022-08-02 14:16 ` Miguel Ojeda 0 siblings, 0 replies; 9+ messages in thread From: Miguel Ojeda @ 2022-08-02 14:16 UTC (permalink / raw) To: Christoph Hellwig Cc: Matthew Wilcox, Linus Torvalds, Greg Kroah-Hartman, Miguel Ojeda, rust-for-linux, linux-kernel, Jarkko Sakkinen, linux-arm-kernel, linux-doc, linux-gpio, linux-kbuild, linux-perf-users, linuxppc-dev, linux-riscv, linux-um, live-patching, linux-fsdevel On Tue, Aug 2, 2022 at 3:48 PM Christoph Hellwig <hch@infradead.org> wrote: > > handwaiving and pointing to git trees is not how Linux development > works. Please make sure all the patches go to the relevant lists > and maintainers first, and actually do have ACKs. Which hand-waving? In fact, we were requested to do it like this. As for the Cc's, if any ML wants to be Cc'd for an abstraction we create, even if no C code is modified on their side, I am more than happy to Cc them. I can even do that by default, but not everyone may want to hear about the Rust side just yet, so I have not been doing it so far. Cheers, Miguel ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v8 00/31] Rust support 2022-08-02 13:45 ` Miguel Ojeda 2022-08-02 13:48 ` Christoph Hellwig @ 2022-08-02 14:01 ` Matthew Wilcox 2022-08-02 15:09 ` Miguel Ojeda 1 sibling, 1 reply; 9+ messages in thread From: Matthew Wilcox @ 2022-08-02 14:01 UTC (permalink / raw) To: Miguel Ojeda Cc: Linus Torvalds, Greg Kroah-Hartman, Miguel Ojeda, rust-for-linux, linux-kernel, Jarkko Sakkinen, linux-arm-kernel, linux-doc, linux-gpio, linux-kbuild, linux-perf-users, linuxppc-dev, linux-riscv, linux-um, live-patching, linux-fsdevel On Tue, Aug 02, 2022 at 03:45:50PM +0200, Miguel Ojeda wrote: > Hi Willy, > > On Tue, Aug 2, 2022 at 2:26 PM Matthew Wilcox <willy@infradead.org> wrote: > > > > None of this (afaict) has been discussed on linux-fsdevel. And I may > > have missed somethiing, but I don't see the fs module in this series > > of patches. Could linux-fsdevel be cc'd on the development of Rust > > support for filesystems in the future? > > In order to provide example drivers and kernel modules, we need to > have some safe abstractions for them, thus we are adding some as we > need them. > > More importantly, the abstractions also serve as a showcase of how > they may be written in the future if Rust support is merged. > > This does not mean these abstractions are a final design or that we > plan to develop them independently of subsystem maintainers. In fact, > we would prefer the opposite: in the future, when the support is > merged and more people start having more experience with Rust, we hope > that the respective kernel maintainers start developing and > maintaining the abstractions themselves. > > But we have to start somewhere, and at least provide enough examples > to serve as guidance and to show that it is actually possible to write > abstractions that restrict the amount of unsafe code. > > And, of course, if you are already interested in developing them, that > would be actually great and we would love your input and/or that you > join us. No objections to any of this. I love the idea of being able to write filesystems in Rust. I just think it would go more smoothly if linux-fsdevel were involved more closely so people at least have the option of being able to follow design decisions, and hopefully influence them. That goes both ways, of course; I hardly think our current operations structures are the optimum way to implement a filesystem, and having fresh eyes say things like "But that shouldn't be part of the address_space_operations" can impel better abstractions. > As for the `fs` module, I see in lore 2 patches didn't make it > through, but I didn't get a bounce (I do get bounces for the > rust-for-linux ML, but I was told that was fine as long as LKML got > them). Sorry about that... I will ask what to do. The obvious answer is to split out the 'fs module' into its own patch ;-) I presume it was part of the kernel crate which would have been either patch 17 or 11 in that series? > Meanwhile, you can see the patches in this branch: > > https://github.com/Rust-for-Linux/linux.git rust-next > > Cheers, > Miguel ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v8 00/31] Rust support 2022-08-02 14:01 ` Matthew Wilcox @ 2022-08-02 15:09 ` Miguel Ojeda 2022-08-02 17:46 ` Miguel Ojeda 0 siblings, 1 reply; 9+ messages in thread From: Miguel Ojeda @ 2022-08-02 15:09 UTC (permalink / raw) To: Matthew Wilcox Cc: Linus Torvalds, Greg Kroah-Hartman, Miguel Ojeda, rust-for-linux, linux-kernel, Jarkko Sakkinen, linux-arm-kernel, linux-doc, linux-gpio, linux-kbuild, linux-perf-users, linuxppc-dev, linux-riscv, linux-um, live-patching, linux-fsdevel On Tue, Aug 2, 2022 at 4:01 PM Matthew Wilcox <willy@infradead.org> wrote: > > No objections to any of this. I love the idea of being able to write > filesystems in Rust. I just think it would go more smoothly if > linux-fsdevel were involved more closely so people at least have the > option of being able to follow design decisions, and hopefully influence > them. That goes both ways, of course; I hardly think our current > operations structures are the optimum way to implement a filesystem, > and having fresh eyes say things like "But that shouldn't be part of the > address_space_operations" can impel better abstractions. I will send the patches to fsdevel then! As for following development closely and design decisions, we have been doing it in GitHub so far pre-merge, so the easiest until the merge (for us) would be to ping you there. We can also send you copies of the `fs` related patches too if you would like that. I would highly recommend joining the monthly informal calls too. (I appreciate the kind answer, by the way!) > The obvious answer is to split out the 'fs module' into its own patch > ;-) I presume it was part of the kernel crate which would have been > either patch 17 or 11 in that series? Yeah, patch 17, exactly (patch 11 is the `alloc` import). I have asked Konstantin privately about them. In any case, I will split the patches further for v9 which should help. Meanwhile, you can also see the `fs` module here, if you are curious: https://github.com/Rust-for-Linux/linux/blob/rust-next/rust/kernel/fs.rs https://github.com/Rust-for-Linux/linux/blob/rust-next/rust/kernel/fs/param.rs Cheers, Miguel ^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH v8 00/31] Rust support 2022-08-02 15:09 ` Miguel Ojeda @ 2022-08-02 17:46 ` Miguel Ojeda 0 siblings, 0 replies; 9+ messages in thread From: Miguel Ojeda @ 2022-08-02 17:46 UTC (permalink / raw) To: Matthew Wilcox Cc: Linus Torvalds, Greg Kroah-Hartman, Miguel Ojeda, rust-for-linux, linux-kernel, Jarkko Sakkinen, linux-arm-kernel, linux-doc, linux-gpio, linux-kbuild, linux-perf-users, linuxppc-dev, linux-riscv, linux-um, live-patching, linux-fsdevel On Tue, Aug 2, 2022 at 5:09 PM Miguel Ojeda <miguel.ojeda.sandonis@gmail.com> wrote: > > Yeah, patch 17, exactly (patch 11 is the `alloc` import). I have asked > Konstantin privately about them. The patches are showing up now in lore -- not sure if it was just a delay (which would be consistent with the lack of bounce) or somebody did something (thank you if so!). Cheers, Miguel ^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2022-08-02 17:46 UTC | newest] Thread overview: 9+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2022-08-02 1:49 [PATCH v8 00/31] Rust support Miguel Ojeda 2022-08-02 1:50 ` [PATCH v8 30/31] [RFC] drivers: gpio: PrimeCell PL061 in Rust Miguel Ojeda 2022-08-02 12:26 ` [PATCH v8 00/31] Rust support Matthew Wilcox 2022-08-02 13:45 ` Miguel Ojeda 2022-08-02 13:48 ` Christoph Hellwig 2022-08-02 14:16 ` Miguel Ojeda 2022-08-02 14:01 ` Matthew Wilcox 2022-08-02 15:09 ` Miguel Ojeda 2022-08-02 17:46 ` Miguel Ojeda
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).