From: Andreas Hindborg <a.hindborg@kernel.org>
To: Zi Yan <ziy@nvidia.com>
Cc: "Andrew Morton" <akpm@linux-foundation.org>,
"Vlastimil Babka" <vbabka@kernel.org>,
"Lorenzo Stoakes" <ljs@kernel.org>,
"Liam R. Howlett" <liam@infradead.org>,
"Uladzislau Rezki" <urezki@gmail.com>,
"David Hildenbrand" <david@kernel.org>,
"Suren Baghdasaryan" <surenb@google.com>,
"Michal Hocko" <mhocko@suse.com>,
"Brendan Jackman" <brendan.jackman@linux.dev>,
"Johannes Weiner" <hannes@cmpxchg.org>,
"Mike Rapoport" <rppt@kernel.org>,
"Joshua Hahn" <joshua.hahnjy@gmail.com>,
"Rakie Kim" <rakie.kim@sk.com>,
"Gregory Price" <gourry@gourry.net>,
"Ying Huang" <ying.huang@linux.alibaba.com>,
"Matthew Wilcox" <willy@infradead.org>,
"Danilo Krummrich" <dakr@kernel.org>,
"Miguel Ojeda" <ojeda@kernel.org>,
"Boqun Feng" <boqun@kernel.org>, "Gary Guo" <gary@garyguo.net>,
"Björn Roy Baron" <bjorn3_gh@protonmail.com>,
"Benno Lossin" <lossin@kernel.org>,
"Alice Ryhl" <aliceryhl@google.com>,
"Trevor Gross" <tmgross@umich.edu>,
"Daniel Almeida" <daniel.almeida@collabora.com>,
"Tamir Duberstein" <tamird@kernel.org>,
"Alexandre Courbot" <acourbot@nvidia.com>,
"Onur Özkan" <work@onurozkan.dev>,
"Greg Kroah-Hartman" <gregkh@linuxfoundation.org>,
"Arve Hjønnevåg" <arve@android.com>,
"Todd Kjos" <tkjos@android.com>,
"Christian Brauner" <brauner@kernel.org>,
"Carlos Llamas" <cmllamas@google.com>,
"Igor B" <igor.b@beldev.am>,
"Vitaly Wool" <vitaly.wool@konsulko.se>,
linux-mm@kvack.org, rust-for-linux@vger.kernel.org,
linux-kernel@vger.kernel.org
Subject: Re: [PATCH v22 0/6] rust: page: add page kinds
Date: Fri, 20 Nov 2026 13:03:30 +0100 [thread overview]
Message-ID: <87se0vu2ul.fsf@t14s.mail-host-address-is-not-set> (raw)
In-Reply-To: <3C3421E5-5B7D-42B8-ABD2-185375693D7A@nvidia.com>
Zi Yan <ziy@nvidia.com> writes:
> On 18 Nov 2026, at 14:34, Andreas Hindborg wrote:
>
>> Zi Yan <ziy@nvidia.com> writes:
>>
>>> On 18 Nov 2026, at 11:18, Andreas Hindborg wrote:
>>>
>>>> Note: The page patches were part of the `Ownable` series [1] until v21.
>>>> This series continues the version numbering of that series, and it depends
>>>> on v22 of that series for `Ownable`, `Owned` and the split of `RefCounted`
>>>> and `AlwaysRefCounted`.
>>>>
>>>> Not all pages can be treated the same way. A page allocated with
>>>> `alloc_pages()` is managed by the page reference count, and kernel C code
>>>> routinely takes its own references to such a page. A page owned by the
>>>> slab allocator must not have references taken to it, but it can still
>>>> show up in places such as a bio vector. A frozen page has a reference
>>>> count of zero and is exclusively owned by the party that allocated it.
>>>>
>>>> A single `Page` type cannot describe all of these. This series makes
>>>> `Page` generic over a sealed `PageKind` that describes what is known about
>>>> the page:
>>>>
>>>> - `Page<Base>` is the base kind. Nothing is known about the page
>>>> beyond the validity of the `struct page`.
>>>> - `Page<RefCounted>` is the default kind. The page is managed by the
>>>> page reference count, and `Page<RefCounted>` implements
>>>> `AlwaysRefCounted`.
>>>> - `Page<Exclusive>` is a uniquely owned frozen page whose data area
>>>> follows standard Rust aliasing rules, so the data is available as
>>>> `&[u8]` and `&mut [u8]`. It is handled through
>>>> `Owned<Page<Exclusive>>` and is the first in-tree user of `Owned`.
>>>> - `Page<Frozen>` is a frozen page whose allocation is uniquely owned.
>>>> Unlike for `Page<Exclusive>`, nothing is known about who accesses the
>>>> data of the page, so the data is only available through the unsafe
>>>> raw accessors.
>>>
>>> Why do we need to allocate Page<Frozen> when we can allocate Page<Exclusive>?
>>> To me, Page<Frozen> is an observed page state from a non-owner point
>>> of view.
>>
>> I'm not sure we need it, which is why I added this note:
>>
>> This currently has no users, but I add it here for completeness. Let's
>> discuss if we should keep it or not.
>>
>> The difference between the `Page<Frozen>` and `Page<Exclusive>` is that
>> `Page<Exclusive>` has stronger invariants. Namely that the (physical)
>> memory region of the page does not incur data races, and that the page
>> not in highmem. From a Rust point of view, this allows us to obtain a
>> reference to the page contents without jumping through any hoops.
>
> But access to memory region of the page is associated with page table
> mapping or IOMMU mapping (for device, and I assume devices are accessing
> data via virtual addresses instead of physical addresses to avoid further
> complication). It seems that you are trying to use page refcount == 0
> to infer that no page table mapping exists for the page. But how about
> kernel direct map?
`Page<Exclusive>` has the invariant that it must not be in highmem, and
as such is always accessible in the kernel virtual address space. As far
as I understand, this means we do not need `kmap_local` before accessing
the contents.
> Anyone with struct page can use kmap_local*()
> to get kernel direct map and access the page content. kmap_local*()
> does not reject frozen pages.
`Page<Exclusive>` is a unique handle. Nobody can get a hold of the
underlying `struct page` to perform mapping operations on the page.
>
>>
>> I do not have a user for a frozen page without these invariants, but I
>> would assume there are use cases?
>
> For the above reason, everything is Page<Frozen>?
Pages that are part of user space process vmas are not frozen? We see
these in system calls for IO.
>
>>
>>> In core-mm, a page is frozen, when its refcount == 0. The code looking
>>> at the page knows the page is exclusively owned by others. If the code
>>> allocates a frozen page, it will not check its refcount, because
>>> the code knows it has the exclusive ownership of the page. To reflect
>>> this, the code calling alloc_frozen_pages() should just get
>>> Page<Exclusive>
>>
>> Is it always the case that users of frozen pages will use them in such a
>> way that they can guarantee no races to the page contents (physical
>> memory)? They cannot be mapped for DMA access or anything like that -
>> that always requires a refcount?
>
> See kmap_local*() case above.
Right. Both `Page<Frozen>` and `Page<Exclusive>` are guaranteed to be
the only reference the underlying `struct page`, and so nobody can do
mapping operations from under us. The difference of the two is that
`Page<Exclusive>` provides guarantees about placement out of highmem and
no races on the page contents.
>
>>
>>> and if the code encounters a Page<Base> and finds it has no refcount,
>>> it should convert it to Page<Frozen> or there should be a method
>>> that accepts PFN and return Page<Frozen> if the page of the PFN has no
>>> refcount, for PFN walkers.
>>
>> We can add conversion functions, that makes sense.
>>
>>>
>>> “the data” mentioned in Page<Exclusive> and Page<Frozen> is struct page
>>> data or the data in the physical frame pointed by Page<...>? If it
>>> is the former, is it better to use metadata?
>>
>> I'm referring to the actual physical memory region that the struct page
>> describes.
>>
>>>
>>> I am new to Rust, so feel free to correct me. Thanks. :)
>>>
>>
>> I'm new to mm, I really appreciate your eyes on this.
>
> Do you mind describing the high level workflow around Page in Rust?
> From my point of view, exclusive page content access is more related
> to page table (including IOMMU page table) than struct page itself.
> struct page ownership is more about the metadata stored in struct
> page for physical memory maintenance.
Just as in C code, there are many workflows around `Page`. Three main
ones I have seen in Rust code are:
- Pages that are part of io buffers during a syscall. The pages are
mapped in at least one user space process and the kernel may want to
read or write from/to them. These would be `Page<RefCounted>`.
- Pages that hit the block device driver API via the block layer. These
can be anything, so we model them as `Page<Base>`.
- Pages used for backing storage like in the null block driver. These
are modeled as `Page<Exclusive>`.
I think for the first one, binder is inserting and removing pages from
vmas to do it's IPC thing.
If someone were to write an allocator of some kind, they would probably
reach for the `Page<Frozen>`, as they would like to have ownership of
the metadata, but not the contents.
Best regards,
Andreas Hindborg
prev parent reply other threads:[~2026-11-20 12:03 UTC|newest]
Thread overview: 11+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-18 16:18 Andreas Hindborg
2026-11-18 16:18 ` [PATCH v22 1/6] rust: page: add page kinds and make `Page` reference counted Andreas Hindborg
2026-11-18 16:18 ` [PATCH v22 2/6] rust: page: add `from_raw()` Andreas Hindborg
2026-11-18 16:18 ` [PATCH v22 3/6] mm/page_alloc: make alloc_frozen_pages() available outside of mm Andreas Hindborg
2026-11-18 16:18 ` [PATCH v22 4/6] rust: page: add `Exclusive` page kind for race-free page access Andreas Hindborg
2026-11-18 16:18 ` [PATCH v22 5/6] rust: page: add `Frozen` page kind Andreas Hindborg
2026-11-18 16:18 ` [PATCH v22 6/6] rust: page: add slice access to `Page<Exclusive>` Andreas Hindborg
2026-11-18 17:02 ` [PATCH v22 0/6] rust: page: add page kinds Zi Yan
2026-11-18 19:34 ` Andreas Hindborg
2026-11-19 16:58 ` Zi Yan
2026-11-20 12:03 ` Andreas Hindborg [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=87se0vu2ul.fsf@t14s.mail-host-address-is-not-set \
--to=a.hindborg@kernel.org \
--cc=acourbot@nvidia.com \
--cc=akpm@linux-foundation.org \
--cc=aliceryhl@google.com \
--cc=arve@android.com \
--cc=bjorn3_gh@protonmail.com \
--cc=boqun@kernel.org \
--cc=brauner@kernel.org \
--cc=brendan.jackman@linux.dev \
--cc=cmllamas@google.com \
--cc=dakr@kernel.org \
--cc=daniel.almeida@collabora.com \
--cc=david@kernel.org \
--cc=gary@garyguo.net \
--cc=gourry@gourry.net \
--cc=gregkh@linuxfoundation.org \
--cc=hannes@cmpxchg.org \
--cc=igor.b@beldev.am \
--cc=joshua.hahnjy@gmail.com \
--cc=liam@infradead.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-mm@kvack.org \
--cc=ljs@kernel.org \
--cc=lossin@kernel.org \
--cc=mhocko@suse.com \
--cc=ojeda@kernel.org \
--cc=rakie.kim@sk.com \
--cc=rppt@kernel.org \
--cc=rust-for-linux@vger.kernel.org \
--cc=surenb@google.com \
--cc=tamird@kernel.org \
--cc=tkjos@android.com \
--cc=tmgross@umich.edu \
--cc=urezki@gmail.com \
--cc=vbabka@kernel.org \
--cc=vitaly.wool@konsulko.se \
--cc=willy@infradead.org \
--cc=work@onurozkan.dev \
--cc=ying.huang@linux.alibaba.com \
--cc=ziy@nvidia.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®