diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index 37f70ca558c..f31f163da1a 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);
 
-int gfs2_filecmp(struct qstr *file1, char *file2, int len_of_file2)
+static inline int __gfs2_dirent_find(const struct gfs2_dirent *dent,
+				     const struct qstr *name, int ret)
 {
-	if (file1->len != len_of_file2)
-		return 0;
-	if (memcmp(file1->name, file2, file1->len))
-		return 0;
-	return 1;
+	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;
+}
+
+static int gfs2_dirent_find_space(const struct gfs2_dirent *dent,
+				  const struct qstr *name)
+{
+	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;
+	struct gfs2_inode *ip = inode->u.generic_ip;
+	struct gfs2_dirent *ndent;
+	unsigned offset = 0, totlen;
 
-	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;
+	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;
+	struct buffer_head *bh;
+	struct gfs2_dirent *dent;
+	struct gfs2_inode *ip = inode->u.generic_ip;
 	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;
-	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;
-
-		default:
-			brelse(bh);
-			return error;
+	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);
 		}
 
-		error = get_next_leaf(dip, bh, &bh_next);
+		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);
+			if (!ln)
+				break;
+			error = get_leaf(ip, ln, &bh);
+		} while(!error);
+
+		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);
+	} while (dent);
 
-	/* If none of the entries got moved into the new leaf,
-	   artificially fill in the first entry. */
-
-	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);
 		}
 	}
@@ -1445,207 +1402,6 @@ static int do_filldir_multi(struct gfs2_inode *dip, uint64_t *offset,
 	return error;
 }
 
-/**
- * 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
@@ -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;
+	struct gfs2_dirent *dent;
+	struct buffer_head *bh;
 
-	*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);
-	}
-
-	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 5b01497b3ab..8fd4dc0f700 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 cd1de61bff2..d403d51d5b0 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 c3fa6cfce16..0dd2a26626e 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 5a0bdc22a1f..3be060f1cbe 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 7f613928851..b54608f9df5 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 a346943363c..b27bce74a79 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 8d6d9414356..8d2c557b3ff 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 7633a8584b0..e8ab9d254b7 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 fff5a96f415..71cca762940 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;
 		}
diff --git a/include/linux/gfs2_ondisk.h b/include/linux/gfs2_ondisk.h
index 8d4f0445df4..a5fb4f99aa4 100644
--- a/include/linux/gfs2_ondisk.h
+++ b/include/linux/gfs2_ondisk.h
@@ -411,7 +411,7 @@ struct gfs2_quota_change {
 /* Translation functions */
 
 extern void gfs2_inum_in(struct gfs2_inum *no, char *buf);
-extern void gfs2_inum_out(struct gfs2_inum *no, char *buf);
+extern void gfs2_inum_out(const struct gfs2_inum *no, char *buf);
 extern void gfs2_sb_in(struct gfs2_sb *sb, char *buf);
 extern void gfs2_rindex_in(struct gfs2_rindex *ri, char *buf);
 extern void gfs2_rindex_out(struct gfs2_rindex *ri, char *buf);
@@ -421,7 +421,6 @@ extern void gfs2_quota_in(struct gfs2_quota *qu, char *buf);
 extern void gfs2_quota_out(struct gfs2_quota *qu, char *buf);
 extern void gfs2_dinode_in(struct gfs2_dinode *di, char *buf);
 extern void gfs2_dinode_out(struct gfs2_dinode *di, char *buf);
-extern void gfs2_leaf_in(struct gfs2_leaf *lf, char *buf);
 extern void gfs2_ea_header_in(struct gfs2_ea_header *ea, char *buf);
 extern void gfs2_ea_header_out(struct gfs2_ea_header *ea, char *buf);
 extern void gfs2_log_header_in(struct gfs2_log_header *lh, char *buf);