Skip to contentSkip to conversation

cachefiles, afs: mm wait fixes

PATCH In review David Howells 2 participants 5 messages Mar 23, 2021

Subsystems (5)
lore
Share & tools
lore

David Howells

author maintainer
#0 lore raw

cover 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(-)
author maintainer
#1 lore raw

PATCH 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
index e027c718ca01..8ffc40e84a59 100644
@@ -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
index 20225b067583..8f4daac6eb4b 100644
@@ -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;
author maintainer
#2 lore raw

PATCH 2/3 mm/writeback: Add wait_on_page_writeback_killable

In reply to David Howells

From: 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
index 8f4daac6eb4b..8c9947fd62f3 100644
@@ -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
index eb34d204d4ee..9e35b636a393 100644
@@ -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.
author maintainer
#3 lore raw

PATCH 3/3 afs: Use wait_on_page_writeback_killable

In reply to David Howells

From: 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
index c9195fc67fd8..eb737ed63afb 100644
@@ -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)
maintainer
#4 lore raw
In reply to David Howells
Quoted 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_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).

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.