Re: [PATCH 5/7] rust: io: let I/O locations carry an access mode

["Gary Guo" <gary@garyguo.net>]

On Thu Oct 15, 2026 at 1:39 PM BST, Daniel Almeida wrote:
> `Io::read`, `Io::write`, `Io::update` and their fallible variants
> project the view to the given `IoLoc` and access it there. A location
> has no say in which accesses are allowed, so a register cannot be
> declared read-only or write-only.
>
> Add the `io::access` module with the `Mode` trait and the `ReadWrite`,
> `ReadOnly` and `WriteOnly` modes, and add an `Access` associated type to
> `IoLoc`. Projecting through a location applies its mode: `ReadWrite`
> leaves the view as it is, while `ReadOnly` and `WriteOnly` wrap it in the
> `ReadOnly` and `WriteOnly` views. The bounds of the generic accessors now
> apply to the backend of the restricted view, so a write to a read-only
> location, or a read from a write-only one, does not compile.
>
> Raw offsets are `ReadWrite`. `OffsetLoc` takes the mode as a type
> parameter that defaults to `ReadWrite`, and `RegisterArray` gets an
> `Access` type, which `register!` sets to `ReadWrite` for now.
>
> No existing location changes its mode, so there is no functional change.
> A following patch lets `register!` declare read-only and write-only
> registers.

So far, without considering access modes, we have a clean mapping after the
register projection series that a `register!()` macro just generates a custom
projection. However, this commit makes it special again and this isn't possible
with struct definitions, so it breaks feature composibility. It is also somewhat
surprising in the sense that it changes the base view type.

What about making RO/WO wrapper types on actual data? Something like

    Mmio<'_, ReadOnly<T>>

and

    Mmio<'_, WriteOnly<T>>

Then we can implement

    impl<T, B> IoRead<ReadOnly<T>> for B where B: IoRead<T> {}

and

    impl<T, B> IoWrite<WriteOnly<T>> for B where B: IoWrite<T> {}

ReadOnly will not implement FromBytes, and WriteOnly will not implement
IntoBytes, to avoid people using them with `copy_read`/`copy_write` API.

This way, the design works for struct too. One issue of this, though, is that
you cannot project from `Mmio<'_, ReadOnly<Struct>>` to `Mmio<'_,
ReadOnly<Field>>` currently. However, I believe this is solved with the "place
wrapper" concept in field projection.

Regardless, before we proceed with any design, I'd like to hear opinions from
Benno on how this interacts with the field projection design as language
feature.

Best,
Gary

>
> Signed-off-by: Daniel Almeida <daniel.almeida@collabora.com>
> ---
>  rust/kernel/io.rs          | 42 +++++++++++++++++--------
>  rust/kernel/io/access.rs   | 76 ++++++++++++++++++++++++++++++++++++++++++++++
>  rust/kernel/io/register.rs | 18 +++++++++--
>  rust/macros/io/register.rs |  1 +
>  4 files changed, 121 insertions(+), 16 deletions(-)