[GFS2] Fix bug in directory code and tidy up

Due to a typo, the dir leaf split operation was (for the first
split in a directory) writing the new hash vaules at the
wrong offset. This is now fixed.

Also some other tidy ups are included:

 - We use GFS2's hash function for dentries (see ops_dentry.c) so that
   we don't have to keep recalculating the hash values.
 - A lot of common code is eliminated between the various directory
   lookup routines.
 - Better error checking on directory lookup (previously different
   routines checked for different errors)
 - The leaf split operation has a couple of redundant operations
   removed from it, so it should be faster.

There is still further scope for further clean ups in the directory
code, and readdir in particular could do with slimming down a bit.

Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>

10 files changed, 682 insertions, 982 deletions

diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index 37f70ca558cc..f31f163da1a1 100644
--- a/fs/gfs2/dir.c
+++ b/fs/gfs2/dir.c
@@ -130,7 +130,7 @@ static int gfs2_dir_write_stuffed(struct gfs2_inode *ip, const char *buf,
 		return error;
 
 	gfs2_trans_add_bh(ip->i_gl, dibh, 1);
-	memcpy(dibh->b_data + offset + sizeof(struct gfs2_inode), buf, size);
+	memcpy(dibh->b_data + offset + sizeof(struct gfs2_dinode), buf, size);
 	if (ip->i_di.di_size < offset + size)
 		ip->i_di.di_size = offset + size;
 	ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();
@@ -177,7 +177,7 @@ static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf,
 	if (gfs2_is_stuffed(ip)) {
 		error = gfs2_unstuff_dinode(ip, NULL, NULL);
 		if (error)
-		return error;
+			return error;
 	}
 
 	lblock = offset;
@@ -244,7 +244,7 @@ fail:
 }
 
 static int gfs2_dir_read_stuffed(struct gfs2_inode *ip, char *buf,
-				unsigned int offset, unsigned int size)
+				 unsigned int offset, unsigned int size)
 {
 	struct buffer_head *dibh;
 	int error;
@@ -343,26 +343,159 @@ fail:
 	return (copied) ? copied : error;
 }
 
-/**
- * int gfs2_filecmp - Compare two filenames
- * @file1: The first filename
- * @file2: The second filename
- * @len_of_file2: The length of the second file
- *
- * This routine compares two filenames and returns 1 if they are equal.
- *
- * Returns: 1 if the files are the same, otherwise 0.
+typedef int (*gfs2_dscan_t)(const struct gfs2_dirent *dent,
+			    const struct qstr *name);
+
+static inline int __gfs2_dirent_find(const struct gfs2_dirent *dent,
+				     const struct qstr *name, int ret)
+{
+	if (dent->de_inum.no_addr != 0 &&
+	    be32_to_cpu(dent->de_hash) == name->hash &&
+	    be16_to_cpu(dent->de_name_len) == name->len &&
+	    memcmp((char *)(dent+1), name->name, name->len) == 0)
+		return ret;
+	return 0;
+}
+
+static int gfs2_dirent_find(const struct gfs2_dirent *dent,
+			    const struct qstr *name)
+{
+	return __gfs2_dirent_find(dent, name, 1);
+}
+
+static int gfs2_dirent_prev(const struct gfs2_dirent *dent,
+			    const struct qstr *name)
+{
+	return __gfs2_dirent_find(dent, name, 2);
+}
+
+/*
+ * name->name holds ptr to start of block.
+ * name->len holds size of block.
  */
+static int gfs2_dirent_last(const struct gfs2_dirent *dent,
+			    const struct qstr *name)
+{
+	const char *start = name->name;
+	const char *end = (const char *)dent + be16_to_cpu(dent->de_rec_len);
+	if (name->len == (end - start))
+		return 1;
+	return 0;
+}
 
-int gfs2_filecmp(struct qstr *file1, char *file2, int len_of_file2)
+static int gfs2_dirent_find_space(const struct gfs2_dirent *dent,
+				  const struct qstr *name)
 {
-	if (file1->len != len_of_file2)
-		return 0;
-	if (memcmp(file1->name, file2, file1->len))
-		return 0;
-	return 1;
+	unsigned required = GFS2_DIRENT_SIZE(name->len);
+	unsigned actual = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
+	unsigned totlen = be16_to_cpu(dent->de_rec_len);
+
+	if ((totlen - actual) >= required)
+		return 1;
+	return 0;
 }
 
+/*
+ * Other possible things to check:
+ * - Inode located within filesystem size (and on valid block)
+ * - Valid directory entry type
+ * Not sure how heavy-weight we want to make this... could also check
+ * hash is correct for example, but that would take a lot of extra time.
+ * For now the most important thing is to check that the various sizes
+ * are correct.
+ */
+static int gfs2_check_dirent(struct gfs2_dirent *dent, unsigned int offset,
+			     unsigned int size, unsigned int len, int first)
+{
+	const char *msg = "gfs2_dirent too small";
+	if (unlikely(size < sizeof(struct gfs2_dirent)))
+		goto error;
+	msg = "gfs2_dirent misaligned";
+	if (unlikely(offset & 0x7))
+		goto error;
+	msg = "gfs2_dirent points beyond end of block";
+	if (unlikely(offset + size > len))
+		goto error;
+	msg = "zero inode number";
+	if (unlikely(!first && !dent->de_inum.no_addr))
+		goto error;
+	msg = "name length is greater than space in dirent";
+	if (dent->de_inum.no_addr &&
+	    unlikely(sizeof(struct gfs2_dirent)+be16_to_cpu(dent->de_name_len) >
+		     size))
+		goto error;
+	return 0;
+error:
+	printk(KERN_WARNING "gfs2_check_dirent: %s (%s)\n", msg,
+	       first ? "first in block" : "not first in block");
+	return -EIO;
+}
+
+static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode,
+					    void *buf,
+					    unsigned int len, gfs2_dscan_t scan,
+					    const struct qstr *name)
+{
+	struct gfs2_meta_header *h = buf;
+	struct gfs2_dirent *dent, *prev;
+	unsigned offset;
+	unsigned size;
+	int ret = 0;
+
+	BUG_ON(buf == NULL);
+	BUG_ON(name == NULL);
+
+	switch(be16_to_cpu(h->mh_type)) {
+	case GFS2_METATYPE_LF:
+		offset = sizeof(struct gfs2_leaf);
+		break;
+	case GFS2_METATYPE_DI:
+		offset = sizeof(struct gfs2_dinode);
+		break;
+	default:
+		goto wrong_type;
+	}
+
+	prev = NULL;
+	dent = (struct gfs2_dirent *)(buf + offset);
+	size = be16_to_cpu(dent->de_rec_len);
+	if (gfs2_check_dirent(dent, offset, size, len, 1))
+		goto consist_inode;
+	do {
+		ret = scan(dent, name);
+		if (ret)
+			break;
+		offset += size;
+		if (offset == len)
+			break;
+		prev = dent;
+		dent = (struct gfs2_dirent *)(buf + offset);
+		size = be16_to_cpu(dent->de_rec_len);
+		if (gfs2_check_dirent(dent, offset, size, len, 0))
+			goto consist_inode;
+	} while(1);
+
+	switch(ret) {
+	case 0:
+		return NULL;
+	case 1:
+		return dent;
+	case 2:
+		return prev ? prev : dent;
+	default:
+		BUG_ON(ret > 0);
+		return ERR_PTR(ret);
+	}
+
+wrong_type:
+	printk(KERN_WARNING "gfs2_scan_dirent: %p wrong block type %u\n", scan,
+	       be16_to_cpu(h->mh_type));
+consist_inode:
+	gfs2_consist_inode(inode->u.generic_ip);
+	return ERR_PTR(-EIO);
+}
+
+
 /**
  * dirent_first - Return the first dirent
  * @dip: the directory
@@ -489,180 +622,39 @@ static void dirent_del(struct gfs2_inode *dip, struct buffer_head *bh,
 	prev->de_rec_len = cpu_to_be16(prev_rec_len);
 }
 
-/**
- * gfs2_dirent_alloc - Allocate a directory entry
- * @dip: The GFS2 inode
- * @bh: The buffer
- * @name_len: The length of the name
- * @dent_out: Pointer to list of dirents
- *
- * Returns: 0 on success, error code otherwise
+/*
+ * Takes a dent from which to grab space as an argument. Returns the
+ * newly created dent.
  */
-
-int gfs2_dirent_alloc(struct gfs2_inode *dip, struct buffer_head *bh,
-		      int name_len, struct gfs2_dirent **dent_out)
+struct gfs2_dirent *gfs2_init_dirent(struct inode *inode,
+				     struct gfs2_dirent *dent,
+				     const struct qstr *name,
+				     struct buffer_head *bh)
 {
-	struct gfs2_dirent *dent, *new;
-	unsigned int rec_len = GFS2_DIRENT_SIZE(name_len);
-	unsigned int entries = 0, offset = 0;
-	int type;
-
-	type = dirent_first(dip, bh, &dent);
-	if (type < 0)
-		return type;
-
-	if (type == IS_LEAF) {
-		struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;
-		entries = be16_to_cpu(leaf->lf_entries);
-		offset = sizeof(struct gfs2_leaf);
-	} else {
-		struct gfs2_dinode *dinode = (struct gfs2_dinode *)bh->b_data;
-		entries = be32_to_cpu(dinode->di_entries);
-		offset = sizeof(struct gfs2_dinode);
-	}
-
-	if (!entries) {
-		if (dent->de_inum.no_addr) {
-			gfs2_consist_inode(dip);
-			return -EIO;
-		}
-
-		gfs2_trans_add_bh(dip->i_gl, bh, 1);
-
-		dent->de_rec_len = cpu_to_be16(bh->b_size - offset);
-		dent->de_name_len = cpu_to_be16(name_len);
-
-		*dent_out = dent;
-		return 0;
-	}
-
-	do {
-		uint16_t cur_rec_len;
-		uint16_t cur_name_len;
-
-		cur_rec_len = be16_to_cpu(dent->de_rec_len);
-		cur_name_len = be16_to_cpu(dent->de_name_len);
-
-		if ((!dent->de_inum.no_addr && cur_rec_len >= rec_len) ||
-		    (cur_rec_len >= GFS2_DIRENT_SIZE(cur_name_len) + rec_len)) {
-			gfs2_trans_add_bh(dip->i_gl, bh, 1);
-
-			if (dent->de_inum.no_addr) {
-				new = (struct gfs2_dirent *)((char *)dent +
-					    GFS2_DIRENT_SIZE(cur_name_len));
-				memset(new, 0, sizeof(struct gfs2_dirent));
-
-				new->de_rec_len = cpu_to_be16(cur_rec_len -
-						GFS2_DIRENT_SIZE(cur_name_len));
-				new->de_name_len = cpu_to_be16(name_len);
-
-				dent->de_rec_len = cpu_to_be16(cur_rec_len -
-						be16_to_cpu(new->de_rec_len));
-
-				*dent_out = new;
-				return 0;
-			}
-
-			dent->de_name_len = cpu_to_be16(name_len);
-
-			*dent_out = dent;
-			return 0;
-		}
-	} while (dirent_next(dip, bh, &dent) == 0);
-
-	return -ENOSPC;
+	struct gfs2_inode *ip = inode->u.generic_ip;
+	struct gfs2_dirent *ndent;
+	unsigned offset = 0, totlen;
+
+	if (dent->de_inum.no_addr)
+		offset = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
+	totlen = be16_to_cpu(dent->de_rec_len);
+	BUG_ON(offset + name->len > totlen);
+	gfs2_trans_add_bh(ip->i_gl, bh, 1);
+	ndent = (struct gfs2_dirent *)((char *)dent + offset);
+	dent->de_rec_len = cpu_to_be16(offset);
+	gfs2_qstr2dirent(name, totlen - offset, ndent);
+	return ndent;
 }
 
-/**
- * dirent_fits - See if we can fit a entry in this buffer
- * @dip: The GFS2 inode
- * @bh: The buffer
- * @name_len: The length of the name
- *
- * Returns: 1 if it can fit, 0 otherwise
- */
-
-static int dirent_fits(struct gfs2_inode *dip, struct buffer_head *bh,
-		       int name_len)
+static struct gfs2_dirent *gfs2_dirent_alloc(struct inode *inode,
+					     struct buffer_head *bh,
+					     const struct qstr *name)
 {
 	struct gfs2_dirent *dent;
-	unsigned int rec_len = GFS2_DIRENT_SIZE(name_len);
-	unsigned int entries = 0;
-	int type;
-
-	type = dirent_first(dip, bh, &dent);
-	if (type < 0)
-		return type;
-
-	if (type == IS_LEAF) {
-		struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;
-		entries = be16_to_cpu(leaf->lf_entries);
-	} else {
-		struct gfs2_dinode *dinode = (struct gfs2_dinode *)bh->b_data;
-		entries = be32_to_cpu(dinode->di_entries);
-	}
-
-	if (!entries)
-		return 1;
-
-	do {
-		uint16_t cur_rec_len;
-		uint32_t cur_name_len;
-
-		cur_rec_len = be16_to_cpu(dent->de_rec_len);
-		cur_name_len = be16_to_cpu(dent->de_name_len);
-
-		if ((!dent->de_inum.no_addr && cur_rec_len >= rec_len) ||
-		    (cur_rec_len >= GFS2_DIRENT_SIZE(cur_name_len) + rec_len))
-			return 1;
-	} while (dirent_next(dip, bh, &dent) == 0);
-
-	return 0;
-}
-
-static int leaf_search(struct gfs2_inode *dip, struct buffer_head *bh,
-		       struct qstr *filename, struct gfs2_dirent **dent_out,
-		       struct gfs2_dirent **dent_prev)
-{
-	uint32_t hash;
-	struct gfs2_dirent *dent, *prev = NULL;
-	unsigned int entries = 0;
-	int type;
-
-	type = dirent_first(dip, bh, &dent);
-	if (type < 0)
-		return type;
-
-	if (type == IS_LEAF) {
-		struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;
-		entries = be16_to_cpu(leaf->lf_entries);
-	} else if (type == IS_DINODE) {
-		struct gfs2_dinode *dinode = (struct gfs2_dinode *)bh->b_data;
-		entries = be32_to_cpu(dinode->di_entries);
-	}
-
-	hash = gfs2_disk_hash(filename->name, filename->len);
-
-	do {
-		if (!dent->de_inum.no_addr) {
-			prev = dent;
-			continue;
-		}
-
-		if (be32_to_cpu(dent->de_hash) == hash &&
-		    gfs2_filecmp(filename, (char *)(dent + 1),
-				 be16_to_cpu(dent->de_name_len))) {
-			*dent_out = dent;
-			if (dent_prev)
-				*dent_prev = prev;
-
-			return 0;
-		}
-
-		prev = dent;
-	} while (dirent_next(dip, bh, &dent) == 0);
-
-	return -ENOENT;
+	dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size, gfs2_dirent_find_space, name);
+	if (!dent || IS_ERR(dent))
+		return dent;
+	return gfs2_init_dirent(inode, dent, name, bh);
 }
 
 static int get_leaf(struct gfs2_inode *dip, uint64_t leaf_no,
@@ -716,75 +708,81 @@ static int get_first_leaf(struct gfs2_inode *dip, uint32_t index,
 	return error;
 }
 
-static int get_next_leaf(struct gfs2_inode *dip, struct buffer_head *bh_in,
-			 struct buffer_head **bh_out)
+static struct gfs2_dirent *gfs2_dirent_search(struct inode *inode,
+					      const struct qstr *name,
+					      gfs2_dscan_t scan,
+					      struct buffer_head **pbh)
 {
-	struct gfs2_leaf *leaf;
-	int error;
-
-	leaf = (struct gfs2_leaf *)bh_in->b_data;
-
-	if (!leaf->lf_next)
-		error = -ENOENT;
-	else
-		error = get_leaf(dip, be64_to_cpu(leaf->lf_next), bh_out);
-
-	return error;
-}
-
-static int linked_leaf_search(struct gfs2_inode *dip, struct qstr *filename,
-			      struct gfs2_dirent **dent_out,
-			      struct gfs2_dirent **dent_prev,
-			      struct buffer_head **bh_out)
-{
-	struct buffer_head *bh = NULL, *bh_next;
-	uint32_t hsize, index;
-	uint32_t hash;
+	struct buffer_head *bh;
+	struct gfs2_dirent *dent;
+	struct gfs2_inode *ip = inode->u.generic_ip;
 	int error;
 
-	hsize = 1 << dip->i_di.di_depth;
-	if (hsize * sizeof(uint64_t) != dip->i_di.di_size) {
-		gfs2_consist_inode(dip);
-		return -EIO;
-	}
-
-	/*  Figure out the address of the leaf node.  */
-
-	hash = gfs2_disk_hash(filename->name, filename->len);
-	index = hash >> (32 - dip->i_di.di_depth);
-
-	error = get_first_leaf(dip, index, &bh_next);
-	if (error)
-		return error;
-
-	/*  Find the entry  */
-
-	do {
-		brelse(bh);
-
-		bh = bh_next;
-
-		error = leaf_search(dip, bh, filename, dent_out, dent_prev);
-		switch (error) {
-		case 0:
-			*bh_out = bh;
-			return 0;
-
-		case -ENOENT:
-			break;
+	if (ip->i_di.di_flags & GFS2_DIF_EXHASH) {
+		struct gfs2_leaf *leaf;
+		unsigned hsize = 1 << ip->i_di.di_depth;
+		unsigned index;
+		u64 ln;
+		if (hsize * sizeof(u64) != ip->i_di.di_size) {
+			gfs2_consist_inode(ip);
+			return ERR_PTR(-EIO);
+		}
 
-		default:
+		index = name->hash >> (32 - ip->i_di.di_depth);
+		error = get_first_leaf(ip, index, &bh);
+		if (error)
+			return ERR_PTR(error);
+		do {
+			dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
+						scan, name);
+			if (dent)
+				goto got_dent;
+			leaf = (struct gfs2_leaf *)bh->b_data;
+			ln = be64_to_cpu(leaf->lf_next);
 			brelse(bh);
-			return error;
-		}
+			if (!ln)
+				break;
+			error = get_leaf(ip, ln, &bh);
+		} while(!error);
 
-		error = get_next_leaf(dip, bh, &bh_next);
+		return error ? ERR_PTR(error) : NULL;
 	}
-	while (!error);
 
-	brelse(bh);
+	error = gfs2_meta_inode_buffer(ip, &bh);
+	if (error)
+		return ERR_PTR(error);
+	dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size, scan, name);
+got_dent:
+	*pbh = bh;
+	return dent;
+}
 
-	return error;
+static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh, u16 depth)
+{
+	struct gfs2_inode *ip = inode->u.generic_ip;
+	u64 bn = gfs2_alloc_meta(ip);
+	struct buffer_head *bh = gfs2_meta_new(ip->i_gl, bn);
+	struct gfs2_leaf *leaf;
+	struct gfs2_dirent *dent;
+	if (!bh)
+		return NULL;
+	gfs2_trans_add_bh(ip->i_gl, bh, 1);
+	gfs2_metatype_set(bh, GFS2_METATYPE_LF, GFS2_FORMAT_LF);
+	leaf = (struct gfs2_leaf *)bh->b_data;
+	leaf->lf_depth = cpu_to_be16(depth);
+	leaf->lf_entries = cpu_to_be16(0);
+	leaf->lf_dirent_format = cpu_to_be16(GFS2_FORMAT_DE);
+	leaf->lf_next = cpu_to_be64(0);
+	memset(leaf->lf_reserved, 0, sizeof(leaf->lf_reserved));
+	dent = (struct gfs2_dirent *)(leaf+1);
+	dent->de_inum.no_formal_ino = cpu_to_be64(0);
+	dent->de_inum.no_addr = cpu_to_be64(0);
+	dent->de_hash = cpu_to_be32(0);
+	dent->de_rec_len = cpu_to_be16(bh->b_size - sizeof(struct gfs2_leaf));
+	dent->de_name_len = cpu_to_be16(0);
+	dent->de_type = cpu_to_be16(0);
+	*pbh = bh;
+	return leaf;
 }
 
 /**
@@ -794,10 +792,12 @@ static int linked_leaf_search(struct gfs2_inode *dip, struct qstr *filename,
  * Returns: 0 on success, error code otherwise
  */
 
-static int dir_make_exhash(struct gfs2_inode *dip)
+static int dir_make_exhash(struct inode *inode)
 {
+	struct gfs2_inode *dip = inode->u.generic_ip;
 	struct gfs2_sbd *sdp = dip->i_sbd;
 	struct gfs2_dirent *dent;
+	struct qstr args;
 	struct buffer_head *bh, *dibh;
 	struct gfs2_leaf *leaf;
 	int y;
@@ -809,24 +809,14 @@ static int dir_make_exhash(struct gfs2_inode *dip)
 	if (error)
 		return error;
 
-	/*  Allocate a new block for the first leaf node  */
-
-	bn = gfs2_alloc_meta(dip);
-
 	/*  Turn over a new leaf  */
 
-	bh = gfs2_meta_new(dip->i_gl, bn);
-	gfs2_trans_add_bh(dip->i_gl, bh, 1);
-	gfs2_metatype_set(bh, GFS2_METATYPE_LF, GFS2_FORMAT_LF);
-	gfs2_buffer_clear_tail(bh, sizeof(struct gfs2_meta_header));
-
-	/*  Fill in the leaf structure  */
-
-	leaf = (struct gfs2_leaf *)bh->b_data;
+	leaf = new_leaf(inode, &bh, 0);
+	if (!leaf)
+		return -ENOSPC;
+	bn = bh->b_blocknr;
 
 	gfs2_assert(sdp, dip->i_di.di_entries < (1 << 16));
-
-	leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
 	leaf->lf_entries = cpu_to_be16(dip->i_di.di_entries);
 
 	/*  Copy dirents  */
@@ -837,15 +827,21 @@ static int dir_make_exhash(struct gfs2_inode *dip)
 	/*  Find last entry  */
 
 	x = 0;
-	dirent_first(dip, bh, &dent);
-
-	do {
-		if (!dent->de_inum.no_addr)
-			continue;
-		if (++x == dip->i_di.di_entries)
-			break;
+	args.len = bh->b_size - sizeof(struct gfs2_dinode) +
+		   sizeof(struct gfs2_leaf);
+	args.name = bh->b_data;
+	dent = gfs2_dirent_scan(dip->i_vnode, bh->b_data, bh->b_size,
+				gfs2_dirent_last, &args);
+	if (!dent) {
+		brelse(bh);
+		brelse(dibh);
+		return -EIO;
+	}
+	if (IS_ERR(dent)) {
+		brelse(bh);
+		brelse(dibh);
+		return PTR_ERR(dent);
 	}
-	while (dirent_next(dip, bh, &dent) == 0);
 
 	/*  Adjust the last dirent's record length
 	   (Remember that dent still points to the last entry.)  */
@@ -891,45 +887,39 @@ static int dir_make_exhash(struct gfs2_inode *dip)
  * Returns: 0 on success, error code on failure
  */
 
-static int dir_split_leaf(struct gfs2_inode *dip, uint32_t index,
-			  uint64_t leaf_no)
+static int dir_split_leaf(struct inode *inode, const struct qstr *name)
 {
+	struct gfs2_inode *dip = inode->u.generic_ip;
 	struct buffer_head *nbh, *obh, *dibh;
 	struct gfs2_leaf *nleaf, *oleaf;
 	struct gfs2_dirent *dent, *prev = NULL, *next = NULL, *new;
 	uint32_t start, len, half_len, divider;
-	uint64_t bn, *lp;
-	uint32_t name_len;
+	uint64_t bn, *lp, leaf_no;
+	uint32_t index;
 	int x, moved = 0;
 	int error;
 
-	/*  Allocate the new leaf block  */
-
-	bn = gfs2_alloc_meta(dip);
-
-	/*  Get the new leaf block  */
-
-	nbh = gfs2_meta_new(dip->i_gl, bn);
-	gfs2_trans_add_bh(dip->i_gl, nbh, 1);
-	gfs2_metatype_set(nbh, GFS2_METATYPE_LF, GFS2_FORMAT_LF);
-	gfs2_buffer_clear_tail(nbh, sizeof(struct gfs2_meta_header));
-
-	nleaf = (struct gfs2_leaf *)nbh->b_data;
-
-	nleaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
+	index = name->hash >> (32 - dip->i_di.di_depth);
+	error = get_leaf_nr(dip, index, &leaf_no);
+	if (error)
+		return error;
 
 	/*  Get the old leaf block  */
-
 	error = get_leaf(dip, leaf_no, &obh);
 	if (error)
 		goto fail;
 
 	gfs2_trans_add_bh(dip->i_gl, obh, 1);
-
 	oleaf = (struct gfs2_leaf *)obh->b_data;
 
-	/*  Compute the start and len of leaf pointers in the hash table.  */
+	nleaf = new_leaf(inode, &nbh, be16_to_cpu(oleaf->lf_depth) + 1);
+	if (!nleaf) {
+		brelse(obh);
+		return -ENOSPC;
+	}
+	bn = nbh->b_blocknr;
 
+	/*  Compute the start and len of leaf pointers in the hash table.  */
 	len = 1 << (dip->i_di.di_depth - be16_to_cpu(oleaf->lf_depth));
 	half_len = len >> 1;
 	if (!half_len) {
@@ -943,19 +933,8 @@ static int dir_split_leaf(struct gfs2_inode *dip, uint32_t index,
 	/* Change the pointers.
 	   Don't bother distinguishing stuffed from non-stuffed.
 	   This code is complicated enough already. */
-
-	lp = kcalloc(half_len, sizeof(uint64_t), GFP_KERNEL | __GFP_NOFAIL);
-
-	error = gfs2_dir_read_data(dip, (char *)lp, start * sizeof(uint64_t),
-				    half_len * sizeof(uint64_t));
-	if (error != half_len * sizeof(uint64_t)) {
-		if (error >= 0)
-			error = -EIO;
-		goto fail_lpfree;
-	}
-
+	lp = kmalloc(half_len * sizeof(uint64_t), GFP_NOFS | __GFP_NOFAIL);
 	/*  Change the pointers  */
-
 	for (x = 0; x < half_len; x++)
 		lp[x] = cpu_to_be64(bn);
 
@@ -970,11 +949,9 @@ static int dir_split_leaf(struct gfs2_inode *dip, uint32_t index,
 	kfree(lp);
 
 	/*  Compute the divider  */
-
 	divider = (start + half_len) << (32 - dip->i_di.di_depth);
 
 	/*  Copy the entries  */
-
 	dirent_first(dip, obh, &dent);
 
 	do {
@@ -984,48 +961,37 @@ static int dir_split_leaf(struct gfs2_inode *dip, uint32_t index,
 
 		if (dent->de_inum.no_addr &&
 		    be32_to_cpu(dent->de_hash) < divider) {
-			name_len = be16_to_cpu(dent->de_name_len);
-
-			gfs2_dirent_alloc(dip, nbh, name_len, &new);
+			struct qstr str;
+			str.name = (char*)(dent+1);
+			str.len = be16_to_cpu(dent->de_name_len);
+			str.hash = be32_to_cpu(dent->de_hash);
+			new = gfs2_dirent_alloc(dip->i_vnode, nbh, &str);
+			if (IS_ERR(new)) {
+				error = PTR_ERR(new);
+				break;
+			}
 
 			new->de_inum = dent->de_inum; /* No endian worries */
-			new->de_hash = dent->de_hash; /* No endian worries */
 			new->de_type = dent->de_type; /* No endian worries */
-			memcpy((char *)(new + 1), (char *)(dent + 1),
-			       name_len);
-
-			nleaf->lf_entries = be16_to_cpu(nleaf->lf_entries)+1;
-			nleaf->lf_entries = cpu_to_be16(nleaf->lf_entries);
+			nleaf->lf_entries = cpu_to_be16(be16_to_cpu(nleaf->lf_entries)+1);
 
 			dirent_del(dip, obh, prev, dent);
 
 			if (!oleaf->lf_entries)
 				gfs2_consist_inode(dip);
-			oleaf->lf_entries = be16_to_cpu(oleaf->lf_entries)-1;
-			oleaf->lf_entries = cpu_to_be16(oleaf->lf_entries);
+			oleaf->lf_entries = cpu_to_be16(be16_to_cpu(oleaf->lf_entries)-1);
 
 			if (!prev)
 				prev = dent;
 
 			moved = 1;
-		} else
+		} else {
 			prev = dent;
-
+		}
 		dent = next;
-	}
-	while (dent);
-
-	/* If none of the entries got moved into the new leaf,
-	   artificially fill in the first entry. */
+	} while (dent);
 
-	if (!moved) {
-		gfs2_dirent_alloc(dip, nbh, 0, &new);
-		new->de_inum.no_addr = 0;
-	}
-
-	oleaf->lf_depth = be16_to_cpu(oleaf->lf_depth) + 1;
-	oleaf->lf_depth = cpu_to_be16(oleaf->lf_depth);
-	nleaf->lf_depth = oleaf->lf_depth;
+	oleaf->lf_depth = nleaf->lf_depth;
 
 	error = gfs2_meta_inode_buffer(dip, &dibh);
 	if (!gfs2_assert_withdraw(dip->i_sbd, !error)) {
@@ -1142,12 +1108,10 @@ static int compare_dents(const void *a, const void *b)
 	int ret = 0;
 
 	dent_a = *(struct gfs2_dirent **)a;
-	hash_a = dent_a->de_hash;
-	hash_a = be32_to_cpu(hash_a);
+	hash_a = be32_to_cpu(dent_a->de_hash);
 
 	dent_b = *(struct gfs2_dirent **)b;
-	hash_b = dent_b->de_hash;
-	hash_b = be32_to_cpu(hash_b);
+	hash_b = be32_to_cpu(dent_b->de_hash);
 
 	if (hash_a > hash_b)
 		ret = 1;
@@ -1292,8 +1256,7 @@ static int do_filldir_single(struct gfs2_inode *dip, uint64_t *offset,
 			goto out;
 		}
 		darr[e++] = de;
-	}
-	while (dirent_next(dip, bh, &de) == 0);
+	} while (dirent_next(dip, bh, &de) == 0);
 
 	if (e != entries) {
 		gfs2_consist_inode(dip);
@@ -1341,11 +1304,9 @@ static int do_filldir_multi(struct gfs2_inode *dip, uint64_t *offset,
 
 	leaf = (struct gfs2_leaf *)bh->b_data;
 	entries = be16_to_cpu(leaf->lf_entries);
-	ln = leaf->lf_next;
+	ln = be64_to_cpu(leaf->lf_next);
 
 	while (ln) {
-		ln = be64_to_cpu(ln);
-
 		error = get_leaf(dip, ln, &tmp_bh);
 		if (error)
 			return error;
@@ -1355,7 +1316,7 @@ static int do_filldir_multi(struct gfs2_inode *dip, uint64_t *offset,
 			entries += be16_to_cpu(leaf->lf_entries);
 			leaves++;
 		}
-		ln = leaf->lf_next;
+		ln = be64_to_cpu(leaf->lf_next);
 
 		brelse(tmp_bh);
 	}
@@ -1387,14 +1348,11 @@ static int do_filldir_multi(struct gfs2_inode *dip, uint64_t *offset,
 				goto out;
 			}
 			darr[e++] = de;
-		}
-		while (dirent_next(dip, bh, &de) == 0);
+		} while (dirent_next(dip, bh, &de) == 0);
 	}
-	ln = leaf->lf_next;
+	ln = be64_to_cpu(leaf->lf_next);
 
 	while (ln) {
-		ln = be64_to_cpu(ln);
-
 		error = get_leaf(dip, ln, &tmp_bh);
 		if (error)
 			goto out;
@@ -1411,14 +1369,13 @@ static int do_filldir_multi(struct gfs2_inode *dip, uint64_t *offset,
 					goto out;
 				}
 				darr[e++] = de;
-			}
-			while (dirent_next(dip, tmp_bh, &de) == 0);
+			} while (dirent_next(dip, tmp_bh, &de) == 0);
 
 			larr[l++] = tmp_bh;
 
-			ln = leaf->lf_next;
+			ln = be64_to_cpu(leaf->lf_next);
 		} else {
-			ln = leaf->lf_next;
+			ln = be64_to_cpu(leaf->lf_next);
 			brelse(tmp_bh);
 		}
 	}
@@ -1446,207 +1403,6 @@ static int do_filldir_multi(struct gfs2_inode *dip, uint64_t *offset,
 }
 
 /**
- * dir_e_search - Search exhash (leaf) dir for inode matching name
- * @dip: The GFS2 inode
- * @filename: Filename string
- * @inode: If non-NULL, function fills with formal inode # and block address
- * @type: If non-NULL, function fills with DT_... dinode type
- *
- * Returns:
- */
-
-static int dir_e_search(struct gfs2_inode *dip, struct qstr *filename,
-			struct gfs2_inum *inum, unsigned int *type)
-{
-	struct buffer_head *bh;
-	struct gfs2_dirent *dent;
-	int error;
-
-	error = linked_leaf_search(dip, filename, &dent, NULL, &bh);
-	if (error)
-		return error;
-
-	if (inum)
-		gfs2_inum_in(inum, (char *)&dent->de_inum);
-	if (type)
-		*type = be16_to_cpu(dent->de_type);
-
-	brelse(bh);
-
-	return 0;
-}
-
-static int dir_e_add(struct gfs2_inode *dip, struct qstr *filename,
-		     struct gfs2_inum *inum, unsigned int type)
-{
-	struct buffer_head *bh, *nbh, *dibh;
-	struct gfs2_leaf *leaf, *nleaf;
-	struct gfs2_dirent *dent;
-	uint32_t hsize, index;
-	uint32_t hash;
-	uint64_t leaf_no, bn;
-	int error;
-
- restart:
-	hsize = 1 << dip->i_di.di_depth;
-	if (hsize * sizeof(uint64_t) != dip->i_di.di_size) {
-		gfs2_consist_inode(dip);
-		return -EIO;
-	}
-
-	/*  Figure out the address of the leaf node.  */
-
-	hash = gfs2_disk_hash(filename->name, filename->len);
-	index = hash >> (32 - dip->i_di.di_depth);
-
-	error = get_leaf_nr(dip, index, &leaf_no);
-	if (error)
-		return error;
-
-	/*  Add entry to the leaf  */
-
-	for (;;) {
-		error = get_leaf(dip, leaf_no, &bh);
-		if (error)
-			return error;
-
-		leaf = (struct gfs2_leaf *)bh->b_data;
-
-		if (gfs2_dirent_alloc(dip, bh, filename->len, &dent)) {
-
-			if (be16_to_cpu(leaf->lf_depth) < dip->i_di.di_depth) {
-				/* Can we split the leaf? */
-
-				brelse(bh);
-
-				error = dir_split_leaf(dip, index, leaf_no);
-				if (error)
-					return error;
-
-				goto restart;
-
-			} else if (dip->i_di.di_depth < GFS2_DIR_MAX_DEPTH) {
-				/* Can we double the hash table? */
-
-				brelse(bh);
-
-				error = dir_double_exhash(dip);
-				if (error)
-					return error;
-
-				goto restart;
-
-			} else if (leaf->lf_next) {
-				/* Can we try the next leaf in the list? */
-				leaf_no = be64_to_cpu(leaf->lf_next);
-				brelse(bh);
-				continue;
-
-			} else {
-				/* Create a new leaf and add it to the list. */
-
-				bn = gfs2_alloc_meta(dip);
-
-				nbh = gfs2_meta_new(dip->i_gl, bn);
-				gfs2_trans_add_bh(dip->i_gl, nbh, 1);
-				gfs2_metatype_set(nbh,
-						 GFS2_METATYPE_LF,
-						 GFS2_FORMAT_LF);
-				gfs2_buffer_clear_tail(nbh,
-					sizeof(struct gfs2_meta_header));
-
-				gfs2_trans_add_bh(dip->i_gl, bh, 1);
-				leaf->lf_next = cpu_to_be64(bn);
-
-				nleaf = (struct gfs2_leaf *)nbh->b_data;
-				nleaf->lf_depth = leaf->lf_depth;
-				nleaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
-
-				gfs2_dirent_alloc(dip, nbh, filename->len,
-						  &dent);
-
-				dip->i_di.di_blocks++;
-
-				brelse(bh);
-
-				bh = nbh;
-				leaf = nleaf;
-			}
-		}
-
-		/* If the gfs2_dirent_alloc() succeeded, it pinned the "bh" */
-
-		gfs2_inum_out(inum, (char *)&dent->de_inum);
-		dent->de_hash = cpu_to_be32(hash);
-		dent->de_type = cpu_to_be16(type);
-		memcpy((char *)(dent + 1), filename->name, filename->len);
-
-		leaf->lf_entries = be16_to_cpu(leaf->lf_entries) + 1;
-		leaf->lf_entries = cpu_to_be16(leaf->lf_entries);
-
-		brelse(bh);
-
-		error = gfs2_meta_inode_buffer(dip, &dibh);
-		if (error)
-			return error;
-
-		dip->i_di.di_entries++;
-		dip->i_di.di_mtime = dip->i_di.di_ctime = get_seconds();
-
-		gfs2_trans_add_bh(dip->i_gl, dibh, 1);
-		gfs2_dinode_out(&dip->i_di, dibh->b_data);
-		brelse(dibh);
-
-		return 0;
-	}
-
-	return -ENOENT;
-}
-
-static int dir_e_del(struct gfs2_inode *dip, struct qstr *filename)
-{
-	struct buffer_head *bh, *dibh;
-	struct gfs2_dirent *dent, *prev;
-	struct gfs2_leaf *leaf;
-	unsigned int entries;
-	int error;
-
-	error = linked_leaf_search(dip, filename, &dent, &prev, &bh);
-	if (error == -ENOENT) {
-		gfs2_consist_inode(dip);
-		return -EIO;
-	}
-	if (error)
-		return error;
-
-	dirent_del(dip, bh, prev, dent); /* Pins bh */
-
-	leaf = (struct gfs2_leaf *)bh->b_data;
-	entries = be16_to_cpu(leaf->lf_entries);
-	if (!entries)
-		gfs2_consist_inode(dip);
-	entries--;
-	leaf->lf_entries = cpu_to_be16(entries);
-
-	brelse(bh);
-
-	error = gfs2_meta_inode_buffer(dip, &dibh);
-	if (error)
-		return error;
-
-	if (!dip->i_di.di_entries)
-		gfs2_consist_inode(dip);
-	dip->i_di.di_entries--;
-	dip->i_di.di_mtime = dip->i_di.di_ctime = get_seconds();
-
-	gfs2_trans_add_bh(dip->i_gl, dibh, 1);
-	gfs2_dinode_out(&dip->i_di, dibh->b_data);
-	brelse(dibh);
-
-	return 0;
-}
-
-/**
  * dir_e_read - Reads the entries from a directory into a filldir buffer
  * @dip: dinode pointer
  * @offset: the hash of the last entry read shifted to the right once
@@ -1661,7 +1417,7 @@ static int dir_e_read(struct gfs2_inode *dip, uint64_t *offset, void *opaque,
 {
 	struct gfs2_sbd *sdp = dip->i_sbd;
 	struct buffer_head *bh;
-	struct gfs2_leaf leaf;
+	struct gfs2_leaf *leaf;
 	uint32_t hsize, len;
 	uint32_t ht_offset, lp_offset, ht_offset_cur = -1;
 	uint32_t hash, index;
@@ -1702,14 +1458,15 @@ static int dir_e_read(struct gfs2_inode *dip, uint64_t *offset, void *opaque,
 		if (error)
 			goto out;
 
-		gfs2_leaf_in(&leaf, bh->b_data);
-
-		if (leaf.lf_next)
+		leaf = (struct gfs2_leaf *)bh->b_data;
+		if (leaf->lf_next)
 			error = do_filldir_multi(dip, offset, opaque, filldir,
 						 bh, &copied);
 		else
 			error = do_filldir_single(dip, offset, opaque, filldir,
-						  bh, leaf.lf_entries, &copied);
+						  bh, 
+						  be16_to_cpu(leaf->lf_entries),
+						  &copied);
 
 		brelse(bh);
 
@@ -1719,7 +1476,7 @@ static int dir_e_read(struct gfs2_inode *dip, uint64_t *offset, void *opaque,
 			goto out;
 		}
 
-		len = 1 << (dip->i_di.di_depth - leaf.lf_depth);
+		len = 1 << (dip->i_di.di_depth - be16_to_cpu(leaf->lf_depth));
 		index = (index & ~(len - 1)) + len;
 	}
 
@@ -1729,165 +1486,6 @@ static int dir_e_read(struct gfs2_inode *dip, uint64_t *offset, void *opaque,
 	return error;
 }
 
-static int dir_e_mvino(struct gfs2_inode *dip, struct qstr *filename,
-		       struct gfs2_inum *inum, unsigned int new_type)
-{
-	struct buffer_head *bh, *dibh;
-	struct gfs2_dirent *dent;
-	int error;
-
-	error = linked_leaf_search(dip, filename, &dent, NULL, &bh);
-	if (error == -ENOENT) {
-		gfs2_consist_inode(dip);
-		return -EIO;
-	}
-	if (error)
-		return error;
-
-	gfs2_trans_add_bh(dip->i_gl, bh, 1);
-
-	gfs2_inum_out(inum, (char *)&dent->de_inum);
-	dent->de_type = cpu_to_be16(new_type);
-
-	brelse(bh);
-
-	error = gfs2_meta_inode_buffer(dip, &dibh);
-	if (error)
-		return error;
-
-	dip->i_di.di_mtime = dip->i_di.di_ctime = get_seconds();
-
-	gfs2_trans_add_bh(dip->i_gl, dibh, 1);
-	gfs2_dinode_out(&dip->i_di, dibh->b_data);
-	brelse(dibh);
-
-	return 0;
-}
-
-/**
- * dir_l_search - Search linear (stuffed dinode) dir for inode matching name
- * @dip: The GFS2 inode
- * @filename: Filename string
- * @inode: If non-NULL, function fills with formal inode # and block address
- * @type: If non-NULL, function fills with DT_... dinode type
- *
- * Returns:
- */
-
-static int dir_l_search(struct gfs2_inode *dip, struct qstr *filename,
-			struct gfs2_inum *inum, unsigned int *type)
-{
-	struct buffer_head *dibh;
-	struct gfs2_dirent *dent;
-	int error;
-
-	if (!gfs2_is_stuffed(dip)) {
-		gfs2_consist_inode(dip);
-		return -EIO;
-	}
-
-	error = gfs2_meta_inode_buffer(dip, &dibh);
-	if (error)
-		return error;
-
-	error = leaf_search(dip, dibh, filename, &dent, NULL);
-	if (!error) {
-		if (inum)
-			gfs2_inum_in(inum, (char *)&dent->de_inum);
-		if (type)
-			*type = be16_to_cpu(dent->de_type);
-	}
-
-	brelse(dibh);
-
-	return error;
-}
-
-static int dir_l_add(struct gfs2_inode *dip, struct qstr *filename,
-		     struct gfs2_inum *inum, unsigned int type)
-{
-	struct buffer_head *dibh;
-	struct gfs2_dirent *dent;
-	int error;
-
-	if (!gfs2_is_stuffed(dip)) {
-		gfs2_consist_inode(dip);
-		return -EIO;
-	}
-
-	error = gfs2_meta_inode_buffer(dip, &dibh);
-	if (error)
-		return error;
-
-	if (gfs2_dirent_alloc(dip, dibh, filename->len, &dent)) {
-		brelse(dibh);
-
-		error = dir_make_exhash(dip);
-		if (!error)
-			error = dir_e_add(dip, filename, inum, type);
-
-		return error;
-	}
-
-	/*  gfs2_dirent_alloc() pins  */
-
-	gfs2_inum_out(inum, (char *)&dent->de_inum);
-	dent->de_hash = gfs2_disk_hash(filename->name, filename->len);
-	dent->de_hash = cpu_to_be32(dent->de_hash);
-	dent->de_type = cpu_to_be16(type);
-	memcpy((char *)(dent + 1), filename->name, filename->len);
-
-	dip->i_di.di_entries++;
-	dip->i_di.di_mtime = dip->i_di.di_ctime = get_seconds();
-
-	gfs2_dinode_out(&dip->i_di, dibh->b_data);
-	brelse(dibh);
-
-	return 0;
-}
-
-static int dir_l_del(struct gfs2_inode *dip, struct qstr *filename)
-{
-	struct buffer_head *dibh;
-	struct gfs2_dirent *dent, *prev;
-	int error;
-
-	if (!gfs2_is_stuffed(dip)) {
-		gfs2_consist_inode(dip);
-		return -EIO;
-	}
-
-	error = gfs2_meta_inode_buffer(dip, &dibh);
-	if (error)
-		return error;
-
-	error = leaf_search(dip, dibh, filename, &dent, &prev);
-	if (error == -ENOENT) {
-		gfs2_consist_inode(dip);
-		error = -EIO;
-		goto out;
-	}
-	if (error)
-		goto out;
-
-	dirent_del(dip, dibh, prev, dent);
-
-	/*  dirent_del() pins  */
-
-	if (!dip->i_di.di_entries)
-		gfs2_consist_inode(dip);
-	dip->i_di.di_entries--;
-
-	dip->i_di.di_mtime = dip->i_di.di_ctime = get_seconds();
-
-	gfs2_dinode_out(&dip->i_di, dibh->b_data);
-
- out:
-	brelse(dibh);
-
-	return error;
-}
-
 static int dir_l_read(struct gfs2_inode *dip, uint64_t *offset, void *opaque,
 		      gfs2_filldir_t filldir)
 {
@@ -1919,46 +1517,6 @@ static int dir_l_read(struct gfs2_inode *dip, uint64_t *offset, void *opaque,
 	return error;
 }
 
-static int dir_l_mvino(struct gfs2_inode *dip, struct qstr *filename,
-		       struct gfs2_inum *inum, unsigned int new_type)
-{
-	struct buffer_head *dibh;
-	struct gfs2_dirent *dent;
-	int error;
-
-	if (!gfs2_is_stuffed(dip)) {
-		gfs2_consist_inode(dip);
-		return -EIO;
-	}
-
-	error = gfs2_meta_inode_buffer(dip, &dibh);
-	if (error)
-		return error;
-
-	error = leaf_search(dip, dibh, filename, &dent, NULL);
-	if (error == -ENOENT) {
-		gfs2_consist_inode(dip);
-		error = -EIO;
-		goto out;
-	}
-	if (error)
-		goto out;
-
-	gfs2_trans_add_bh(dip->i_gl, dibh, 1);
-
-	gfs2_inum_out(inum, (char *)&dent->de_inum);
-	dent->de_type = cpu_to_be16(new_type);
-
-	dip->i_di.di_mtime = dip->i_di.di_ctime = get_seconds();
-
-	gfs2_dinode_out(&dip->i_di, dibh->b_data);
-
- out:
-	brelse(dibh);
-
-	return error;
-}
-
 /**
  * gfs2_dir_search - Search a directory
  * @dip: The GFS2 inode
@@ -1971,17 +1529,69 @@ static int dir_l_mvino(struct gfs2_inode *dip, struct qstr *filename,
  * Returns: errno
  */
 
-int gfs2_dir_search(struct gfs2_inode *dip, struct qstr *filename,
+int gfs2_dir_search(struct inode *dir, const struct qstr *name,
 		    struct gfs2_inum *inum, unsigned int *type)
 {
+	struct buffer_head *bh;
+	struct gfs2_dirent *dent;
+
+	dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
+	if (dent) {
+		if (IS_ERR(dent))
+			return PTR_ERR(dent);
+		if (inum)
+			gfs2_inum_in(inum, (char *)&dent->de_inum);
+		if (type)
+			*type = be16_to_cpu(dent->de_type);
+		brelse(bh);
+		return 0;
+	}
+	return -ENOENT;
+}
+
+static int dir_new_leaf(struct inode *inode, const struct qstr *name)
+{
+	struct buffer_head *bh, *obh;
+	struct gfs2_inode *ip = inode->u.generic_ip;
+	struct gfs2_leaf *leaf, *oleaf;
 	int error;
+	u32 index;
+	u64 bn;
 
-	if (dip->i_di.di_flags & GFS2_DIF_EXHASH)
-		error = dir_e_search(dip, filename, inum, type);
-	else
-		error = dir_l_search(dip, filename, inum, type);
+	index = name->hash >> (32 - ip->i_di.di_depth);
+	error = get_first_leaf(ip, index, &obh);
+	if (error)
+		return error;
+	do {
+		oleaf = (struct gfs2_leaf *)obh->b_data;
+		bn = be64_to_cpu(oleaf->lf_next);
+		if (!bn)
+			break;
+		brelse(obh);
+		error = get_leaf(ip, bn, &obh);
+		if (error)
+			return error;
+	} while(1);
 
-	return error;
+	gfs2_trans_add_bh(ip->i_gl, obh, 1);
+
+	leaf = new_leaf(inode, &bh, be16_to_cpu(oleaf->lf_depth));
+	if (!leaf) {
+		brelse(obh);
+		return -ENOSPC;
+	}
+	oleaf->lf_next = cpu_to_be64(bn);
+	brelse(bh);
+	brelse(obh);
+
+	error = gfs2_meta_inode_buffer(ip, &bh);
+	if (error)
+		return error;
+	gfs2_trans_add_bh(ip->i_gl, bh, 1);
+	ip->i_di.di_blocks++;
+	gfs2_dinode_out(&ip->i_di, bh->b_data);
+	brelse(bh);
+	return 0;
 }
 
 /**
@@ -1994,19 +1604,70 @@ int gfs2_dir_search(struct gfs2_inode *dip, struct qstr *filename,
  * Returns: 0 on success, error code on failure
  */
 
-int gfs2_dir_add(struct gfs2_inode *dip, struct qstr *filename,
-		 struct gfs2_inum *inum, unsigned int type)
+int gfs2_dir_add(struct inode *inode, const struct qstr *name,
+		 const struct gfs2_inum *inum, unsigned type)
 {
+	struct gfs2_inode *ip = inode->u.generic_ip;
+	struct buffer_head *bh;
+	struct gfs2_dirent *dent;
+	struct gfs2_leaf *leaf;
 	int error;
 
-	if (dip->i_di.di_flags & GFS2_DIF_EXHASH)
-		error = dir_e_add(dip, filename, inum, type);
-	else
-		error = dir_l_add(dip, filename, inum, type);
-
+	while(1) {
+		dent = gfs2_dirent_search(inode, name, gfs2_dirent_find_space,
+					  &bh);
+		if (dent) {
+			if (IS_ERR(dent))
+				return PTR_ERR(dent);
+			dent = gfs2_init_dirent(inode, dent, name, bh);
+			gfs2_inum_out(inum, (char *)&dent->de_inum);
+			dent->de_type = cpu_to_be16(type);
+			if (ip->i_di.di_flags & GFS2_DIF_EXHASH) {
+				leaf = (struct gfs2_leaf *)bh->b_data;
+				leaf->lf_entries = cpu_to_be16(be16_to_cpu(leaf->lf_entries) + 1);
+			}
+			brelse(bh);
+			error = gfs2_meta_inode_buffer(ip, &bh);
+			if (error)
+				break;
+			gfs2_trans_add_bh(ip->i_gl, bh, 1);
+			ip->i_di.di_entries++;
+			ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();
+			gfs2_dinode_out(&ip->i_di, bh->b_data);
+			brelse(bh);
+			error = 0;
+			break;
+		}
+		if (!(ip->i_di.di_flags & GFS2_DIF_EXHASH)) {
+			error = dir_make_exhash(inode);
+			if (error)
+				break;
+			continue;
+		}
+		error = dir_split_leaf(inode, name);
+		if (error == 0)
+			continue;
+		if (error != -ENOSPC)
+			break;
+		if (ip->i_di.di_depth < GFS2_DIR_MAX_DEPTH) {
+			error = dir_double_exhash(ip);
+			if (error)
+				break;
+			error = dir_split_leaf(inode, name);
+			if (error)
+				break;
+			continue;
+		}
+		error = dir_new_leaf(inode, name);
+		if (!error)
+			continue;
+		error = -ENOSPC;
+		break;
+	}
 	return error;
 }
 
+
 /**
  * gfs2_dir_del - Delete a directory entry
  * @dip: The GFS2 inode
@@ -2015,14 +1676,50 @@ int gfs2_dir_add(struct gfs2_inode *dip, struct qstr *filename,
  * Returns: 0 on success, error code on failure
  */
 
-int gfs2_dir_del(struct gfs2_inode *dip, struct qstr *filename)
+int gfs2_dir_del(struct gfs2_inode *dip, const struct qstr *name)
 {
+	struct gfs2_dirent *dent, *prev = NULL;
+	struct buffer_head *bh;
 	int error;
 
-	if (dip->i_di.di_flags & GFS2_DIF_EXHASH)
-		error = dir_e_del(dip, filename);
-	else
-		error = dir_l_del(dip, filename);
+	/* Returns _either_ the entry (if its first in block) or the
+	   previous entry otherwise */
+	dent = gfs2_dirent_search(dip->i_vnode, name, gfs2_dirent_prev, &bh);
+	if (!dent) {
+		gfs2_consist_inode(dip);
+		return -EIO;
+	}
+	if (IS_ERR(dent)) {
+		gfs2_consist_inode(dip);
+		return PTR_ERR(dent);
+	}
+	/* If not first in block, adjust pointers accordingly */
+	if (gfs2_dirent_find(dent, name) == 0) {
+		prev = dent;
+		dent = (struct gfs2_dirent *)((char *)dent + be16_to_cpu(prev->de_rec_len));
+	}
+
+	dirent_del(dip, bh, prev, dent);
+	if (dip->i_di.di_flags & GFS2_DIF_EXHASH) {
+		struct gfs2_leaf *leaf = (struct gfs2_leaf *)bh->b_data;
+		u16 entries = be16_to_cpu(leaf->lf_entries);
+		if (!entries)
+			gfs2_consist_inode(dip);
+		leaf->lf_entries = cpu_to_be16(--entries);
+		brelse(bh);
+	}
+
+	error = gfs2_meta_inode_buffer(dip, &bh);
+	if (error)
+		return error;
+
+	if (!dip->i_di.di_entries)
+		gfs2_consist_inode(dip);
+	gfs2_trans_add_bh(dip->i_gl, bh, 1);
+	dip->i_di.di_entries--;
+	dip->i_di.di_mtime = dip->i_di.di_ctime = get_seconds();
+	gfs2_dinode_out(&dip->i_di, bh->b_data);
+	brelse(bh);
 
 	return error;
 }
@@ -2053,17 +1750,37 @@ int gfs2_dir_read(struct gfs2_inode *dip, uint64_t *offset, void *opaque,
  * Returns: errno
  */
 
-int gfs2_dir_mvino(struct gfs2_inode *dip, struct qstr *filename,
+int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
 		   struct gfs2_inum *inum, unsigned int new_type)
 {
+	struct buffer_head *bh;
+	struct gfs2_dirent *dent;
 	int error;
 
-	if (dip->i_di.di_flags & GFS2_DIF_EXHASH)
-		error = dir_e_mvino(dip, filename, inum, new_type);
-	else
-		error = dir_l_mvino(dip, filename, inum, new_type);
+	dent = gfs2_dirent_search(dip->i_vnode, filename, gfs2_dirent_find, &bh);
+	if (!dent) {
+		gfs2_consist_inode(dip);
+		return -EIO;
+	}
+	if (IS_ERR(dent))
+		return PTR_ERR(dent);
 
-	return error;
+	gfs2_trans_add_bh(dip->i_gl, bh, 1);
+	gfs2_inum_out(inum, (char *)&dent->de_inum);
+	dent->de_type = cpu_to_be16(new_type);
+
+	if (dip->i_di.di_flags & GFS2_DIF_EXHASH) {
+		brelse(bh);
+		error = gfs2_meta_inode_buffer(dip, &bh);
+		if (error)
+			return error;
+		gfs2_trans_add_bh(dip->i_gl, bh, 1);
+	}
+
+	dip->i_di.di_mtime = dip->i_di.di_ctime = get_seconds();
+	gfs2_dinode_out(&dip->i_di, bh->b_data);
+	brelse(bh);
+	return 0;
 }
 
 /**
@@ -2079,7 +1796,7 @@ static int foreach_leaf(struct gfs2_inode *dip, leaf_call_t lc, void *data)
 {
 	struct gfs2_sbd *sdp = dip->i_sbd;
 	struct buffer_head *bh;
-	struct gfs2_leaf leaf;
+	struct gfs2_leaf *leaf;
 	uint32_t hsize, len;
 	uint32_t ht_offset, lp_offset, ht_offset_cur = -1;
 	uint32_t index = 0;
@@ -2118,10 +1835,10 @@ static int foreach_leaf(struct gfs2_inode *dip, leaf_call_t lc, void *data)
 			error = get_leaf(dip, leaf_no, &bh);
 			if (error)
 				goto out;
-			gfs2_leaf_in(&leaf, bh->b_data);
+			leaf = (struct gfs2_leaf *)bh->b_data;
 			brelse(bh);
 
-			len = 1 << (dip->i_di.di_depth - leaf.lf_depth);
+			len = 1 << (dip->i_di.di_depth - be16_to_cpu(leaf->lf_depth));
 
 			error = lc(dip, index, len, leaf_no, data);
 			if (error)
@@ -2158,10 +1875,10 @@ static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len,
 			uint64_t leaf_no, void *data)
 {
 	struct gfs2_sbd *sdp = dip->i_sbd;
-	struct gfs2_leaf tmp_leaf;
+	struct gfs2_leaf *tmp_leaf;
 	struct gfs2_rgrp_list rlist;
 	struct buffer_head *bh, *dibh;
-	uint64_t blk;
+	uint64_t blk, nblk;
 	unsigned int rg_blocks = 0, l_blocks = 0;
 	char *ht;
 	unsigned int x, size = len * sizeof(uint64_t);
@@ -2185,11 +1902,12 @@ static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len,
 
 	/*  Count the number of leaves  */
 
-	for (blk = leaf_no; blk; blk = tmp_leaf.lf_next) {
+	for (blk = leaf_no; blk; blk = nblk) {
 		error = get_leaf(dip, blk, &bh);
 		if (error)
 			goto out_rlist;
-		gfs2_leaf_in(&tmp_leaf, (bh)->b_data);
+		tmp_leaf = (struct gfs2_leaf *)bh->b_data;
+		nblk = be64_to_cpu(tmp_leaf->lf_next);
 		brelse(bh);
 
 		gfs2_rlist_add(sdp, &rlist, blk);
@@ -2214,11 +1932,12 @@ static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len,
 	if (error)
 		goto out_rg_gunlock;
 
-	for (blk = leaf_no; blk; blk = tmp_leaf.lf_next) {
+	for (blk = leaf_no; blk; blk = nblk) {
 		error = get_leaf(dip, blk, &bh);
 		if (error)
 			goto out_end_trans;
-		gfs2_leaf_in(&tmp_leaf, bh->b_data);
+		tmp_leaf = (struct gfs2_leaf *)bh->b_data;
+		nblk = be64_to_cpu(tmp_leaf->lf_next);
 		brelse(bh);
 
 		gfs2_free_meta(dip, blk, 1);
@@ -2308,63 +2027,22 @@ int gfs2_dir_exhash_dealloc(struct gfs2_inode *dip)
  * gfs2_diradd_alloc_required - find if adding entry will require an allocation
  * @ip: the file being written to
  * @filname: the filename that's going to be added
- * @alloc_required: set to 1 if an alloc is required, 0 otherwise
  *
- * Returns: errno
+ * Returns: 1 if alloc required, 0 if not, -ve on error
  */
 
-int gfs2_diradd_alloc_required(struct gfs2_inode *dip, struct qstr *filename,
-			       int *alloc_required)
+int gfs2_diradd_alloc_required(struct inode *inode,
+			       const struct qstr *name)
 {
-	struct buffer_head *bh = NULL, *bh_next;
-	uint32_t hsize, hash, index;
-	int error = 0;
-
-	*alloc_required = 0;
-
-	if (dip->i_di.di_flags & GFS2_DIF_EXHASH) {
-		hsize = 1 << dip->i_di.di_depth;
-		if (hsize * sizeof(uint64_t) != dip->i_di.di_size) {
-			gfs2_consist_inode(dip);
-			return -EIO;
-		}
-
-		hash = gfs2_disk_hash(filename->name, filename->len);
-		index = hash >> (32 - dip->i_di.di_depth);
-
-		error = get_first_leaf(dip, index, &bh_next);
-		if (error)
-			return error;
-
-		do {
-			brelse(bh);
-
-			bh = bh_next;
-
-			if (dirent_fits(dip, bh, filename->len))
-				break;
-
-			error = get_next_leaf(dip, bh, &bh_next);
-			if (error == -ENOENT) {
-				*alloc_required = 1;
-				error = 0;
-				break;
-			}
-		}
-		while (!error);
-
-		brelse(bh);
-	} else {
-		error = gfs2_meta_inode_buffer(dip, &bh);
-		if (error)
-			return error;
-
-		if (!dirent_fits(dip, bh, filename->len))
-			*alloc_required = 1;
-
-		brelse(bh);
-	}
+	struct gfs2_dirent *dent;
+	struct buffer_head *bh;
 
-	return error;
+	dent = gfs2_dirent_search(inode, name, gfs2_dirent_find_space, &bh);
+	if (!dent)
+		return 1;
+	if (IS_ERR(dent))
+		return PTR_ERR(dent);
+	brelse(bh);
+	return 0;
 }
 
diff --git a/fs/gfs2/dir.h b/fs/gfs2/dir.h
index 5b01497b3ab3..8fd4dc0f700e 100644
--- a/fs/gfs2/dir.h
+++ b/fs/gfs2/dir.h
@@ -27,25 +27,34 @@ typedef int (*gfs2_filldir_t) (void *opaque,
 			      uint64_t offset,
 			      struct gfs2_inum *inum, unsigned int type);
 
-int gfs2_filecmp(struct qstr *file1, char *file2, int len_of_file2);
-int gfs2_dirent_alloc(struct gfs2_inode *dip, struct buffer_head *bh,
-		     int name_len, struct gfs2_dirent **dent_out);
-
-int gfs2_dir_search(struct gfs2_inode *dip, struct qstr *filename,
-		   struct gfs2_inum *inum, unsigned int *type);
-int gfs2_dir_add(struct gfs2_inode *dip, struct qstr *filename,
-		struct gfs2_inum *inum, unsigned int type);
-int gfs2_dir_del(struct gfs2_inode *dip, struct qstr *filename);
+int gfs2_dir_search(struct inode *dir, const struct qstr *filename,
+		    struct gfs2_inum *inum, unsigned int *type);
+int gfs2_dir_add(struct inode *inode, const struct qstr *filename,
+		 const struct gfs2_inum *inum, unsigned int type);
+int gfs2_dir_del(struct gfs2_inode *dip, const struct qstr *filename);
 int gfs2_dir_read(struct gfs2_inode *dip, uint64_t * offset, void *opaque,
-		 gfs2_filldir_t filldir);
-int gfs2_dir_mvino(struct gfs2_inode *dip, struct qstr *filename,
-		  struct gfs2_inum *new_inum, unsigned int new_type);
+		  gfs2_filldir_t filldir);
+int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
+		   struct gfs2_inum *new_inum, unsigned int new_type);
 
 int gfs2_dir_exhash_dealloc(struct gfs2_inode *dip);
 
-int gfs2_diradd_alloc_required(struct gfs2_inode *dip, struct qstr *filename,
-			      int *alloc_required);
+int gfs2_diradd_alloc_required(struct inode *dir,
+			       const struct qstr *filename);
 int gfs2_dir_get_buffer(struct gfs2_inode *ip, uint64_t block, int new,
-                         struct buffer_head **bhp);
+                        struct buffer_head **bhp);
+
+/* N.B. This probably ought to take inum & type as args as well */
+static inline void gfs2_qstr2dirent(const struct qstr *name, u16 reclen, struct gfs2_dirent *dent)
+{
+	dent->de_inum.no_addr = cpu_to_be64(0);
+	dent->de_inum.no_formal_ino = cpu_to_be64(0);
+	dent->de_hash = cpu_to_be32(name->hash);
+	dent->de_rec_len = cpu_to_be16(reclen);
+	dent->de_name_len = cpu_to_be16(name->len);
+	dent->de_type = cpu_to_be16(0);
+	memset(dent->__pad, 0, sizeof(dent->__pad));
+	memcpy((char*)(dent+1), name->name, name->len);
+}
 
 #endif /* __DIR_DOT_H__ */
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index cd1de61bff2f..d403d51d5b0f 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -228,12 +228,10 @@ struct inode *gfs2_iget(struct super_block *sb, struct gfs2_inum *inum)
 
 void gfs2_inode_min_init(struct gfs2_inode *ip, unsigned int type)
 {
-	spin_lock(&ip->i_spin);
 	if (!test_and_set_bit(GIF_MIN_INIT, &ip->i_flags)) {
 		ip->i_di.di_nlink = 1;
 		ip->i_di.di_mode = DT2IF(type);
 	}
-	spin_unlock(&ip->i_spin);
 }
 
 /**
@@ -257,10 +255,8 @@ int gfs2_inode_refresh(struct gfs2_inode *ip)
 		return -EIO;
 	}
 
-	spin_lock(&ip->i_spin);
 	gfs2_dinode_in(&ip->i_di, dibh->b_data);
 	set_bit(GIF_MIN_INIT, &ip->i_flags);
-	spin_unlock(&ip->i_spin);
 
 	brelse(dibh);
 
@@ -702,6 +698,16 @@ int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
 	return 0;
 }
 
+struct inode *gfs2_lookup_simple(struct inode *dip, const char *name)
+{
+	struct qstr qstr;
+	qstr.name = name;
+	qstr.len = strlen(name);
+	qstr.hash = gfs2_disk_hash(qstr.name, qstr.len);
+	return gfs2_lookupi(dip, &qstr, 1, NULL);
+}
+
+
 /**
  * gfs2_lookupi - Look up a filename in a directory and return its inode
  * @d_gh: An initialized holder for the directory glock
@@ -715,8 +721,9 @@ int gfs2_change_nlink(struct gfs2_inode *ip, int diff)
  * Returns: errno
  */
 
-int gfs2_lookupi(struct inode *dir, struct qstr *name, int is_root,
-		 struct inode **inodep)
+struct inode *gfs2_lookupi(struct inode *dir, struct qstr *name, int is_root,
+			   struct nameidata *nd)
+		 
 {
 	struct super_block *sb = dir->i_sb;
 	struct gfs2_inode *ipp;
@@ -727,14 +734,14 @@ int gfs2_lookupi(struct inode *dir, struct qstr *name, int is_root,
 	unsigned int type;
 	struct gfs2_glock *gl;
 	int error = 0;
-
-	*inodep = NULL;
+	struct inode *inode = NULL;
 
 	if (!name->len || name->len > GFS2_FNAMESIZE)
-		return -ENAMETOOLONG;
+		return ERR_PTR(-ENAMETOOLONG);
 
-	if (gfs2_filecmp(name, ".", 1) ||
-	    (gfs2_filecmp(name, "..", 2) && dir == sb->s_root->d_inode)) {
+	if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) ||
+	    (name->len == 2 && memcmp(name->name, "..", 2) == 0 &&
+	     dir == sb->s_root->d_inode)) {
 		gfs2_inode_hold(dip);
 		ipp = dip;
 		goto done;
@@ -742,7 +749,7 @@ int gfs2_lookupi(struct inode *dir, struct qstr *name, int is_root,
 
 	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
 	if (error)
-		return error;
+		return ERR_PTR(error);
 
 	if (!is_root) {
 		error = gfs2_repermission(dip->i_vnode, MAY_EXEC, NULL);
@@ -750,7 +757,7 @@ int gfs2_lookupi(struct inode *dir, struct qstr *name, int is_root,
 			goto out;
 	}
 
-	error = gfs2_dir_search(dip, name, &inum, &type);
+	error = gfs2_dir_search(dir, name, &inum, &type);
 	if (error)
 		goto out;
 
@@ -768,13 +775,16 @@ int gfs2_lookupi(struct inode *dir, struct qstr *name, int is_root,
 out:
 	gfs2_glock_dq_uninit(&d_gh);
 done:
+	if (error == -ENOENT)
+		return NULL;
 	if (error == 0) {
-		*inodep = gfs2_ip2v(ipp);
-		if (!*inodep)
-			error = -ENOMEM;
+		inode = gfs2_ip2v(ipp);
 		gfs2_inode_put(ipp);
+		if (!inode)
+			return ERR_PTR(-ENOMEM);
+		return inode;
 	}
-	return error;
+	return ERR_PTR(error);
 }
 
 static int pick_formal_ino_1(struct gfs2_sbd *sdp, uint64_t *formal_ino)
@@ -918,7 +928,7 @@ static int create_ok(struct gfs2_inode *dip, struct qstr *name,
 	if (!dip->i_di.di_nlink)
 		return -EPERM;
 
-	error = gfs2_dir_search(dip, name, NULL, NULL);
+	error = gfs2_dir_search(dip->i_vnode, name, NULL, NULL);
 	switch (error) {
 	case -ENOENT:
 		error = 0;
@@ -1116,7 +1126,9 @@ static int link_dinode(struct gfs2_inode *dip, struct qstr *name,
 	if (error)
 		goto fail;
 
-	error = gfs2_diradd_alloc_required(dip, name, &alloc_required);
+	error = alloc_required = gfs2_diradd_alloc_required(dip->i_vnode, name);
+	if (alloc_required < 0)
+		goto fail;
 	if (alloc_required) {
 		error = gfs2_quota_check(dip, dip->i_di.di_uid,
 					 dip->i_di.di_gid);
@@ -1145,7 +1157,7 @@ static int link_dinode(struct gfs2_inode *dip, struct qstr *name,
 			goto fail_quota_locks;
 	}
 
-	error = gfs2_dir_add(dip, name, &ip->i_num, IF2DT(ip->i_di.di_mode));
+	error = gfs2_dir_add(dip->i_vnode, name, &ip->i_num, IF2DT(ip->i_di.di_mode));
 	if (error)
 		goto fail_end_trans;
 
@@ -1379,12 +1391,14 @@ int gfs2_rmdiri(struct gfs2_inode *dip, struct qstr *name,
 
 	dotname.len = 1;
 	dotname.name = ".";
+	dotname.hash = gfs2_disk_hash(dotname.name, dotname.len);
 	error = gfs2_dir_del(ip, &dotname);
 	if (error)
 		return error;
 
 	dotname.len = 2;
 	dotname.name = "..";
+	dotname.hash = gfs2_disk_hash(dotname.name, dotname.len);
 	error = gfs2_dir_del(ip, &dotname);
 	if (error)
 		return error;
@@ -1439,7 +1453,7 @@ int gfs2_unlink_ok(struct gfs2_inode *dip, struct qstr *name,
 	if (error)
 		return error;
 
-	error = gfs2_dir_search(dip, name, &inum, &type);
+	error = gfs2_dir_search(dip->i_vnode, name, &inum, &type);
 	if (error)
 		return error;
 
@@ -1476,6 +1490,7 @@ int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
 	memset(&dotdot, 0, sizeof(struct qstr));
 	dotdot.name = "..";
 	dotdot.len = 2;
+	dotdot.hash = gfs2_disk_hash(dotdot.name, dotdot.len);
 
 	igrab(dir);
 
@@ -1489,9 +1504,11 @@ int gfs2_ok_to_move(struct gfs2_inode *this, struct gfs2_inode *to)
 			break;
 		}
 
-		error = gfs2_lookupi(dir, &dotdot, 1, &tmp);
-		if (error)
+		tmp = gfs2_lookupi(dir, &dotdot, 1, NULL);
+		if (IS_ERR(tmp)) {
+			error = PTR_ERR(tmp);
 			break;
+		}
 
 		iput(dir);
 		dir = tmp;
diff --git a/fs/gfs2/inode.h b/fs/gfs2/inode.h
index c3fa6cfce169..0dd2a26626ec 100644
--- a/fs/gfs2/inode.h
+++ b/fs/gfs2/inode.h
@@ -44,8 +44,8 @@ void gfs2_inode_destroy(struct gfs2_inode *ip);
 int gfs2_inode_dealloc(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul);
 
 int gfs2_change_nlink(struct gfs2_inode *ip, int diff);
-int gfs2_lookupi(struct inode *dir, struct qstr *name, int is_root,
-		 struct inode **ipp);
+struct inode *gfs2_lookupi(struct inode *dir, struct qstr *name, int is_root,
+			   struct nameidata *nd);
 struct inode *gfs2_createi(struct gfs2_holder *ghs, struct qstr *name,
 			   unsigned int mode);
 int gfs2_unlinki(struct gfs2_inode *dip, struct qstr *name,
@@ -66,17 +66,7 @@ int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr);
 
 int gfs2_repermission(struct inode *inode, int mask, struct nameidata *nd);
 
-static inline int gfs2_lookup_simple(struct inode *dip, char *name,
-				     struct inode **ipp)
-{
-	struct qstr qstr;
-	int err;
-	memset(&qstr, 0, sizeof(struct qstr));
-	qstr.name = name;
-	qstr.len = strlen(name);
-	err = gfs2_lookupi(dip, &qstr, 1, ipp);
-	return err;
-}
+struct inode *gfs2_lookup_simple(struct inode *dip, const char *name);
 
 #endif /* __INODE_DOT_H__ */
 
diff --git a/fs/gfs2/ondisk.c b/fs/gfs2/ondisk.c
index 5a0bdc22a1f4..3be060f1cbe7 100644
--- a/fs/gfs2/ondisk.c
+++ b/fs/gfs2/ondisk.c
@@ -64,7 +64,7 @@ void gfs2_inum_in(struct gfs2_inum *no, char *buf)
 	no->no_addr = be64_to_cpu(str->no_addr);
 }
 
-void gfs2_inum_out(struct gfs2_inum *no, char *buf)
+void gfs2_inum_out(const struct gfs2_inum *no, char *buf)
 {
 	struct gfs2_inum *str = (struct gfs2_inum *)buf;
 
@@ -342,17 +342,6 @@ void gfs2_dirent_print(struct gfs2_dirent *de, char *name)
 	printk(KERN_INFO "  name = %s\n", buf);
 }
 
-void gfs2_leaf_in(struct gfs2_leaf *lf, char *buf)
-{
-	struct gfs2_leaf *str = (struct gfs2_leaf *)buf;
-
-	gfs2_meta_header_in(&lf->lf_header, buf);
-	lf->lf_depth = be16_to_cpu(str->lf_depth);
-	lf->lf_entries = be16_to_cpu(str->lf_entries);
-	lf->lf_dirent_format = be32_to_cpu(str->lf_dirent_format);
-	lf->lf_next = be64_to_cpu(str->lf_next);
-}
-
 void gfs2_leaf_print(struct gfs2_leaf *lf)
 {
 	gfs2_meta_header_print(&lf->lf_header);
diff --git a/fs/gfs2/ops_dentry.c b/fs/gfs2/ops_dentry.c
index 7f6139288519..b54608f9df50 100644
--- a/fs/gfs2/ops_dentry.c
+++ b/fs/gfs2/ops_dentry.c
@@ -38,25 +38,26 @@
 static int gfs2_drevalidate(struct dentry *dentry, struct nameidata *nd)
 {
 	struct dentry *parent = dget_parent(dentry);
+	struct gfs2_sbd *sdp = parent->d_inode->i_sb->s_fs_info;
 	struct gfs2_inode *dip = parent->d_inode->u.generic_ip;
-	struct inode *inode;
+	struct inode *inode = dentry->d_inode;
 	struct gfs2_holder d_gh;
 	struct gfs2_inode *ip;
 	struct gfs2_inum inum;
 	unsigned int type;
 	int error;
 
-	lock_kernel();
-
-	inode = dentry->d_inode;
 	if (inode && is_bad_inode(inode))
 		goto invalid;
 
+	if (sdp->sd_args.ar_localcaching)
+		goto valid;
+
 	error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
 	if (error)
 		goto fail;
 
-	error = gfs2_dir_search(dip, &dentry->d_name, &inum, &type);
+	error = gfs2_dir_search(parent->d_inode, &dentry->d_name, &inum, &type);
 	switch (error) {
 	case 0:
 		if (!inode)
@@ -84,7 +85,6 @@ static int gfs2_drevalidate(struct dentry *dentry, struct nameidata *nd)
 	gfs2_glock_dq_uninit(&d_gh);
 
  valid:
-	unlock_kernel();
 	dput(parent);
 	return 1;
 
@@ -99,7 +99,6 @@ static int gfs2_drevalidate(struct dentry *dentry, struct nameidata *nd)
 	}
 	d_drop(dentry);
 
-	unlock_kernel();
 	dput(parent);
 	return 0;
 
@@ -107,12 +106,18 @@ static int gfs2_drevalidate(struct dentry *dentry, struct nameidata *nd)
 	gfs2_glock_dq_uninit(&d_gh);
 
  fail:
-	unlock_kernel();
 	dput(parent);
 	return 0;
 }
 
+static int gfs2_dhash(struct dentry *dentry, struct qstr *str)
+{
+	str->hash = gfs2_disk_hash(str->name, str->len);
+	return 0;
+}
+
 struct dentry_operations gfs2_dops = {
 	.d_revalidate = gfs2_drevalidate,
+	.d_hash = gfs2_dhash,
 };
 
diff --git a/fs/gfs2/ops_export.c b/fs/gfs2/ops_export.c
index a346943363c6..b27bce74a795 100644
--- a/fs/gfs2/ops_export.c
+++ b/fs/gfs2/ops_export.c
@@ -24,6 +24,7 @@
 #include "inode.h"
 #include "ops_export.h"
 #include "rgrp.h"
+#include "util.h"
 
 static struct dentry *gfs2_decode_fh(struct super_block *sb,
 				     __u32 *fh,
@@ -167,11 +168,15 @@ static struct dentry *gfs2_get_parent(struct dentry *child)
 	struct qstr dotdot = { .name = "..", .len = 2 };
 	struct inode *inode;
 	struct dentry *dentry;
-	int error;
 
-	error = gfs2_lookupi(child->d_inode, &dotdot, 1, &inode);
-	if (error)
-		return ERR_PTR(error);
+	dotdot.hash = gfs2_disk_hash(dotdot.name, dotdot.len);
+
+	inode = gfs2_lookupi(child->d_inode, &dotdot, 1, NULL);
+
+	if (!inode)
+		return ERR_PTR(-ENOENT);
+	if (IS_ERR(inode))
+		return ERR_PTR(PTR_ERR(inode));
 
 	dentry = d_alloc_anon(inode);
 	if (!dentry) {
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 8d6d94143561..8d2c557b3ff4 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -379,11 +379,10 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
 		goto fail_recoverd;
 	}
 
-	error = gfs2_lookup_simple(sdp->sd_master_dir, "jindex",
-				   &sdp->sd_jindex);
-	if (error) {
+	sdp->sd_jindex = gfs2_lookup_simple(sdp->sd_master_dir, "jindex");
+	if (IS_ERR(sdp->sd_jindex)) {
 		fs_err(sdp, "can't lookup journal index: %d\n", error);
-		return error;
+		return PTR_ERR(sdp->sd_jindex);
 	}
 	ip = sdp->sd_jindex->u.generic_ip;
 	set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
@@ -531,26 +530,26 @@ static int init_inodes(struct gfs2_sbd *sdp, int undo)
 		goto fail_master;
 
 	/* Read in the master inode number inode */
-	error = gfs2_lookup_simple(sdp->sd_master_dir, "inum",
-				   &sdp->sd_inum_inode);
-	if (error) {
+	sdp->sd_inum_inode = gfs2_lookup_simple(sdp->sd_master_dir, "inum");
+	if (IS_ERR(sdp->sd_inum_inode)) {
+		error = PTR_ERR(sdp->sd_inum_inode);
 		fs_err(sdp, "can't read in inum inode: %d\n", error);
 		goto fail_journal;
 	}
 
 
 	/* Read in the master statfs inode */
-	error = gfs2_lookup_simple(sdp->sd_master_dir, "statfs",
-				   &sdp->sd_statfs_inode);
-	if (error) {
+	sdp->sd_statfs_inode = gfs2_lookup_simple(sdp->sd_master_dir, "statfs");
+	if (IS_ERR(sdp->sd_statfs_inode)) {
+		error = PTR_ERR(sdp->sd_statfs_inode);
 		fs_err(sdp, "can't read in statfs inode: %d\n", error);
 		goto fail_inum;
 	}
 
 	/* Read in the resource index inode */
-	error = gfs2_lookup_simple(sdp->sd_master_dir, "rindex",
-				   &sdp->sd_rindex);
-	if (error) {
+	sdp->sd_rindex = gfs2_lookup_simple(sdp->sd_master_dir, "rindex");
+	if (IS_ERR(sdp->sd_rindex)) {
+		error = PTR_ERR(sdp->sd_rindex);
 		fs_err(sdp, "can't get resource index inode: %d\n", error);
 		goto fail_statfs;
 	}
@@ -559,9 +558,9 @@ static int init_inodes(struct gfs2_sbd *sdp, int undo)
 	sdp->sd_rindex_vn = ip->i_gl->gl_vn - 1;
 
 	/* Read in the quota inode */
-	error = gfs2_lookup_simple(sdp->sd_master_dir, "quota",
-				   &sdp->sd_quota_inode);
-	if (error) {
+	sdp->sd_quota_inode = gfs2_lookup_simple(sdp->sd_master_dir, "quota");
+	if (IS_ERR(sdp->sd_quota_inode)) {
+		error = PTR_ERR(sdp->sd_quota_inode);
 		fs_err(sdp, "can't get quota file inode: %d\n", error);
 		goto fail_rindex;
 	}
@@ -600,36 +599,41 @@ static int init_per_node(struct gfs2_sbd *sdp, int undo)
 	if (undo)
 		goto fail_qc_gh;
 
-	error = gfs2_lookup_simple(sdp->sd_master_dir, "per_node", &pn);
-	if (error) {
+	pn = gfs2_lookup_simple(sdp->sd_master_dir, "per_node");
+	if (IS_ERR(pn)) {
+		error = PTR_ERR(pn);
 		fs_err(sdp, "can't find per_node directory: %d\n", error);
 		return error;
 	}
 
 	sprintf(buf, "inum_range%u", sdp->sd_jdesc->jd_jid);
-	error = gfs2_lookup_simple(pn, buf, &sdp->sd_ir_inode);
-	if (error) {
+	sdp->sd_ir_inode = gfs2_lookup_simple(pn, buf);
+	if (IS_ERR(sdp->sd_ir_inode)) {
+		error = PTR_ERR(sdp->sd_ir_inode);
 		fs_err(sdp, "can't find local \"ir\" file: %d\n", error);
 		goto fail;
 	}
 
 	sprintf(buf, "statfs_change%u", sdp->sd_jdesc->jd_jid);
-	error = gfs2_lookup_simple(pn, buf, &sdp->sd_sc_inode);
-	if (error) {
+	sdp->sd_sc_inode = gfs2_lookup_simple(pn, buf);
+	if (IS_ERR(sdp->sd_sc_inode)) {
+		error = PTR_ERR(sdp->sd_sc_inode);
 		fs_err(sdp, "can't find local \"sc\" file: %d\n", error);
 		goto fail_ir_i;
 	}
 
 	sprintf(buf, "unlinked_tag%u", sdp->sd_jdesc->jd_jid);
-	error = gfs2_lookup_simple(pn, buf, &sdp->sd_ut_inode);
-	if (error) {
+	sdp->sd_ut_inode = gfs2_lookup_simple(pn, buf);
+	if (IS_ERR(sdp->sd_ut_inode)) {
+		error = PTR_ERR(sdp->sd_ut_inode);
 		fs_err(sdp, "can't find local \"ut\" file: %d\n", error);
 		goto fail_sc_i;
 	}
 
 	sprintf(buf, "quota_change%u", sdp->sd_jdesc->jd_jid);
-	error = gfs2_lookup_simple(pn, buf, &sdp->sd_qc_inode);
-	if (error) {
+	sdp->sd_qc_inode = gfs2_lookup_simple(pn, buf);
+	if (IS_ERR(sdp->sd_qc_inode)) {
+		error = PTR_ERR(sdp->sd_qc_inode);
 		fs_err(sdp, "can't find local \"qc\" file: %d\n", error);
 		goto fail_ut_i;
 	}
diff --git a/fs/gfs2/ops_inode.c b/fs/gfs2/ops_inode.c
index 7633a8584b0d..e8ab9d254b76 100644
--- a/fs/gfs2/ops_inode.c
+++ b/fs/gfs2/ops_inode.c
@@ -58,7 +58,6 @@ static int gfs2_create(struct inode *dir, struct dentry *dentry,
 	struct gfs2_holder ghs[2];
 	struct inode *inode;
 	int new = 1;
-	int error;
 
 	gfs2_holder_init(dip->i_gl, 0, 0, ghs);
 
@@ -78,14 +77,16 @@ static int gfs2_create(struct inode *dir, struct dentry *dentry,
 			return PTR_ERR(inode);
 		}
 
-		error = gfs2_lookupi(dir, &dentry->d_name, 0, &inode);
-		if (!error) {
-			new = 0;
-			gfs2_holder_uninit(ghs);
-			break;
-		} else if (error != -ENOENT) {
-			gfs2_holder_uninit(ghs);
-			return error;
+		inode = gfs2_lookupi(dir, &dentry->d_name, 0, nd);
+		if (inode) {
+			if (!IS_ERR(inode)) {
+				new = 0;
+				gfs2_holder_uninit(ghs);
+				break;
+			} else {
+				gfs2_holder_uninit(ghs);
+				return PTR_ERR(inode);
+			}
 		}
 	}
 
@@ -110,17 +111,13 @@ static int gfs2_create(struct inode *dir, struct dentry *dentry,
 static struct dentry *gfs2_lookup(struct inode *dir, struct dentry *dentry,
 				  struct nameidata *nd)
 {
-	struct gfs2_inode *dip = dir->u.generic_ip;
-	struct gfs2_sbd *sdp = dip->i_sbd;
 	struct inode *inode = NULL;
-	int error;
 
-	if (!sdp->sd_args.ar_localcaching)
-		dentry->d_op = &gfs2_dops;
+	dentry->d_op = &gfs2_dops;
 
-	error = gfs2_lookupi(dir, &dentry->d_name, 0, &inode);
-	if (error && error != -ENOENT)
-		return ERR_PTR(error);
+	inode = gfs2_lookupi(dir, &dentry->d_name, 0, nd);
+	if (inode && IS_ERR(inode))
+		return ERR_PTR(PTR_ERR(inode));
 
 	if (inode)
 		return d_splice_alias(inode, dentry);
@@ -166,7 +163,7 @@ static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 	if (error)
 		goto out_gunlock;
 
-	error = gfs2_dir_search(dip, &dentry->d_name, NULL, NULL);
+	error = gfs2_dir_search(dir, &dentry->d_name, NULL, NULL);
 	switch (error) {
 	case -ENOENT:
 		break;
@@ -192,10 +189,10 @@ static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 	if (ip->i_di.di_nlink == (uint32_t)-1)
 		goto out_gunlock;
 
-	error = gfs2_diradd_alloc_required(dip, &dentry->d_name,
-					   &alloc_required);
-	if (error)
+	alloc_required = error = gfs2_diradd_alloc_required(dir, &dentry->d_name);
+	if (error < 0)
 		goto out_gunlock;
+	error = 0;
 
 	if (alloc_required) {
 		struct gfs2_alloc *al = gfs2_alloc_get(dip);
@@ -228,7 +225,7 @@ static int gfs2_link(struct dentry *old_dentry, struct inode *dir,
 			goto out_ipres;
 	}
 
-	error = gfs2_dir_add(dip, &dentry->d_name, &ip->i_num,
+	error = gfs2_dir_add(dir, &dentry->d_name, &ip->i_num,
 			     IF2DT(ip->i_di.di_mode));
 	if (error)
 		goto out_end_trans;
@@ -419,24 +416,24 @@ static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 
 	if (!gfs2_assert_withdraw(sdp, !error)) {
 		struct gfs2_dinode *di = (struct gfs2_dinode *)dibh->b_data;
-		struct gfs2_dirent *dent;
-
-		gfs2_dirent_alloc(ip, dibh, 1, &dent);
+		struct gfs2_dirent *dent = (struct gfs2_dirent *)(di+1);
+		struct qstr str = { .name = ".", .len = 1 };
+		str.hash = gfs2_disk_hash(str.name, str.len);
 
+		gfs2_trans_add_bh(ip->i_gl, dibh, 1);
+		gfs2_qstr2dirent(&str, GFS2_DIRENT_SIZE(str.len), dent);
 		dent->de_inum = di->di_num; /* already GFS2 endian */
-		dent->de_hash = gfs2_disk_hash(".", 1);
-		dent->de_hash = cpu_to_be32(dent->de_hash);
 		dent->de_type = DT_DIR;
-		memcpy((char *) (dent + 1), ".", 1);
 		di->di_entries = cpu_to_be32(1);
 
-		gfs2_dirent_alloc(ip, dibh, 2, &dent);
+		str.name = "..";
+		str.len = 2;
+		str.hash = gfs2_disk_hash(str.name, str.len);
+		dent = (struct gfs2_dirent *)((char*)dent + GFS2_DIRENT_SIZE(1));
+		gfs2_qstr2dirent(&str, dibh->b_size - GFS2_DIRENT_SIZE(1) - sizeof(struct gfs2_dinode), dent);
 
 		gfs2_inum_out(&dip->i_num, (char *) &dent->de_inum);
-		dent->de_hash = gfs2_disk_hash("..", 2);
-		dent->de_hash = cpu_to_be32(dent->de_hash);
 		dent->de_type = DT_DIR;
-		memcpy((char *) (dent + 1), "..", 2);
 
 		gfs2_dinode_out(&ip->i_di, (char *)di);
 
@@ -687,7 +684,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
 		if (error)
 			goto out_gunlock;
 
-		error = gfs2_dir_search(ndip, &ndentry->d_name, NULL, NULL);
+		error = gfs2_dir_search(ndir, &ndentry->d_name, NULL, NULL);
 		switch (error) {
 		case -ENOENT:
 			error = 0;
@@ -723,10 +720,10 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
 			goto out_gunlock;
 	}
 
-	error = gfs2_diradd_alloc_required(ndip, &ndentry->d_name,
-					   &alloc_required);
-	if (error)
+	alloc_required = error = gfs2_diradd_alloc_required(ndir, &ndentry->d_name);
+	if (error < 0)
 		goto out_gunlock;
+	error = 0;
 
 	if (alloc_required) {
 		struct gfs2_alloc *al = gfs2_alloc_get(ndip);
@@ -777,6 +774,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
 		struct qstr name;
 		name.len = 2;
 		name.name = "..";
+		name.hash = gfs2_disk_hash(name.name, name.len);
 
 		error = gfs2_change_nlink(ndip, +1);
 		if (error)
@@ -803,7 +801,7 @@ static int gfs2_rename(struct inode *odir, struct dentry *odentry,
 	if (error)
 		goto out_end_trans;
 
-	error = gfs2_dir_add(ndip, &ndentry->d_name, &ip->i_num,
+	error = gfs2_dir_add(ndir, &ndentry->d_name, &ip->i_num,
 			     IF2DT(ip->i_di.di_mode));
 	if (error)
 		goto out_end_trans;
diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index fff5a96f4152..71cca7629403 100644
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -299,8 +299,9 @@ int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
 			break;
 
 		name.len = sprintf(buf, "journal%u", sdp->sd_journals);
+		name.hash = gfs2_disk_hash(name.name, name.len);
 
-		error = gfs2_dir_search(sdp->sd_jindex->u.generic_ip,
+		error = gfs2_dir_search(sdp->sd_jindex,
 					&name, NULL, NULL);
 		if (error == -ENOENT) {
 			error = 0;
@@ -317,8 +318,12 @@ int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
 		if (!jd)
 			break;
 
-		error = gfs2_lookupi(sdp->sd_jindex, &name, 1, &jd->jd_inode);
-		if (error) {
+		jd->jd_inode = gfs2_lookupi(sdp->sd_jindex, &name, 1, NULL);
+		if (!jd->jd_inode || IS_ERR(jd->jd_inode)) {
+			if (!jd->jd_inode)
+				error = -ENOENT;
+			else
+				error = PTR_ERR(jd->jd_inode);
 			kfree(jd);
 			break;
 		}