afs: Do better accretion of small writes on newly created content

Processes like ld that do lots of small writes that aren't necessarily
contiguous result in a lot of small StoreData operations to the server, the
idea being that if someone else changes the data on the server, we only
write our changes over that and not the space between.  Further, we don't
want to write back empty space if we can avoid it to make it easier for the
server to do sparse files.

However, making lots of tiny RPC ops is a lot less efficient for the server
than one big one because each op requires allocation of resources and the
taking of locks, so we want to compromise a bit.

Reduce the load by the following:

 (1) If a file is just created locally or has just been truncated with
     O_TRUNC locally, allow subsequent writes to the file to be merged with
     intervening space if that space doesn't cross an entire intervening
     page.

 (2) Don't flush the file on ->flush() but rather on ->release() if the
     file was open for writing.

Just linking vmlinux.o, without this patch, looking in /proc/fs/afs/stats:

	file-wr : n=441 nb=513581204

and after the patch:

	file-wr : n=62 nb=513668555

there were 379 fewer StoreData RPC operations at the expense of an extra
87K being written.

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

diff --git a/fs/afs/callback.c b/fs/afs/callback.c
index 6049ca8374984f0026c46d11b85a0cf8daf32559..abd9a84f4e88a6dbded5eb02aa75e46a239a4c56 100644 (file)
--- a/fs/afs/callback.c
+++ b/fs/afs/callback.c
@@ -130,6 +130,7 @@ void afs_break_callback(struct afs_vnode *vnode)
 
        write_seqlock(&vnode->cb_lock);
 
+       clear_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);
        if (test_and_clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
                vnode->cb_break++;
                afs_clear_permits(vnode);

diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index 43bb3b23a87940c1aba72ac4f03d54fa132b6a48..5889f70d4d273a8622aefbd32148e8ff8e1b7d55 100644 (file)
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -1092,6 +1092,7 @@ static void afs_vnode_new_inode(struct afs_fs_cursor *fc,
                                struct afs_file_status *newstatus,
                                struct afs_callback *newcb)
 {
+       struct afs_vnode *vnode;
        struct inode *inode;
 
        if (fc->ac.error < 0)
@@ -1109,6 +1110,8 @@ static void afs_vnode_new_inode(struct afs_fs_cursor *fc,
                return;
        }
 
+       vnode = AFS_FS_I(inode);
+       set_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);
        d_add(new_dentry, inode);
 }
 

diff --git a/fs/afs/file.c b/fs/afs/file.c
index e5cac1bc3cf0b07d85a620976f144dede454e6af..c24c08016dd96e2309ce9e8052d643b2af6da2a6 100644 (file)
--- a/fs/afs/file.c
+++ b/fs/afs/file.c
@@ -30,7 +30,6 @@ static int afs_readpages(struct file *filp, struct address_space *mapping,
 
 const struct file_operations afs_file_operations = {
        .open           = afs_open,
-       .flush          = afs_flush,
        .release        = afs_release,
        .llseek         = generic_file_llseek,
        .read_iter      = generic_file_read_iter,
@@ -146,6 +145,9 @@ int afs_open(struct inode *inode, struct file *file)
                if (ret < 0)
                        goto error_af;
        }
+
+       if (file->f_flags & O_TRUNC)
+               set_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);
        
        file->private_data = af;
        _leave(" = 0");
@@ -170,6 +172,9 @@ int afs_release(struct inode *inode, struct file *file)
 
        _enter("{%x:%u},", vnode->fid.vid, vnode->fid.vnode);
 
+       if ((file->f_mode & FMODE_WRITE))
+               return vfs_fsync(file, 0);
+
        file->private_data = NULL;
        if (af->wb)
                afs_put_wb_key(af->wb);

diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index f6b44f47732d23dd4dd62aaeaf7d72be3a46d65d..f8086ec95e24161eb9b9900745275e1cc4c1cfc6 100644 (file)
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -506,6 +506,7 @@ struct afs_vnode {
 #define AFS_VNODE_MOUNTPOINT   5               /* set if vnode is a mountpoint symlink */
 #define AFS_VNODE_AUTOCELL     6               /* set if Vnode is an auto mount point */
 #define AFS_VNODE_PSEUDODIR    7               /* set if Vnode is a pseudo directory */
+#define AFS_VNODE_NEW_CONTENT  8               /* Set if file has new content (create/trunc-0) */
 
        struct list_head        wb_keys;        /* List of keys available for writeback */
        struct list_head        pending_locks;  /* locks waiting to be granted */
@@ -1026,7 +1027,6 @@ extern int afs_writepage(struct page *, struct writeback_control *);
 extern int afs_writepages(struct address_space *, struct writeback_control *);
 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 *);

diff --git a/fs/afs/write.c b/fs/afs/write.c
index eccc16198f68363f738c89ce58c4c5880f3c1524..160f6cc26c008a1c906211288178fb9176e5066c 100644 (file)
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -125,7 +125,12 @@ try_again:
                                             page->index, priv);
                        goto flush_conflicting_write;
                }
-               if (to < f || from > t)
+               /* If the file is being filled locally, allow inter-write
+                * spaces to be merged into writes.  If it's not, only write
+                * back what the user gives us.
+                */
+               if (!test_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags) &&
+                   (to < f || from > t))
                        goto flush_conflicting_write;
                if (from < f)
                        f = from;
@@ -419,7 +424,8 @@ static int afs_write_back_from_locked_page(struct address_space *mapping,
                trace_afs_page_dirty(vnode, tracepoint_string("WARN"),
                                     primary_page->index, priv);
 
-       if (start >= final_page || to < PAGE_SIZE)
+       if (start >= final_page ||
+           (to < PAGE_SIZE && !test_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags)))
                goto no_more;
 
        start++;
@@ -440,9 +446,10 @@ static int afs_write_back_from_locked_page(struct address_space *mapping,
                }
 
                for (loop = 0; loop < n; loop++) {
-                       if (to != PAGE_SIZE)
-                               break;
                        page = pages[loop];
+                       if (to != PAGE_SIZE &&
+                           !test_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags))
+                               break;
                        if (page->index > final_page)
                                break;
                        if (!trylock_page(page))
@@ -455,7 +462,8 @@ static int afs_write_back_from_locked_page(struct address_space *mapping,
                        priv = page_private(page);
                        f = priv & AFS_PRIV_MAX;
                        t = priv >> AFS_PRIV_SHIFT;
-                       if (f != 0) {
+                       if (f != 0 &&
+                           !test_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags)) {
                                unlock_page(page);
                                break;
                        }
@@ -740,20 +748,6 @@ int afs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
        return file_write_and_wait_range(file, start, end);
 }
 
-/*
- * Flush out all outstanding writes on a file opened for writing when it is
- * closed.
- */
-int afs_flush(struct file *file, fl_owner_t id)
-{
-       _enter("");
-
-       if ((file->f_mode & FMODE_WRITE) == 0)
-               return 0;
-
-       return vfs_fsync(file, 0);
-}
-
 /*
  * 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