Merge tag 'iio-fixes-for-4.4a' of ssh://ra.kernel.org/pub/scm/linux/kernel/git/jic23...

[firefly-linux-kernel-4.4.55.git] / fs / ocfs2 / file.c

diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 7210583b472f52d054f89802a893dfd45ce203ac..0e5b4515f92e7a875a6f396db0d5648c9c157ad1 100644 (file)
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -1130,6 +1130,7 @@ out:
 int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
 {
        int status = 0, size_change;
+       int inode_locked = 0;
        struct inode *inode = d_inode(dentry);
        struct super_block *sb = inode->i_sb;
        struct ocfs2_super *osb = OCFS2_SB(sb);
@@ -1178,6 +1179,7 @@ int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
                        mlog_errno(status);
                goto bail_unlock_rw;
        }
+       inode_locked = 1;
 
        if (size_change) {
                status = inode_newsize_ok(inode, attr->ia_size);
@@ -1258,7 +1260,10 @@ int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
 bail_commit:
        ocfs2_commit_trans(osb, handle);
 bail_unlock:
-       ocfs2_inode_unlock(inode, 1);
+       if (status) {
+               ocfs2_inode_unlock(inode, 1);
+               inode_locked = 0;
+       }
 bail_unlock_rw:
        if (size_change)
                ocfs2_rw_unlock(inode, 1);
@@ -1274,6 +1279,8 @@ bail:
                if (status < 0)
                        mlog_errno(status);
        }
+       if (inode_locked)
+               ocfs2_inode_unlock(inode, 1);
 
        return status;
 }
@@ -2262,8 +2269,6 @@ static ssize_t ocfs2_file_write_iter(struct kiocb *iocb,
        ssize_t written = 0;
        ssize_t ret;
        size_t count = iov_iter_count(from), orig_count;
-       loff_t old_size;
-       u32 old_clusters;
        struct file *file = iocb->ki_filp;
        struct inode *inode = file_inode(file);
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
@@ -2271,6 +2276,8 @@ static ssize_t ocfs2_file_write_iter(struct kiocb *iocb,
                               OCFS2_MOUNT_COHERENCY_BUFFERED);
        int unaligned_dio = 0;
        int dropped_dio = 0;
+       int append_write = ((iocb->ki_pos + count) >=
+                       i_size_read(inode) ? 1 : 0);
 
        trace_ocfs2_file_aio_write(inode, file, file->f_path.dentry,
                (unsigned long long)OCFS2_I(inode)->ip_blkno,
@@ -2290,8 +2297,9 @@ relock:
        /*
         * Concurrent O_DIRECT writes are allowed with
         * mount_option "coherency=buffered".
+        * For append write, we must take rw EX.
         */
-       rw_level = (!direct_io || full_coherency);
+       rw_level = (!direct_io || full_coherency || append_write);
 
        ret = ocfs2_rw_lock(inode, rw_level);
        if (ret < 0) {
@@ -2364,13 +2372,6 @@ relock:
                ocfs2_iocb_set_unaligned_aio(iocb);
        }
 
-       /*
-        * To later detect whether a journal commit for sync writes is
-        * necessary, we sample i_size, and cluster count here.
-        */
-       old_size = i_size_read(inode);
-       old_clusters = OCFS2_I(inode)->ip_clusters;
-
        /* communicate with ocfs2_dio_end_io */
        ocfs2_iocb_set_rw_locked(iocb, rw_level);
 
@@ -2378,6 +2379,20 @@ relock:
        /* buffered aio wouldn't have proper lock coverage today */
        BUG_ON(written == -EIOCBQUEUED && !(iocb->ki_flags & IOCB_DIRECT));
 
+       /*
+        * deep in g_f_a_w_n()->ocfs2_direct_IO we pass in a ocfs2_dio_end_io
+        * function pointer which is called when o_direct io completes so that
+        * it can unlock our rw lock.
+        * Unfortunately there are error cases which call end_io and others
+        * that don't.  so we don't have to unlock the rw_lock if either an
+        * async dio is going to do it in the future or an end_io after an
+        * error has already done it.
+        */
+       if ((written == -EIOCBQUEUED) || (!ocfs2_iocb_is_rw_locked(iocb))) {
+               rw_level = -1;
+               unaligned_dio = 0;
+       }
+
        if (unlikely(written <= 0))
                goto no_sync;
 
@@ -2402,21 +2417,7 @@ relock:
        }
 
 no_sync:
-       /*
-        * deep in g_f_a_w_n()->ocfs2_direct_IO we pass in a ocfs2_dio_end_io
-        * function pointer which is called when o_direct io completes so that
-        * it can unlock our rw lock.
-        * Unfortunately there are error cases which call end_io and others
-        * that don't.  so we don't have to unlock the rw_lock if either an
-        * async dio is going to do it in the future or an end_io after an
-        * error has already done it.
-        */
-       if ((ret == -EIOCBQUEUED) || (!ocfs2_iocb_is_rw_locked(iocb))) {
-               rw_level = -1;
-               unaligned_dio = 0;
-       }
-
-       if (unaligned_dio) {
+       if (unaligned_dio && ocfs2_iocb_is_unaligned_aio(iocb)) {
                ocfs2_iocb_clear_unaligned_aio(iocb);
                mutex_unlock(&OCFS2_I(inode)->ip_unaligned_aio);
        }