cachefiles, afs: mm wait fixes
Subsystems (5)
David Howells
maintainercover cachefiles, afs: mm wait fixes
Here are some patches to fix page waiting-related issues in cachefiles and afs[1]:
(1) In cachefiles, remove the use of the wait_bit_key struct to access something that's actually in wait_page_key format. The proper struct is now available in the header, so that should be used instead.
(2) Add a proper wait function for waiting killably on the page writeback flag. This includes a recent bugfix here (presumably commit c2407cf7d22d0c0d94cf20342b3b8f06f1d904e7).
(3) In afs, use the function added in (2) rather than using wait_on_page_bit_killable() which doesn't have the aforementioned bugfix.
Note that I modified this to work with the upstream code where the page pointer isn't cached in a local variable.
The patches can be found here:
https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git/log/?h=afs-fixes
David
---
Matthew Wilcox (Oracle) (3):
fs/cachefiles: Remove wait_bit_key layout dependency mm/writeback: Add wait_on_page_writeback_killable
afs: Use wait_on_page_writeback_killable
fs/afs/write.c | 3 +-- include/linux/pagemap.h | 1 + mm/page-writeback.c | 16 ++++++++++++++++ 3 files changed, 18 insertions(+), 2 deletions(-)
David Howells
maintainerPATCH 1/3 fs/cachefiles: Remove wait_bit_key layout dependency
From: Matthew Wilcox (Oracle) <[email protected]>
Cachefiles was relying on wait_page_key and wait_bit_key being the same layout, which is fragile. Now that wait_page_key is exposed in the pagemap.h header, we can remove that fragility
A comment on the need to maintain structure layout equivalence was added by Linus[1] and that is no longer applicable.
---
fs/cachefiles/rdwr.c | 7 +++---- include/linux/pagemap.h | 1 - 2 files changed, 3 insertions(+), 5 deletions(-)
fs/cachefiles/rdwr.c +3 -4
@@ -24,17 +24,16 @@ static int cachefiles_read_waiter(wait_queue_entry_t *wait, unsigned mode, container_of(wait, struct cachefiles_one_read, monitor);struct cachefiles_object *object;struct fscache_retrieval *op = monitor->op; -struct wait_bit_key *key = _key; +struct wait_page_key *key = _key;struct page *page = wait->private;ASSERT (key);_enter ("{%lu},%u,%d,{%p,%u}" , monitor->netfs_page->index, mode, sync, - key->flags, key->bit_nr); + key->page, key->bit_nr); -if (key->flags != &page->flags || - key->bit_nr != PG_locked) +if (key->page != page || key->bit_nr != PG_locked)return 0 ;_debug ("--- monitor %p %lx ---" , page, page->flags);
include/linux/pagemap.h +0 -1
@@ -559,7 +559,6 @@ static inline pgoff_t linear_page_index(struct vm_area_struct *vma,return pgoff; } -/* This has the same layout as wait_bit_key - see fs/cachefiles/rdwr.c */ struct wait_page_key {struct page *page;int bit_nr;
David Howells
maintainerPATCH 2/3 mm/writeback: Add wait_on_page_writeback_killable
In reply to David HowellsFrom: Matthew Wilcox (Oracle) <[email protected]>
This is the killable version of wait_on_page_writeback.
---
include/linux/pagemap.h | 1 + mm/page-writeback.c | 16 ++++++++++++++++ 2 files changed, 17 insertions(+)
include/linux/pagemap.h +1 -0
@@ -682,6 +682,7 @@ static inline int wait_on_page_locked_killable(struct page *page)int put_and_wait_on_page_locked (struct page *page,int state);void wait_on_page_writeback (struct page *page); +int wait_on_page_writeback_killable (struct page *page);extern void end_page_writeback (struct page *page);void wait_for_stable_page (struct page *page);
mm/page-writeback.c +16 -0
@@ -2833,6 +2833,22 @@ void wait_on_page_writeback(struct page *page) }EXPORT_SYMBOL_GPL (wait_on_page_writeback); +/* +* Wait for a page to complete writeback. Returns -EINTR if we get a +* fatal signal while waiting. +*/ +int wait_on_page_writeback_killable (struct page *page) +{ +while (PageWriteback (page)) { +trace_wait_on_page_writeback (page,page_mapping (page)); +if (wait_on_page_bit_killable (page, PG_writeback)) +return -EINTR ; + } + +return 0 ; +} +EXPORT_SYMBOL_GPL (wait_on_page_writeback_killable); +/** * wait_for_stable_page() - wait for writeback to finish, if necessary. * @page: The page to wait on.
David Howells
maintainerPATCH 3/3 afs: Use wait_on_page_writeback_killable
In reply to David HowellsFrom: Matthew Wilcox (Oracle) <[email protected]>
Open-coding this function meant it missed out on the recent bugfix for waiters being woken by a delayed wake event from a previous instantiation of the page.
[DH: Changed the patch to use vmf->page rather than variable page which
doesn't exist yet upstream]
---
fs/afs/write.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/afs/write.c +1 -2
@@ -851,8 +851,7 @@ vm_fault_t afs_page_mkwrite(struct vm_fault *vmf)fscache_wait_on_page_write (vnode->cache, vmf->page);#endif -if (PageWriteback (vmf->page) && -wait_on_page_bit_killable (vmf->page, PG_writeback) <0 ) +if (wait_on_page_writeback_killable (vmf->page))return VM_FAULT_RETRY ;if (lock_page_killable (vmf->page) <0 )
Matthew Wilcox
maintainerQuoted 12 lines · David Howells
Here are some patches to fix page waiting-related issues in cachefiles and afs[1]:
(1) In cachefiles, remove the use of the
wait_bit_keystruct to access something that's actually inwait_page_keyformat. The proper struct is now available in the header, so that should be used instead.(2) Add a proper wait function for waiting killably on the page writeback flag. This includes a recent bugfix here (presumably commit
c2407cf7d22d0c0d94cf20342b3b8f06f1d904e7).
Quoted 6 lines
(3) In afs, use the function added in (2) rather than using
wait_on_page_bit_killable()which doesn't have the aforementioned bugfix.Note that I modified this to work with the upstream code where the page pointer isn't cached in a local variable.
Thanks, the minor modifications to the patches (changelogs, fixes to apply to upstream) all look good to me.