Merge tag 'gfs2-merge-window' of git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-3.0-nmw

Pull GFS2 updates from Steven Whitehouse:
 "The main topics this time are allocation, in the form of Bob's
  improvements when searching resource groups and several updates to
  quotas which should increase scalability.  The quota changes follow on
  from those in the last merge window, and there will likely be further
  work to come in this area in due course.

  There are also a few patches which help to improve efficiency of
  adding entries into directories, and clean up some of that code.

  One on-disk change is included this time, which is to write some
  additional information which should be useful to fsck and also
  potentially for debugging.

  Other than that, its just a few small random bug fixes and clean ups"

* tag 'gfs2-merge-window' of git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-3.0-nmw: (24 commits)
  GFS2: revert "GFS2: d_splice_alias() can't return error"
  GFS2: Small cleanup
  GFS2: Don't use ENOBUFS when ENOMEM is the correct error code
  GFS2: Fix kbuild test robot reported warning
  GFS2: Move quota bitmap operations under their own lock
  GFS2: Clean up quota slot allocation
  GFS2: Only run logd and quota when mounted read/write
  GFS2: Use RCU/hlist_bl based hash for quotas
  GFS2: No need to invalidate pages for a dio read
  GFS2: Add initialization for address space in super block
  GFS2: Add hints to directory leaf blocks
  GFS2: For exhash conversion, only one block is needed
  GFS2: Increase i_writecount during gfs2_setattr_chown
  GFS2: Remember directory insert point
  GFS2: Consolidate transaction blocks calculation for dir add
  GFS2: Add directory addition info structure
  GFS2: Use only a single address space for rgrps
  GFS2: Use range based functions for rgrp sync/invalidation
  GFS2: Remove test which is always true
  GFS2: Remove gfs2_quota_change_host structure
  ...

18 files changed, 550 insertions, 359 deletions

diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
index 73f3e4ee4037..49436fa7cd4f 100644
--- a/fs/gfs2/aops.c
+++ b/fs/gfs2/aops.c
@@ -1032,8 +1032,9 @@ static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,
                         unmap_shared_mapping_range(ip->i_inode.i_mapping, offset, len);
                 rv = filemap_write_and_wait_range(mapping, lstart, end);
                 if (rv)
-                        return rv;
-                truncate_inode_pages_range(mapping, lstart, end);
+                        goto out;
+                if (rw == WRITE)
+                        truncate_inode_pages_range(mapping, lstart, end);
         }
 
         rv = __blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
@@ -1080,30 +1081,22 @@ int gfs2_releasepage(struct page *page, gfp_t gfp_mask)
                 bh = bh->b_this_page;
         } while(bh != head);
         spin_unlock(&sdp->sd_ail_lock);
-        gfs2_log_unlock(sdp);
 
         head = bh = page_buffers(page);
         do {
-                gfs2_log_lock(sdp);
                 bd = bh->b_private;
                 if (bd) {
                         gfs2_assert_warn(sdp, bd->bd_bh == bh);
-                        if (!list_empty(&bd->bd_list)) {
-                                if (!buffer_pinned(bh))
-                                        list_del_init(&bd->bd_list);
-                                else
-                                        bd = NULL;
-                        }
-                        if (bd)
-                                bd->bd_bh = NULL;
+                        if (!list_empty(&bd->bd_list))
+                                list_del_init(&bd->bd_list);
+                        bd->bd_bh = NULL;
                         bh->b_private = NULL;
-                }
-                gfs2_log_unlock(sdp);
-                if (bd)
                         kmem_cache_free(gfs2_bufdata_cachep, bd);
+                }
 
                 bh = bh->b_this_page;
         } while (bh != head);
+        gfs2_log_unlock(sdp);
 
         return try_to_free_buffers(page);
 
diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index 2e5fc268d324..fa32655449c8 100644
--- a/fs/gfs2/dir.c
+++ b/fs/gfs2/dir.c
@@ -834,6 +834,7 @@ static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh,
         struct gfs2_leaf *leaf;
         struct gfs2_dirent *dent;
         struct qstr name = { .name = "" };
+        struct timespec tv = CURRENT_TIME;
 
         error = gfs2_alloc_blocks(ip, &bn, &n, 0, NULL);
         if (error)
@@ -850,7 +851,11 @@ static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh,
         leaf->lf_entries = 0;
         leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
         leaf->lf_next = 0;
-        memset(leaf->lf_reserved, 0, sizeof(leaf->lf_reserved));
+        leaf->lf_inode = cpu_to_be64(ip->i_no_addr);
+        leaf->lf_dist = cpu_to_be32(1);
+        leaf->lf_nsec = cpu_to_be32(tv.tv_nsec);
+        leaf->lf_sec = cpu_to_be64(tv.tv_sec);
+        memset(leaf->lf_reserved2, 0, sizeof(leaf->lf_reserved2));
         dent = (struct gfs2_dirent *)(leaf+1);
         gfs2_qstr2dirent(&name, bh->b_size - sizeof(struct gfs2_leaf), dent);
         *pbh = bh;
@@ -1612,11 +1617,31 @@ out:
         return ret;
 }
 
+/**
+ * dir_new_leaf - Add a new leaf onto hash chain
+ * @inode: The directory
+ * @name: The name we are adding
+ *
+ * This adds a new dir leaf onto an existing leaf when there is not
+ * enough space to add a new dir entry. This is a last resort after
+ * we've expanded the hash table to max size and also split existing
+ * leaf blocks, so it will only occur for very large directories.
+ *
+ * The dist parameter is set to 1 for leaf blocks directly attached
+ * to the hash table, 2 for one layer of indirection, 3 for two layers
+ * etc. We are thus able to tell the difference between an old leaf
+ * with dist set to zero (i.e. "don't know") and a new one where we
+ * set this information for debug/fsck purposes.
+ *
+ * Returns: 0 on success, or -ve on error
+ */
+
 static int dir_new_leaf(struct inode *inode, const struct qstr *name)
 {
         struct buffer_head *bh, *obh;
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_leaf *leaf, *oleaf;
+        u32 dist = 1;
         int error;
         u32 index;
         u64 bn;
@@ -1626,6 +1651,7 @@ static int dir_new_leaf(struct inode *inode, const struct qstr *name)
         if (error)
                 return error;
         do {
+                dist++;
                 oleaf = (struct gfs2_leaf *)obh->b_data;
                 bn = be64_to_cpu(oleaf->lf_next);
                 if (!bn)
@@ -1643,6 +1669,7 @@ static int dir_new_leaf(struct inode *inode, const struct qstr *name)
                 brelse(obh);
                 return -ENOSPC;
         }
+        leaf->lf_dist = cpu_to_be32(dist);
         oleaf->lf_next = cpu_to_be64(bh->b_blocknr);
         brelse(bh);
         brelse(obh);
@@ -1659,39 +1686,53 @@ static int dir_new_leaf(struct inode *inode, const struct qstr *name)
 
 /**
  * gfs2_dir_add - Add new filename into directory
- * @dip: The GFS2 inode
- * @filename: The new name
- * @inode: The inode number of the entry
- * @type: The type of the entry
+ * @inode: The directory inode
+ * @name: The new name
+ * @nip: The GFS2 inode to be linked in to the directory
+ * @da: The directory addition info
+ *
+ * If the call to gfs2_diradd_alloc_required resulted in there being
+ * no need to allocate any new directory blocks, then it will contain
+ * a pointer to the directory entry and the bh in which it resides. We
+ * can use that without having to repeat the search. If there was no
+ * free space, then we must now create more space.
  *
  * Returns: 0 on success, error code on failure