Inaccessible pages & folios
Subsystems (2)
Hi Claudio,
I'm working on making the page cache manage memory in larger chunks than PAGE_SIZE [1] [2]. In doing so, I came across this call that you added:
@@ -2807,6 +2807,13 @@ int __test_set_page_writeback(struct page *page, bool keep_write)
inc_zone_page_state(page, NR_ZONE_WRITE_PENDING);
}
unlock_page_memcg(page);+ access_ret = arch_make_page_accessible(page);
I'm going to change __test_set_page_writeback() to take a folio [3] and now I'm wondering what interface you'd like to use. My preference would be to rename arch_make_page_accessible() to arch_make_folio_accessible() and pass a folio, at which time you would make the entire folio (however many pages might be in it) accessible. If you would rather, we can leave the interface as arch_make_page_accessible(), in which case we'll just call it N times in __test_set_page_writeback() (and I won't need to touch gup.c).
Let me know what you want.
[1] https://lwn.net/Articles/849538/
[2] https://lore.kernel.org/linux-mm/[email protected]/
[3] https://git.infradead.org/users/willy/pagecache.git/commitdiff/85297eb08f1b034b9652ea63dd053e3be4d7de7f
PS: The prototype is in gfp.h. That's not really appropriate; gfp.h is about allocating memory, and this call really has nothing to do with memory allocation. I think mm.h is a better place for it, if you can't find a better header file than that.
Quoted 4 lines · On Fri, 9 Apr 2021 20:40:59 +0100 Matthew Wilcox <[email protected]> wrote:
Hi Claudio,
I'm working on making the page cache manage memory in larger chunks than
PAGE_SIZE[1] [2]. In doing so, I came across this call that
yes, I had read the LWN article with great interest
Quoted 8 lines
you added:
(quoted diff) +1
-0@@ -2807,6 +2807,13 @@ int __test_set_page_writeback(struct page *page, bool keep_write) inc_zone_page_state(page, NR_ZONE_WRITE_PENDING); } unlock_page_memcg(page); + access_ret = arch_make_page_accessible(page);
Quoted 8 lines
I'm going to change
__test_set_page_writeback()to take a folio [3] and now I'm wondering what interface you'd like to use. My preference would be to renamearch_make_page_accessible()toarch_make_folio_accessible()and pass a folio, at which time you would make the entire folio (however many pages might be in it) accessible. If you would rather, we can leave the interface asarch_make_page_accessible(), in which case we'll just call it N times in__test_set_page_writeback()(and I won't need to touchgup.c).
For the rename case, how would you handle gup.c?
Consider that arch_make_page_accessible deals (typically) with KVM guest pages. Once you bundle up the pages in folios, you can have different pages in the same folio with different properties.
In case of failure, you could end up with a folio with some pages processed and some not processed. Would you stop at the first error? What would the state of the folio be? On s390x we use the PG_arch_1 bit to mark secure pages, how would that work with folios?
and how are fault handlers affected by this folio conversion? would they still work on pages, or would that also work on folios? on s390x we use the arch_make_page_accessible function in some fault handlers.
a possible approach maybe would be to keep the _page variant, and add a _folio wrapper around it
for s390x the PG_arch_1 is very important to prevent protected pages from being fed to I/O, as in that case Very Bad Things™ would happen.
sorry for the wall of questions, but I actually like your folio approach and I want to understand it better, so we can find a way to make everything work well together
Quoted 8 lines
Let me know what you want.
[1] https://lwn.net/Articles/849538/
[2]
https://lore.kernel.org/linux-mm/[email protected]/
[3]
https://git.infradead.org/users/willy/pagecache.git/commitdiff/85297eb08f1b034b9652ea63dd053e3be4d7de7f
Quoted 4 lines
PS: The prototype is in
gfp.h. That's not really appropriate;gfp.his about allocating memory, and this call really has nothing to do with memory allocation. I thinkmm.his a better place for it, if you can't find a better header file than that.
I had put it there because arch_alloc_page and arch_free_page are also there, and the behaviour, from a kernel point of view, is similar (unaccessible/unallocated pages will trigger a fault).
I actually do not have a preference regarding where the prototype lives, as long as everything works. If you think mm.h is more appropriate, go for it :)
Quoted 11 lines · Claudio Imbrenda
Quoted 8 lines · On Fri, 9 Apr 2021 20:40:59 +0100 Matthew Wilcox <[email protected]> wrote:
I'm going to change
__test_set_page_writeback()to take a folio [3] and now I'm wondering what interface you'd like to use. My preference would be to renamearch_make_page_accessible()toarch_make_folio_accessible()and pass a folio, at which time you would make the entire folio (however many pages might be in it) accessible. If you would rather, we can leave the interface asarch_make_page_accessible(), in which case we'll just call it N times in__test_set_page_writeback()(and I won't need to touchgup.c).
Quoted 1 line
For the rename case, how would you handle
gup.c?
At first, I'd turn it into arch_make_folio_accessible(page_folio(page));
Eventually, gup.c needs to become folio-aware. I haven't spent too much time thinking about it, but code written like this:
page = pte_page(pte);
head = try_grab_compound_head(page, 1, flags);
if (!head)
goto pte_unmap;
if (unlikely(pte_val(pte) != pte_val(*ptep))) {
put_compound_head(head, 1, flags);
goto pte_unmap;
}
VM_BUG_ON_PAGE(compound_head(page) != head, page);is just crying out for use of folios. Also, some of the gup callers would much prefer to work in terms of folios than individual struct pages (imagine an RDMA adapter that wants to pin several gigabytes of memory that's allocated using hugetlbfs for example).
Quoted 3 lines
Consider that
arch_make_page_accessibledeals (typically) with KVM guest pages. Once you bundle up the pages in folios, you can have different pages in the same folio with different properties.
So what you're saying is that the host might allocate, eg a 1GB folio for a guest, then the guest splits that up into smaller chunks (eg 1MB), and would only want one of those small chunks accessible to the hypervisor?
Quoted 8 lines
In case of failure, you could end up with a folio with some pages processed and some not processed. Would you stop at the first error? What would the state of the folio be? On s390x we use the
PG_arch_1bit to mark secure pages, how would that work with folios?and how are fault handlers affected by this folio conversion? would they still work on pages, or would that also work on folios? on s390x we use the
arch_make_page_accessiblefunction in some fault handlers.
Folios can be mapped into userspace at an unaligned offset. So we still have to work in pages, at least for now. We might have some optimised path for aligned folios later.
Quoted 2 lines
a possible approach maybe would be to keep the
_pagevariant, and add a_foliowrapper around it
Yes, we can do that. It's what I'm currently doing for flush_dcache_folio().
Quoted 6 lines
for s390x the
PG_arch_1is very important to prevent protected pages from being fed to I/O, as in that case Very Bad Things™ would happen.sorry for the wall of questions, but I actually like your folio approach and I want to understand it better, so we can find a way to make everything work well together
Great!
Quoted 5 lines
Quoted 4 lines
PS: The prototype is in
gfp.h. That's not really appropriate;gfp.his about allocating memory, and this call really has nothing to do with memory allocation. I thinkmm.his a better place for it, if you can't find a better header file than that.
Quoted 7 lines
I had put it there because
arch_alloc_pageandarch_free_pageare also there, and the behaviour, from a kernel point of view, is similar (unaccessible/unallocated pages will trigger a fault).I actually do not have a preference regarding where the prototype lives, as long as everything works. If you think
mm.his more appropriate, go for it :)
Heh, I see how you got there from the implementors point of view ;-) I'll move it ...
On Mon, 12 Apr 2021 13:43:41 +0100
Matthew Wilcox <[email protected]> wrote:
[...]
Quoted 4 lines
Quoted 1 line
For the rename case, how would you handle
gup.c?At first, I'd turn it into
arch_make_folio_accessible(page_folio(page));
that's tricky. what happens if some pages in the folio cannot be made accessible?
also, I assume you keep the semantic difference between get_page and pin_page? that's also very important for us
Quoted 18 lines
Eventually,
gup.cneeds to become folio-aware. I haven't spent too much time thinking about it, but code written like this:page = pte_page(pte); head = try_grab_compound_head(page, 1, flags); if (!head) goto pte_unmap; if (unlikely(pte_val(pte) != pte_val(*ptep))) { put_compound_head(head, 1, flags); goto pte_unmap; } VM_BUG_ON_PAGE(compound_head(page) != head, page);is just crying out for use of folios. Also, some of the gup callers would much prefer to work in terms of folios than individual struct pages (imagine an RDMA adapter that wants to pin several gigabytes of memory that's allocated using hugetlbfs for example).
Quoted 8 lines
Quoted 3 lines
Consider that
arch_make_page_accessibledeals (typically) with KVM guest pages. Once you bundle up the pages in folios, you can have different pages in the same folio with different properties.So what you're saying is that the host might allocate, eg a 1GB folio for a guest, then the guest splits that up into smaller chunks (eg 1MB), and would only want one of those small chunks accessible to the hypervisor?
qemu will allocate a big chunk of memory, and I/O would happen only on small chunks (depending on what the guest does). I don't know how swap and pagecache would behave in the folio scenario.
Also consider that currently we need 4k hardware pages for protected guests (so folios would be ok, as long as they are backed by small pages)
How and when are folios created actually?
is there a way to prevent creation of multi-page folios?
Quoted 14 lines
Quoted 9 lines
In case of failure, you could end up with a folio with some pages processed and some not processed. Would you stop at the first error? What would the state of the folio be? On s390x we use the
PG_arch_1bit to mark secure pages, how would that work with folios?and how are fault handlers affected by this folio conversion? would they still work on pages, or would that also work on folios? on s390x we use the
arch_make_page_accessiblefunction in some fault handlers.Folios can be mapped into userspace at an unaligned offset. So we still have to work in pages, at least for now. We might have some optimised path for aligned folios later.
Quoted 5 lines
Quoted 2 lines
a possible approach maybe would be to keep the
_pagevariant, and add a_foliowrapper around itYes, we can do that. It's what I'm currently doing for
flush_dcache_folio().
where would the page flags be stored? as I said, we really depend on that bit to be set correctly to prevent potentially disruptive I/O errors. It's ok if the bit overindicates protection (non-protected pages can be marked as protected), but protected pages must at all times have the bit set.
the reason why this hook exists at all, is to prevent secure pages from being accidentally (or maliciously) fed into I/O
Quoted 25 lines
Quoted 7 lines
for s390x the
PG_arch_1is very important to prevent protected pages from being fed to I/O, as in that case Very Bad Things™ would happen.sorry for the wall of questions, but I actually like your folio approach and I want to understand it better, so we can find a way to make everything work well together
Great!
Quoted 5 lines
Quoted 4 lines
PS: The prototype is in
gfp.h. That's not really appropriate;gfp.his about allocating memory, and this call really has nothing to do with memory allocation. I thinkmm.his a better place for it, if you can't find a better header file than that.Quoted 7 lines
I had put it there because
arch_alloc_pageandarch_free_pageare also there, and the behaviour, from a kernel point of view, is similar (unaccessible/unallocated pages will trigger a fault).I actually do not have a preference regarding where the prototype lives, as long as everything works. If you think
mm.his more appropriate, go for it :)Heh, I see how you got there from the implementors point of view ;-) I'll move it ...
Quoted 5 lines · Claudio Imbrenda
On Mon, 12 Apr 2021 13:43:41 +0100
Matthew Wilcox <[email protected]> wrote:[...]
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
For the rename case, how would you handle
gup.c?At first, I'd turn it into
arch_make_folio_accessible(page_folio(page));that's tricky. what happens if some pages in the folio cannot be made accessible?
I was only thinking about the page cache case ...
access_ret = arch_make_page_accessible(page);
/*
* If writeback has been triggered on a page that cannot be made
* accessible, it is too late to recover here.
*/
VM_BUG_ON_PAGE(access_ret != 0, page);... where it seems all pages _can_ be made accessible.
Quoted 2 lines
also, I assume you keep the semantic difference between
get_pageandpin_page? that's also very important for us
I haven't changed anything in gup.c yet. Just trying to get the page cache to suck less right now.
Quoted 9 lines
Quoted 4 lines
So what you're saying is that the host might allocate, eg a 1GB folio for a guest, then the guest splits that up into smaller chunks (eg 1MB), and would only want one of those small chunks accessible to the hypervisor?
qemu will allocate a big chunk of memory, and I/O would happen only on small chunks (depending on what the guest does). I don't know how swap and pagecache would behave in the folio scenario.
Quoted 7 lines
Also consider that currently we need 4k hardware pages for protected guests (so folios would be ok, as long as they are backed by small pages)
How and when are folios created actually?
is there a way to prevent creation of multi-page folios?
Today there's no way to create multi-page folios because I haven't submitted the patch to add alloc_folio() and friends:
We do have a way to allocate compound pages and add them to the page cache, but that's only in use by tmpfs/shmem.
What will happen is that (for filesystems which support multipage folios), they'll be allocated by the page cache. I expect other places will start to use folios after that (eg anonymous memory), but I don't know where all those places will be. I hope not to be involved in that!
The general principle, though, is that the overhead of tracking memory in page-sized units is too high, and we need to use larger units by default. There are occasions when we need to do things to memory in smaller units, and for those, we can choose to either handle sub-folio things, or we can split a folio apart into smaller folios.
Quoted 6 lines
Quoted 5 lines
Quoted 2 lines
a possible approach maybe would be to keep the
_pagevariant, and add a_foliowrapper around itYes, we can do that. It's what I'm currently doing for
flush_dcache_folio().
Quoted 8 lines
where would the page flags be stored? as I said, we really depend on that bit to be set correctly to prevent potentially disruptive I/O errors. It's ok if the bit overindicates protection (non-protected pages can be marked as protected), but protected pages must at all times have the bit set.
the reason why this hook exists at all, is to prevent secure pages from being accidentally (or maliciously) fed into I/O
You can still use PG_arch_1 on the sub-pages of a folio. It's one of the things you'll have to decide, actually. Does setting PG_arch_1 on the head page of the folio indicate that the entire page is accessible, or just that the head page is accessible? Different page flags have made different decisions here.
On Mon, 12 Apr 2021 14:55:14 +0100
Matthew Wilcox <[email protected]> wrote:
[...]
Quoted 11 lines
I was only thinking about the page cache case ...
access_ret = arch_make_page_accessible(page); /* * If writeback has been triggered on a page that cannot be made * accessible, it is too late to recover here. */ VM_BUG_ON_PAGE(access_ret != 0, page);
Quoted 1 line
... where it seems all pages _can_ be made accessible.
yes, for that case it is straightforward
Quoted 5 lines
Quoted 2 lines
also, I assume you keep the semantic difference between
get_pageandpin_page? that's also very important for usI haven't changed anything in
gup.cyet. Just trying to get the page cache to suck less right now.
fair enough :)
Quoted 50 lines
Quoted 9 lines
Quoted 4 lines
So what you're saying is that the host might allocate, eg a 1GB folio for a guest, then the guest splits that up into smaller chunks (eg 1MB), and would only want one of those small chunks accessible to the hypervisor?
qemu will allocate a big chunk of memory, and I/O would happen only on small chunks (depending on what the guest does). I don't know how swap and pagecache would behave in the folio scenario.
Quoted 7 lines
Also consider that currently we need 4k hardware pages for protected guests (so folios would be ok, as long as they are backed by small pages)
How and when are folios created actually?
is there a way to prevent creation of multi-page folios?
Today there's no way to create multi-page folios because I haven't submitted the patch to add
alloc_folio()and friends:We do have a way to allocate compound pages and add them to the page cache, but that's only in use by tmpfs/shmem.
What will happen is that (for filesystems which support multipage folios), they'll be allocated by the page cache. I expect other places will start to use folios after that (eg anonymous memory), but I don't know where all those places will be. I hope not to be involved in that!
The general principle, though, is that the overhead of tracking memory in page-sized units is too high, and we need to use larger units by default. There are occasions when we need to do things to memory in smaller units, and for those, we can choose to either handle sub-folio things, or we can split a folio apart into smaller folios.
Quoted 12 lines
Quoted 5 lines
Quoted 2 lines
a possible approach maybe would be to keep the
_pagevariant, and add a_foliowrapper around itYes, we can do that. It's what I'm currently doing for
flush_dcache_folio().where would the page flags be stored? as I said, we really depend on that bit to be set correctly to prevent potentially disruptive I/O errors. It's ok if the bit overindicates protection (non-protected pages can be marked as protected), but protected pages must at all times have the bit set.
Quoted 8 lines
Quoted 2 lines
the reason why this hook exists at all, is to prevent secure pages from being accidentally (or maliciously) fed into I/O
You can still use
PG_arch_1on the sub-pages of a folio. It's one of the things you'll have to decide, actually. Does settingPG_arch_1on the head page of the folio indicate that the entire page is accessible, or just that the head page is accessible? Different page flags have made different decisions here.
ok then, I think the simplest and safest thing to do right now is to keep the flag on each page
in short:
* pagecache -> you can put a loop or introduce a _folio wrapper for arch_make_page_accessible
* gup.c -> won't be touched for now, but when the time comes, the PG_arch_1 bit should be set for each page