12 files changed, 86 insertions, 29 deletions

diff --git a/Documentation/filesystems/Locking b/Documentation/filesystems/Locking
index 4fca82e5276..d5a269a51a9 100644
--- a/Documentation/filesystems/Locking
+++ b/Documentation/filesystems/Locking
@@ -62,6 +62,7 @@ ata *);
         int (*removexattr) (struct dentry *, const char *);
         void (*truncate_range)(struct inode *, loff_t, loff_t);
         int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, u64 len);
+        void (*update_time)(struct inode *, struct timespec *, int);
 
 locking rules:
         all may block
@@ -89,6 +90,8 @@ listxattr:	no
 removexattr:    yes
 truncate_range: yes
 fiemap:         no
+update_time:    no
+
         Additionally, ->rmdir(), ->unlink() and ->rename() have ->i_mutex on
 victim.
         cross-directory ->rename() has (per-superblock) ->s_vfs_rename_sem.
diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt
index 0d049202808..b2aa722e5ea 100644
--- a/Documentation/filesystems/vfs.txt
+++ b/Documentation/filesystems/vfs.txt
@@ -364,6 +364,7 @@ struct inode_operations {
         ssize_t (*listxattr) (struct dentry *, char *, size_t);
         int (*removexattr) (struct dentry *, const char *);
         void (*truncate_range)(struct inode *, loff_t, loff_t);
+        void (*update_time)(struct inode *, struct timespec *, int);
 };
 
 Again, all methods are called without any locks being held, unless
@@ -475,6 +476,9 @@ otherwise noted.
   truncate_range: a method provided by the underlying filesystem to truncate a
         range of blocks , i.e. punch a hole somewhere in a file.
 
+  update_time: called by the VFS to update a specific time or the i_version of
+        an inode.  If this is not defined the VFS will update the inode itself
+        and call mark_inode_dirty_sync.
 
 The Address Space Object
 ========================
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 504e61b7fd7..9562109d3a8 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -962,7 +962,9 @@ static ssize_t fuse_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
         if (err)
                 goto out;
 
-        file_update_time(file);
+        err = file_update_time(file);
+        if (err)
+                goto out;
 
         if (file->f_flags & O_DIRECT) {
                 written = generic_file_direct_write(iocb, iov, &nr_segs,
diff --git a/fs/inode.c b/fs/inode.c
index a79555e492e..f0335fc315e 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -1487,6 +1487,27 @@ static int relatime_need_update(struct vfsmount *mnt, struct inode *inode,
         return 0;
 }
 
+/*
+ * This does the actual work of updating an inodes time or version.  Must have
+ * had called mnt_want_write() before calling this.
+ */
+static int update_time(struct inode *inode, struct timespec *time, int flags)
+{
+        if (inode->i_op->update_time)
+                return inode->i_op->update_time(inode, time, flags);
+
+        if (flags & S_ATIME)
+                inode->i_atime = *time;
+        if (flags & S_VERSION)
+                inode_inc_iversion(inode);
+        if (flags & S_CTIME)
+                inode->i_ctime = *time;
+        if (flags & S_MTIME)
+                inode->i_mtime = *time;
+        mark_inode_dirty_sync(inode);
+        return 0;
+}
+
 /**
  *      touch_atime     -       update the access time
  *      @path: the &struct path to update
@@ -1524,8 +1545,14 @@ void touch_atime(struct path *path)
         if (mnt_want_write(mnt))
                 return;
 
-        inode->i_atime = now;
-        mark_inode_dirty_sync(inode);
+        /*
+         * File systems can error out when updating inodes if they need to
+         * allocate new space to modify an inode (such is the case for
+         * Btrfs), but since we touch atime while walking down the path we
+         * really don't care if we failed to update the atime of the file,
+         * so just ignore the return value.
+         */
+        update_time(inode, &now, S_ATIME);
         mnt_drop_write(mnt);
 }
 EXPORT_SYMBOL(touch_atime);
@@ -1604,18 +1631,20 @@ EXPORT_SYMBOL(file_remove_suid);
  *      usage in the file write path of filesystems, and filesystems may
  *      choose to explicitly ignore update via this function with the
  *      S_NOCMTIME inode flag, e.g. for network filesystem where these
- *      timestamps are handled by the server.
+ *      timestamps are handled by the server.  This can return an error for
+ *      file systems who need to allocate space in order to update an inode.
  */
 
-void file_update_time(struct file *file)
+int file_update_time(struct file *file)
 {
         struct inode *inode = file->f_path.dentry->d_inode;
         struct timespec now;
-        enum { S_MTIME = 1, S_CTIME = 2, S_VERSION = 4 } sync_it = 0;
+        int sync_it = 0;
+        int ret;
 
         /* First try to exhaust all avenues to not sync */
         if (IS_NOCMTIME(inode))
-                return;
+                return 0;
 
         now = current_fs_time(inode->i_sb);
         if (!timespec_equal(&inode->i_mtime, &now))
@@ -1628,21 +1657,16 @@ void file_update_time(struct file *file)
                 sync_it |= S_VERSION;
 
         if (!sync_it)
-                return;
+                return 0;
 
         /* Finally allowed to write? Takes lock. */
         if (mnt_want_write_file(file))
-                return;
+                return 0;
 
-        /* Only change inode inside the lock region */
-        if (sync_it & S_VERSION)
-                inode_inc_iversion(inode);
-        if (sync_it & S_CTIME)
-                inode->i_ctime = now;
-        if (sync_it & S_MTIME)
-                inode->i_mtime = now;
-        mark_inode_dirty_sync(inode);
+        ret = update_time(inode, &now, sync_it);
         mnt_drop_write_file(file);
+
+        return ret;
 }
 EXPORT_SYMBOL(file_update_time);
 
diff --git a/fs/ncpfs/file.c b/fs/ncpfs/file.c
index 3ff5fcc1528..122e260247f 100644
--- a/fs/ncpfs/file.c
+++ b/fs/ncpfs/file.c
@@ -221,6 +221,10 @@ ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *
 
         already_written = 0;
 
+        errno = file_update_time(file);
+        if (errno)
+                goto outrel;
+
         bouncebuffer = vmalloc(bufsize);
         if (!bouncebuffer) {
                 errno = -EIO;   /* -ENOMEM */
@@ -252,8 +256,6 @@ ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *
         }
         vfree(bouncebuffer);
 
-        file_update_time(file);
-
         *ppos = pos;
 
         if (pos > i_size_read(inode)) {
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index 8639169221c..7389d2d5e51 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -2096,7 +2096,9 @@ static ssize_t ntfs_file_aio_write_nolock(struct kiocb *iocb,
         err = file_remove_suid(file);
         if (err)
                 goto out;
-        file_update_time(file);
+        err = file_update_time(file);
+        if (err)
+                goto out;
         written = ntfs_file_buffered_write(iocb, iov, nr_segs, pos, ppos,
                         count);
 out:
diff --git a/fs/pipe.c b/fs/pipe.c
index 95ebb56de49..49c1065256f 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -654,8 +654,11 @@ out:
                 wake_up_interruptible_sync_poll(&pipe->wait, POLLIN | POLLRDNORM);
                 kill_fasync(&pipe->fasync_readers, SIGIO, POLL_IN);
         }
-        if (ret > 0)
-                file_update_time(filp);
+        if (ret > 0) {
+                int err = file_update_time(filp);
+                if (err)
+                        ret = err;
+        }
         return ret;
 }
 
diff --git a/fs/splice.c b/fs/splice.c
index f8476841eb0..47c4c1ad0c0 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -1003,8 +1003,10 @@ generic_file_splice_write(struct pipe_inode_info *pipe, struct file *out,
                 mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
                 ret = file_remove_suid(out);
                 if (!ret) {
-                        file_update_time(out);
-                        ret = splice_from_pipe_feed(pipe, &sd, pipe_to_file);
+                        ret = file_update_time(out);
+                        if (!ret)
+                                ret = splice_from_pipe_feed(pipe, &sd,
+                                                            pipe_to_file);
                 }
                 mutex_unlock(&inode->i_mutex);
         } while (ret > 0);
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 8d214b87f6b..9f7ec15a652 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -586,8 +586,11 @@ restart:
          * lock above.  Eventually we should look into a way to avoid
          * the pointless lock roundtrip.
          */
-        if (likely(!(file->f_mode & FMODE_NOCMTIME)))
-                file_update_time(file);
+        if (likely(!(file->f_mode & FMODE_NOCMTIME))) {
+                error = file_update_time(file);
+                if (error)
+                        return error;
+        }
 
         /*
          * If we're writing the file then make sure to clear the setuid and
diff --git a/include/linux/fs.h b/include/linux/fs.h
index cdc1a963094..57fc70574d2 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1684,6 +1684,7 @@ struct inode_operations {
         void (*truncate_range)(struct inode *, loff_t, loff_t);
         int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
                       u64 len);
+        int (*update_time)(struct inode *, struct timespec *, int);
 } ____cacheline_aligned;
 
 struct seq_file;
@@ -1843,6 +1844,13 @@ static inline void inode_inc_iversion(struct inode *inode)
        spin_unlock(&inode->i_lock);
 }
 
+enum file_time_flags {
+        S_ATIME = 1,
+        S_MTIME = 2,
+        S_CTIME = 4,
+        S_VERSION = 8,
+};
+
 extern void touch_atime(struct path *);
 static inline void file_accessed(struct file *file)
 {
@@ -2579,7 +2587,7 @@ extern int inode_change_ok(const struct inode *, struct iattr *);
 extern int inode_newsize_ok(const struct inode *, loff_t offset);
 extern void setattr_copy(struct inode *inode, const struct iattr *attr);
 
-extern void file_update_time(struct file *file);
+extern int file_update_time(struct file *file);
 
 extern int generic_show_options(struct seq_file *m, struct dentry *root);
 extern void save_mount_options(struct super_block *sb, char *options);
diff --git a/mm/filemap.c b/mm/filemap.c
index 21e5abfbcdf..51070f1f1b5 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2463,7 +2463,9 @@ ssize_t __generic_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
         if (err)
                 goto out;
 
-        file_update_time(file);
+        err = file_update_time(file);
+        if (err)
+                goto out;
 
         /* coalesce the iovecs and go direct-to-BIO for O_DIRECT */
         if (unlikely(file->f_flags & O_DIRECT)) {
diff --git a/mm/filemap_xip.c b/mm/filemap_xip.c
index a4eb3113222..213ca1f5340 100644
--- a/mm/filemap_xip.c
+++ b/mm/filemap_xip.c
@@ -426,7 +426,9 @@ xip_file_write(struct file *filp, const char __user *buf, size_t len,
         if (ret)
                 goto out_backing;
 
-        file_update_time(filp);
+        ret = file_update_time(filp);
+        if (ret)
+                goto out_backing;
 
         ret = __xip_file_write (filp, buf, count, pos, ppos);