1 files changed, 169 insertions, 91 deletions

diff --git a/fs/gfs2/ops_address.c b/fs/gfs2/ops_address.c
index d611b2ad2e97..b14357e89421 100644
--- a/fs/gfs2/ops_address.c
+++ b/fs/gfs2/ops_address.c
@@ -20,13 +20,13 @@
 #include "bmap.h"
 #include "glock.h"
 #include "inode.h"
-#include "jdata.h"
 #include "log.h"
 #include "meta_io.h"
 #include "ops_address.h"
 #include "page.h"
 #include "quota.h"
 #include "trans.h"
+#include "rgrp.h"
 
 /**
  * gfs2_get_block - Fills in a buffer head with details about a block
@@ -149,33 +149,55 @@ static int get_blocks_noalloc(struct inode *inode, sector_t lblock,
  *
  * Returns: errno
  *
- * Use Linux VFS block_write_full_page() to write one page,
- *   using GFS2's get_block_noalloc to find which blocks to write.
+ * Some of this is copied from block_write_full_page() although we still
+ * call it to do most of the work.
  */
 
 static int gfs2_writepage(struct page *page, struct writeback_control *wbc)
 {
+        struct inode *inode = page->mapping->host;
         struct gfs2_inode *ip = get_v2ip(page->mapping->host);
         struct gfs2_sbd *sdp = ip->i_sbd;
+        loff_t i_size = i_size_read(inode);
+        pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
+        unsigned offset;
         int error;
+        int done_trans = 0;
 
         atomic_inc(&sdp->sd_ops_address);
-
         if (gfs2_assert_withdraw(sdp, gfs2_glock_is_held_excl(ip->i_gl))) {
                 unlock_page(page);
                 return -EIO;
         }
-        if (get_transaction) {
-                redirty_page_for_writepage(wbc, page);
+        if (get_transaction)
+                goto out_ignore;
+
+        /* Is the page fully outside i_size? (truncate in progress) */
+        offset = i_size & (PAGE_CACHE_SIZE-1);
+        if (page->index >= end_index+1 || !offset) {
+                page->mapping->a_ops->invalidatepage(page, 0);
                 unlock_page(page);
-                return 0;
+                return 0; /* don't care */
         }
 
-        error = block_write_full_page(page, get_block_noalloc, wbc);
+        if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip)) {
+                error = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);
+                if (error)
+                        goto out_ignore;
+                gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);
+                done_trans = 1;
+        }
 
+        error = block_write_full_page(page, get_block_noalloc, wbc);
+        if (done_trans)
+                gfs2_trans_end(sdp);
         gfs2_meta_cache_flush(ip);
-
         return error;
+
+out_ignore:
+        redirty_page_for_writepage(wbc, page);
+        unlock_page(page);
+        return 0;
 }
 
 /**
@@ -227,40 +249,9 @@ static int zero_readpage(struct page *page)
 }
 
 /**
- * jdata_readpage - readpage that goes through gfs2_jdata_read_mem()
- * @ip:
- * @page: The page to read
- *
- * Returns: errno
- */
-
-static int jdata_readpage(struct gfs2_inode *ip, struct page *page)
-{
-        void *kaddr;
-        int ret;
-
-        kaddr = kmap(page);
-
-        ret = gfs2_jdata_read_mem(ip, kaddr,
-                                  (uint64_t)page->index << PAGE_CACHE_SHIFT,
-                                  PAGE_CACHE_SIZE);
-        if (ret >= 0) {
-                if (ret < PAGE_CACHE_SIZE)
-                        memset(kaddr + ret, 0, PAGE_CACHE_SIZE - ret);
-                SetPageUptodate(page);
-                ret = 0;
-        }
-
-        kunmap(page);
-
-        unlock_page(page);
-
-        return ret;
-}
-
-/**
  * gfs2_readpage - readpage with locking
- * @file: The file to read a page for
+ * @file: The file to read a page for. N.B. This may be NULL if we are
+ * reading an internal file.
  * @page: The page to read
  *
  * Returns: errno
@@ -270,31 +261,35 @@ static int gfs2_readpage(struct file *file, struct page *page)
 {
         struct gfs2_inode *ip = get_v2ip(page->mapping->host);
         struct gfs2_sbd *sdp = ip->i_sbd;
+        struct gfs2_holder gh;
         int error;
 
         atomic_inc(&sdp->sd_ops_address);
 
-        if (gfs2_assert_warn(sdp, gfs2_glock_is_locked_by_me(ip->i_gl))) {
-                unlock_page(page);
-                return -EOPNOTSUPP;
-        }
+        gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
+        error = gfs2_glock_nq_m_atime(1, &gh);
+        if (error)
+                goto out_unlock;
 
-        if (!gfs2_is_jdata(ip)) {
-                if (gfs2_is_stuffed(ip)) {
-                        if (!page->index) {
-                                error = stuffed_readpage(ip, page);
-                                unlock_page(page);
-                        } else
-                                error = zero_readpage(page);
+        if (gfs2_is_stuffed(ip)) {
+                if (!page->index) {
+                        error = stuffed_readpage(ip, page);
+                        unlock_page(page);
                 } else
-                        error = mpage_readpage(page, gfs2_get_block);
+                        error = zero_readpage(page);
         } else
-                error = jdata_readpage(ip, page);
+                error = mpage_readpage(page, gfs2_get_block);
 
         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
                 error = -EIO;
 
+        gfs2_glock_dq_m(1, &gh);
+        gfs2_holder_uninit(&gh);
+out:
         return error;
+out_unlock:
+        unlock_page(page);
+        goto out;
 }
 
 /**
@@ -312,28 +307,82 @@ static int gfs2_prepare_write(struct file *file, struct page *page,
 {
         struct gfs2_inode *ip = get_v2ip(page->mapping->host);
         struct gfs2_sbd *sdp = ip->i_sbd;
+        unsigned int data_blocks, ind_blocks, rblocks;
+        int alloc_required;
         int error = 0;
+        loff_t pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + from;
+        loff_t end = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
+        struct gfs2_alloc *al;
 
         atomic_inc(&sdp->sd_ops_address);
 
-        if (gfs2_assert_warn(sdp, gfs2_glock_is_locked_by_me(ip->i_gl)))
-                return -EOPNOTSUPP;
+        gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_ATIME, &ip->i_gh);
+        error = gfs2_glock_nq_m_atime(1, &ip->i_gh);
+        if (error)
+                goto out_uninit;
 
-        if (gfs2_is_stuffed(ip)) {
-                uint64_t file_size;
-                file_size = ((uint64_t)page->index << PAGE_CACHE_SHIFT) + to;
+        gfs2_write_calc_reserv(ip, to - from, &data_blocks, &ind_blocks);
+
+        error = gfs2_write_alloc_required(ip, pos, from - to, &alloc_required);
+        if (error)
+                goto out_unlock;
 
-                if (file_size > sdp->sd_sb.sb_bsize -
-                                sizeof(struct gfs2_dinode)) {
-                        error = gfs2_unstuff_dinode(ip, gfs2_unstuffer_page,
-                                                    page);
-                        if (!error)
-                                error = block_prepare_write(page, from, to,
-                                                            gfs2_get_block);
-                } else if (!PageUptodate(page))
+
+        if (alloc_required) {
+                al = gfs2_alloc_get(ip);
+
+                error = gfs2_quota_lock(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
+                if (error)
+                        goto out_alloc_put;
+
+                error = gfs2_quota_check(ip, ip->i_di.di_uid, ip->i_di.di_gid);
+                if (error)
+                        goto out_qunlock;
+
+                al->al_requested = data_blocks + ind_blocks;
+                error = gfs2_inplace_reserve(ip);
+                if (error)
+                        goto out_qunlock;
+        }
+
+        rblocks = RES_DINODE + ind_blocks;
+        if (gfs2_is_jdata(ip))
+                rblocks += data_blocks ? data_blocks : 1;
+        if (ind_blocks || data_blocks)
+                rblocks += RES_STATFS + RES_QUOTA;
+
+        error = gfs2_trans_begin(sdp, rblocks, 0);
+        if (error)
+                goto out;
+
+        if (gfs2_is_stuffed(ip)) {
+                if (end > sdp->sd_sb.sb_bsize - sizeof(struct gfs2_dinode)) {
+                        error = gfs2_unstuff_dinode(ip, gfs2_unstuffer_page, page);
+                        if (error)
+                                goto out;
+                } else if (!PageUptodate(page)) {
                         error = stuffed_readpage(ip, page);
-        } else
-                error = block_prepare_write(page, from, to, gfs2_get_block);
+                        goto out;
+                }
+        }
+
+        error = block_prepare_write(page, from, to, gfs2_get_block);
+
+out:
+        if (error) {
+                gfs2_trans_end(sdp);
+                if (alloc_required) {
+                        gfs2_inplace_release(ip);
+out_qunlock:
+                        gfs2_quota_unlock(ip);
+out_alloc_put:
+                        gfs2_alloc_put(ip);
+                }
+out_unlock:
+                gfs2_glock_dq_m(1, &ip->i_gh);
+out_uninit:
+                gfs2_holder_uninit(&ip->i_gh);
+        }
 
         return error;
 }
@@ -354,48 +403,73 @@ static int gfs2_commit_write(struct file *file, struct page *page,
         struct inode *inode = page->mapping->host;
         struct gfs2_inode *ip = get_v2ip(inode);
         struct gfs2_sbd *sdp = ip->i_sbd;
-        int error;
+        int error = -EOPNOTSUPP;
+        struct buffer_head *dibh;
+        struct gfs2_alloc *al = &ip->i_alloc;;
 
         atomic_inc(&sdp->sd_ops_address);
 
+
+        if (gfs2_assert_withdraw(sdp, gfs2_glock_is_locked_by_me(ip->i_gl)))
+                goto fail_nounlock;
+
+        error = gfs2_meta_inode_buffer(ip, &dibh);
+        if (error)
+                goto fail_endtrans;
+
+        gfs2_trans_add_bh(ip->i_gl, dibh, 1);
+
         if (gfs2_is_stuffed(ip)) {
-                struct buffer_head *dibh;
                 uint64_t file_size;
                 void *kaddr;
 
                 file_size = ((uint64_t)page->index << PAGE_CACHE_SHIFT) + to;
 
-                error = gfs2_meta_inode_buffer(ip, &dibh);
-                if (error)
-                        goto fail;
-
-                gfs2_trans_add_bh(ip->i_gl, dibh, 1);
-
-                kaddr = kmap(page);
+                kaddr = kmap_atomic(page, KM_USER0);
                 memcpy(dibh->b_data + sizeof(struct gfs2_dinode) + from,
-                       (char *)kaddr + from,
-                       to - from);
-                kunmap(page);
-
-                brelse(dibh);
+                       (char *)kaddr + from, to - from);
+                kunmap_atomic(page, KM_USER0);
 
                 SetPageUptodate(page);
 
                 if (inode->i_size < file_size)
                         i_size_write(inode, file_size);
         } else {
-                if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED)
+                if (sdp->sd_args.ar_data == GFS2_DATA_ORDERED || gfs2_is_jdata(ip))
                         gfs2_page_add_databufs(ip, page, from, to);
                 error = generic_commit_write(file, page, from, to);
                 if (error)
                         goto fail;
         }
 
+        if (ip->i_di.di_size < inode->i_size)
+                ip->i_di.di_size = inode->i_size;
+
+        gfs2_dinode_out(&ip->i_di, dibh->b_data);
+        brelse(dibh);
+        gfs2_trans_end(sdp);
+        if (al->al_requested) {
+                gfs2_inplace_release(ip);
+                gfs2_quota_unlock(ip);
+                gfs2_alloc_put(ip);
+        }
+        gfs2_glock_dq_m(1, &ip->i_gh);
+        gfs2_holder_uninit(&ip->i_gh);
         return 0;
 
- fail:
+fail:
+        brelse(dibh);
+fail_endtrans:
+        gfs2_trans_end(sdp);
+        if (al->al_requested) {
+                gfs2_inplace_release(ip);
+                gfs2_quota_unlock(ip);
+                gfs2_alloc_put(ip);
+        }
+        gfs2_glock_dq_m(1, &ip->i_gh);
+        gfs2_holder_uninit(&ip->i_gh);
+fail_nounlock:
         ClearPageUptodate(page);
-
         return error;
 }
 
@@ -492,12 +566,16 @@ static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb, const struct iovec *io
 
         atomic_inc(&sdp->sd_ops_address);
 
-        if (gfs2_assert_warn(sdp, gfs2_glock_is_locked_by_me(ip->i_gl)) ||
-            gfs2_assert_warn(sdp, !gfs2_is_stuffed(ip)))
+        if (gfs2_is_jdata(ip))
                 return -EINVAL;
 
-        if (rw == WRITE && !get_transaction)
-                gb = get_blocks_noalloc;
+        if (rw == WRITE) {
+                return -EOPNOTSUPP; /* for now */
+        } else {
+                if (gfs2_assert_warn(sdp, gfs2_glock_is_locked_by_me(ip->i_gl)) ||
+                    gfs2_assert_warn(sdp, !gfs2_is_stuffed(ip)))
+                        return -EINVAL;
+        }
 
         return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
                                   offset, nr_segs, gb, NULL);