Merge tag 'dt2-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc

[cascardo/linux.git] / fs / gfs2 / file.c

diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index 7f4ed3d..6e600ab 100644 (file)
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -337,7 +337,8 @@ static void gfs2_size_hint(struct file *filep, loff_t offset, size_t size)
        size_t blks = (size + sdp->sd_sb.sb_bsize - 1) >> sdp->sd_sb.sb_bsize_shift;
        int hint = min_t(size_t, INT_MAX, blks);
 
-       atomic_set(&ip->i_res->rs_sizehint, hint);
+       if (hint > atomic_read(&ip->i_res->rs_sizehint))
+               atomic_set(&ip->i_res->rs_sizehint, hint);
 }
 
 /**
@@ -728,7 +729,6 @@ static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,
        struct gfs2_inode *ip = GFS2_I(inode);
        struct buffer_head *dibh;
        int error;
-       loff_t size = len;
        unsigned int nr_blks;
        sector_t lblock = offset >> inode->i_blkbits;
 
@@ -762,11 +762,6 @@ static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,
                        goto out;
                }
        }
-       if (offset + size > inode->i_size && !(mode & FALLOC_FL_KEEP_SIZE))
-               i_size_write(inode, offset + size);
-
-       mark_inode_dirty(inode);
-
 out:
        brelse(dibh);
        return error;
@@ -796,8 +791,7 @@ static void calc_max_reserv(struct gfs2_inode *ip, loff_t max, loff_t *len,
        }
 }
 
-static long gfs2_fallocate(struct file *file, int mode, loff_t offset,
-                          loff_t len)
+static long __gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
 {
        struct inode *inode = file_inode(file);
        struct gfs2_sbd *sdp = GFS2_SB(inode);
@@ -811,14 +805,9 @@ static long gfs2_fallocate(struct file *file, int mode, loff_t offset,
        loff_t bsize_mask = ~((loff_t)sdp->sd_sb.sb_bsize - 1);
        loff_t next = (offset + len - 1) >> sdp->sd_sb.sb_bsize_shift;
        loff_t max_chunk_size = UINT_MAX & bsize_mask;
-       struct gfs2_holder gh;
 
        next = (next + 1) << sdp->sd_sb.sb_bsize_shift;
 
-       /* We only support the FALLOC_FL_KEEP_SIZE mode */
-       if (mode & ~FALLOC_FL_KEEP_SIZE)
-               return -EOPNOTSUPP;
-
        offset &= bsize_mask;
 
        len = next - offset;
@@ -829,17 +818,6 @@ static long gfs2_fallocate(struct file *file, int mode, loff_t offset,
        if (bytes == 0)
                bytes = sdp->sd_sb.sb_bsize;
 
-       error = gfs2_rs_alloc(ip);
-       if (error)
-               return error;
-
-       mutex_lock(&inode->i_mutex);
-
-       gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
-       error = gfs2_glock_nq(&gh);
-       if (unlikely(error))
-               goto out_uninit;
-
        gfs2_size_hint(file, offset, len);
 
        while (len > 0) {
@@ -852,8 +830,7 @@ static long gfs2_fallocate(struct file *file, int mode, loff_t offset,
                }
                error = gfs2_quota_lock_check(ip);
                if (error)
-                       goto out_unlock;
-
+                       return error;
 retry:
                gfs2_write_calc_reserv(ip, bytes, &data_blocks, &ind_blocks);
 
@@ -895,44 +872,68 @@ retry:
                gfs2_quota_unlock(ip);
        }
 
-       if (error == 0)
-               error = generic_write_sync(file, pos, count);
-       goto out_unlock;
+       if (!(mode & FALLOC_FL_KEEP_SIZE) && (pos + count) > inode->i_size) {
+               i_size_write(inode, pos + count);
+               /* Marks the inode as dirty */
+               file_update_time(file);
+       }
+
+       return generic_write_sync(file, pos, count);
 
 out_trans_fail:
        gfs2_inplace_release(ip);
 out_qunlock:
        gfs2_quota_unlock(ip);
+       return error;
+}
+
+static long gfs2_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
+{
+       struct inode *inode = file_inode(file);
+       struct gfs2_inode *ip = GFS2_I(inode);
+       struct gfs2_holder gh;
+       int ret;
+
+       if (mode & ~FALLOC_FL_KEEP_SIZE)
+               return -EOPNOTSUPP;
+
+       mutex_lock(&inode->i_mutex);
+
+       gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
+       ret = gfs2_glock_nq(&gh);
+       if (ret)
+               goto out_uninit;
+
+       if (!(mode & FALLOC_FL_KEEP_SIZE) &&
+           (offset + len) > inode->i_size) {
+               ret = inode_newsize_ok(inode, offset + len);
+               if (ret)
+                       goto out_unlock;
+       }
+
+       ret = get_write_access(inode);
+       if (ret)
+               goto out_unlock;
+
+       ret = gfs2_rs_alloc(ip);
+       if (ret)
+               goto out_putw;
+
+       ret = __gfs2_fallocate(file, mode, offset, len);
+       if (ret)
+               gfs2_rs_deltree(ip->i_res);
+out_putw:
+       put_write_access(inode);
 out_unlock:
        gfs2_glock_dq(&gh);
 out_uninit:
        gfs2_holder_uninit(&gh);
        mutex_unlock(&inode->i_mutex);
-       return error;
+       return ret;
 }
 
 #ifdef CONFIG_GFS2_FS_LOCKING_DLM
 
-/**
- * gfs2_setlease - acquire/release a file lease
- * @file: the file pointer
- * @arg: lease type
- * @fl: file lock
- *
- * We don't currently have a way to enforce a lease across the whole
- * cluster; until we do, disable leases (by just returning -EINVAL),
- * unless the administrator has requested purely local locking.
- *
- * Locking: called under i_lock
- *
- * Returns: errno
- */
-
-static int gfs2_setlease(struct file *file, long arg, struct file_lock **fl)
-{
-       return -EINVAL;
-}
-
 /**
  * gfs2_lock - acquire/release a posix lock on a file
  * @file: the file pointer
@@ -1078,7 +1079,7 @@ const struct file_operations gfs2_file_fops = {
        .flock          = gfs2_flock,
        .splice_read    = generic_file_splice_read,
        .splice_write   = iter_file_splice_write,
-       .setlease       = gfs2_setlease,
+       .setlease       = simple_nosetlease,
        .fallocate      = gfs2_fallocate,
 };