afs: Implement shared-writeable mmap

Implement shared-writeable mmap for AFS.

Signed-off-by: David Howells <dhowells@redhat.com>

3 files changed, 54 insertions, 9 deletions

diff --git a/fs/afs/file.c b/fs/afs/file.c
index c3a7bc1281f5..675c5c268a52 100644
--- a/fs/afs/file.c
+++ b/fs/afs/file.c
@@ -19,6 +19,7 @@
 #include <linux/task_io_accounting_ops.h>
 #include "internal.h"
 
+static int afs_file_mmap(struct file *file, struct vm_area_struct *vma);
 static int afs_readpage(struct file *file, struct page *page);
 static void afs_invalidatepage(struct page *page, unsigned int offset,
                                unsigned int length);
@@ -34,7 +35,7 @@ const struct file_operations afs_file_operations = {
         .llseek         = generic_file_llseek,
         .read_iter      = generic_file_read_iter,
         .write_iter     = afs_file_write,
-        .mmap           = generic_file_readonly_mmap,
+        .mmap           = afs_file_mmap,
         .splice_read    = generic_file_splice_read,
         .fsync          = afs_fsync,
         .lock           = afs_lock,
@@ -61,6 +62,12 @@ const struct address_space_operations afs_fs_aops = {
         .writepages     = afs_writepages,
 };
 
+static const struct vm_operations_struct afs_vm_ops = {
+        .fault          = filemap_fault,
+        .map_pages      = filemap_map_pages,
+        .page_mkwrite   = afs_page_mkwrite,
+};
+
 /*
  * Discard a pin on a writeback key.
  */
@@ -629,3 +636,16 @@ static int afs_releasepage(struct page *page, gfp_t gfp_flags)
         _leave(" = T");
         return 1;
 }
+
+/*
+ * Handle setting up a memory mapping on an AFS file.
+ */
+static int afs_file_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        int ret;
+
+        ret = generic_file_mmap(file, vma);
+        if (ret == 0)
+                vma->vm_ops = &afs_vm_ops;
+        return ret;
+}
diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index 688562ae3bf8..1de36e6abd5e 100644
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -886,6 +886,7 @@ extern void afs_pages_written_back(struct afs_vnode *, struct afs_call *);
 extern ssize_t afs_file_write(struct kiocb *, struct iov_iter *);
 extern int afs_flush(struct file *, fl_owner_t);
 extern int afs_fsync(struct file *, loff_t, loff_t, int);
+extern int afs_page_mkwrite(struct vm_fault *);
 extern void afs_prune_wb_keys(struct afs_vnode *);
 extern int afs_launder_page(struct page *);
 
diff --git a/fs/afs/write.c b/fs/afs/write.c
index 4c131371005b..6807277ef956 100644
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -749,21 +749,45 @@ int afs_flush(struct file *file, fl_owner_t id)
  * notification that a previously read-only page is about to become writable
  * - if it returns an error, the caller will deliver a bus error signal
  */
-int afs_page_mkwrite(struct vm_area_struct *vma, struct page *page)
+int afs_page_mkwrite(struct vm_fault *vmf)
 {
-        struct afs_vnode *vnode = AFS_FS_I(vma->vm_file->f_mapping->host);
+        struct file *file = vmf->vma->vm_file;
+        struct inode *inode = file_inode(file);
+        struct afs_vnode *vnode = AFS_FS_I(inode);
+        unsigned long priv;
 
         _enter("{{%x:%u}},{%lx}",
-               vnode->fid.vid, vnode->fid.vnode, page->index);
+               vnode->fid.vid, vnode->fid.vnode, vmf->page->index);
 
-        /* wait for the page to be written to the cache before we allow it to
-         * be modified */
+        sb_start_pagefault(inode->i_sb);
+
+        /* Wait for the page to be written to the cache before we allow it to
+         * be modified.  We then assume the entire page will need writing back.
+         */
 #ifdef CONFIG_AFS_FSCACHE
-        fscache_wait_on_page_write(vnode->cache, page);
+        fscache_wait_on_page_write(vnode->cache, vmf->page);
 #endif
 
-        _leave(" = 0");
-        return 0;
+        if (PageWriteback(vmf->page) &&
+            wait_on_page_bit_killable(vmf->page, PG_writeback) < 0)
+                return VM_FAULT_RETRY;
+
+        if (lock_page_killable(vmf->page) < 0)
+                return VM_FAULT_RETRY;
+
+        /* We mustn't change page->private until writeback is complete as that
+         * details the portion of the page we need to write back and we might
+         * need to redirty the page if there's a problem.
+         */
+        wait_on_page_writeback(vmf->page);
+
+        priv = (unsigned long)PAGE_SIZE << AFS_PRIV_SHIFT; /* To */
+        priv |= 0; /* From */
+        SetPagePrivate(vmf->page);
+        set_page_private(vmf->page, priv);
+
+        sb_end_pagefault(inode->i_sb);
+        return VM_FAULT_LOCKED;
 }
 
 /*