1 files changed, 45 insertions, 32 deletions

diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index 7cfdcb913363..4074b952b059 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -448,15 +448,20 @@ static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
 {
         struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
 
-        if (!(file->f_flags & O_NOATIME)) {
+        if (!(file->f_flags & O_NOATIME) &&
+            !IS_NOATIME(&ip->i_inode)) {
                 struct gfs2_holder i_gh;
                 int error;
 
-                gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
+                gfs2_holder_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
                 error = gfs2_glock_nq(&i_gh);
-                file_accessed(file);
-                if (error == 0)
-                        gfs2_glock_dq_uninit(&i_gh);
+                if (error == 0) {
+                        file_accessed(file);
+                        gfs2_glock_dq(&i_gh);
+                }
+                gfs2_holder_uninit(&i_gh);
+                if (error)
+                        return error;
         }
         vma->vm_ops = &gfs2_vm_ops;
         vma->vm_flags |= VM_CAN_NONLINEAR;
@@ -617,8 +622,7 @@ static void empty_write_end(struct page *page, unsigned from,
 {
         struct gfs2_inode *ip = GFS2_I(page->mapping->host);
 
-        page_zero_new_buffers(page, from, to);
-        flush_dcache_page(page);
+        zero_user(page, from, to-from);
         mark_page_accessed(page);
 
         if (!gfs2_is_writeback(ip))
@@ -627,36 +631,43 @@ static void empty_write_end(struct page *page, unsigned from,
         block_commit_write(page, from, to);
 }
 
-static int write_empty_blocks(struct page *page, unsigned from, unsigned to)
+static int needs_empty_write(sector_t block, struct inode *inode)
 {
-        unsigned start, end, next;
-        struct buffer_head *bh, *head;
         int error;
+        struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
 
-        if (!page_has_buffers(page)) {
-                error = __block_write_begin(page, from, to - from, gfs2_block_map);
-                if (unlikely(error))
-                        return error;
+        bh_map.b_size = 1 << inode->i_blkbits;
+        error = gfs2_block_map(inode, block, &bh_map, 0);
+        if (unlikely(error))
+                return error;
+        return !buffer_mapped(&bh_map);
+}
 
-                empty_write_end(page, from, to);
-                return 0;
-        }
+static int write_empty_blocks(struct page *page, unsigned from, unsigned to)
+{
+        struct inode *inode = page->mapping->host;
+        unsigned start, end, next, blksize;
+        sector_t block = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
+        int ret;
 
-        bh = head = page_buffers(page);
+        blksize = 1 << inode->i_blkbits;
         next = end = 0;
         while (next < from) {
-                next += bh->b_size;
-                bh = bh->b_this_page;
+                next += blksize;
+                block++;
         }
         start = next;
         do {
-                next += bh->b_size;
-                if (buffer_mapped(bh)) {
+                next += blksize;
+                ret = needs_empty_write(block, inode);
+                if (unlikely(ret < 0))
+                        return ret;
+                if (ret == 0) {
                         if (end) {
-                                error = __block_write_begin(page, start, end - start,
-                                                            gfs2_block_map);
-                                if (unlikely(error))
-                                        return error;
+                                ret = __block_write_begin(page, start, end - start,
+                                                          gfs2_block_map);
+                                if (unlikely(ret))
+                                        return ret;
                                 empty_write_end(page, start, end);
                                 end = 0;
                         }
@@ -664,13 +675,13 @@ static int write_empty_blocks(struct page *page, unsigned from, unsigned to)
                 }
                 else
                         end = next;
-                bh = bh->b_this_page;
+                block++;
         } while (next < to);
 
         if (end) {
-                error = __block_write_begin(page, start, end - start, gfs2_block_map);
-                if (unlikely(error))
-                        return error;
+                ret = __block_write_begin(page, start, end - start, gfs2_block_map);
+                if (unlikely(ret))
+                        return ret;
                 empty_write_end(page, start, end);
         }
 
@@ -976,8 +987,10 @@ static void do_unflock(struct file *file, struct file_lock *fl)
 
         mutex_lock(&fp->f_fl_mutex);
         flock_lock_file_wait(file, fl);
-        if (fl_gh->gh_gl)
-                gfs2_glock_dq_uninit(fl_gh);
+        if (fl_gh->gh_gl) {
+                gfs2_glock_dq_wait(fl_gh);
+                gfs2_holder_uninit(fl_gh);
+        }
         mutex_unlock(&fp->f_fl_mutex);
 }