// SPDX-License-Identifier: GPL-2.0-or-later

  /* -*- mode: c; c-basic-offset: 8; -*-
   * vim: noexpandtab sw=8 ts=8 sts=0:
   *
   * dir.c
   *
   * Creates, reads, walks and deletes directory-nodes
   *
   * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
   *
   *  Portions of this code from linux/fs/ext3/dir.c
   *
   *  Copyright (C) 1992, 1993, 1994, 1995
   *  Remy Card (card@masi.ibp.fr)
   *  Laboratoire MASI - Institut Blaise pascal
   *  Universite Pierre et Marie Curie (Paris VI)
   *
   *   from
   *
   *   linux/fs/minix/dir.c
   *

   *   Copyright (C) 1991, 1992 Linus Torvalds

   */
  
  #include <linux/fs.h>
  #include <linux/types.h>
  #include <linux/slab.h>
  #include <linux/highmem.h>

  #include <linux/quotaops.h>

  #include <linux/sort.h>

  #include <linux/iversion.h>

  #include <cluster/masklog.h>
  
  #include "ocfs2.h"
  
  #include "alloc.h"

  #include "blockcheck.h"

  #include "dir.h"
  #include "dlmglue.h"
  #include "extent_map.h"
  #include "file.h"
  #include "inode.h"
  #include "journal.h"
  #include "namei.h"
  #include "suballoc.h"

  #include "super.h"

  #include "sysfile.h"

  #include "uptodate.h"

  #include "ocfs2_trace.h"

  
  #include "buffer_head_io.h"

  #define NAMEI_RA_CHUNKS  2
  #define NAMEI_RA_BLOCKS  4
  #define NAMEI_RA_SIZE        (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)

  static int ocfs2_do_extend_dir(struct super_block *sb,
  			       handle_t *handle,
  			       struct inode *dir,
  			       struct buffer_head *parent_fe_bh,
  			       struct ocfs2_alloc_context *data_ac,
  			       struct ocfs2_alloc_context *meta_ac,
  			       struct buffer_head **new_bh);

  static int ocfs2_dir_indexed(struct inode *inode);

  /*

   * These are distinct checks because future versions of the file system will
   * want to have a trailing dirent structure independent of indexing.
   */

  static int ocfs2_supports_dir_trailer(struct inode *dir)

  {

  	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);

  	if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
  		return 0;

  	return ocfs2_meta_ecc(osb) || ocfs2_dir_indexed(dir);

  }

  /*
   * "new' here refers to the point at which we're creating a new
   * directory via "mkdir()", but also when we're expanding an inline
   * directory. In either case, we don't yet have the indexing bit set
   * on the directory, so the standard checks will fail in when metaecc
   * is turned off. Only directory-initialization type functions should
   * use this then. Everything else wants ocfs2_supports_dir_trailer()
   */
  static int ocfs2_new_dir_wants_trailer(struct inode *dir)

  {

  	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
  
  	return ocfs2_meta_ecc(osb) ||
  		ocfs2_supports_indexed_dirs(osb);

  }
  
  static inline unsigned int ocfs2_dir_trailer_blk_off(struct super_block *sb)
  {
  	return sb->s_blocksize - sizeof(struct ocfs2_dir_block_trailer);
  }
  
  #define ocfs2_trailer_from_bh(_bh, _sb) ((struct ocfs2_dir_block_trailer *) ((_bh)->b_data + ocfs2_dir_trailer_blk_off((_sb))))

  /* XXX ocfs2_block_dqtrailer() is similar but not quite - can we make
   * them more consistent? */
  struct ocfs2_dir_block_trailer *ocfs2_dir_trailer_from_size(int blocksize,
  							    void *data)
  {
  	char *p = data;
  
  	p += blocksize - sizeof(struct ocfs2_dir_block_trailer);
  	return (struct ocfs2_dir_block_trailer *)p;
  }

  /*
   * XXX: This is executed once on every dirent. We should consider optimizing
   * it.
   */
  static int ocfs2_skip_dir_trailer(struct inode *dir,
  				  struct ocfs2_dir_entry *de,
  				  unsigned long offset,
  				  unsigned long blklen)
  {
  	unsigned long toff = blklen - sizeof(struct ocfs2_dir_block_trailer);

  	if (!ocfs2_supports_dir_trailer(dir))

  		return 0;
  
  	if (offset != toff)
  		return 0;
  
  	return 1;
  }
  
  static void ocfs2_init_dir_trailer(struct inode *inode,

  				   struct buffer_head *bh, u16 rec_len)

  {
  	struct ocfs2_dir_block_trailer *trailer;
  
  	trailer = ocfs2_trailer_from_bh(bh, inode->i_sb);
  	strcpy(trailer->db_signature, OCFS2_DIR_TRAILER_SIGNATURE);
  	trailer->db_compat_rec_len =
  			cpu_to_le16(sizeof(struct ocfs2_dir_block_trailer));
  	trailer->db_parent_dinode = cpu_to_le64(OCFS2_I(inode)->ip_blkno);
  	trailer->db_blkno = cpu_to_le64(bh->b_blocknr);

  	trailer->db_free_rec_len = cpu_to_le16(rec_len);
  }
  /*
   * Link an unindexed block with a dir trailer structure into the index free
   * list. This function will modify dirdata_bh, but assumes you've already
   * passed it to the journal.
   */
  static int ocfs2_dx_dir_link_trailer(struct inode *dir, handle_t *handle,
  				     struct buffer_head *dx_root_bh,
  				     struct buffer_head *dirdata_bh)
  {
  	int ret;
  	struct ocfs2_dx_root_block *dx_root;
  	struct ocfs2_dir_block_trailer *trailer;

  	ret = ocfs2_journal_access_dr(handle, INODE_CACHE(dir), dx_root_bh,

  				      OCFS2_JOURNAL_ACCESS_WRITE);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  	trailer = ocfs2_trailer_from_bh(dirdata_bh, dir->i_sb);
  	dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
  
  	trailer->db_free_next = dx_root->dr_free_blk;
  	dx_root->dr_free_blk = cpu_to_le64(dirdata_bh->b_blocknr);
  
  	ocfs2_journal_dirty(handle, dx_root_bh);
  
  out:
  	return ret;
  }
  
  static int ocfs2_free_list_at_root(struct ocfs2_dir_lookup_result *res)
  {
  	return res->dl_prev_leaf_bh == NULL;

  }

  void ocfs2_free_dir_lookup_result(struct ocfs2_dir_lookup_result *res)
  {

  	brelse(res->dl_dx_root_bh);

  	brelse(res->dl_leaf_bh);

  	brelse(res->dl_dx_leaf_bh);

  	brelse(res->dl_prev_leaf_bh);

  }
  
  static int ocfs2_dir_indexed(struct inode *inode)
  {
  	if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INDEXED_DIR_FL)
  		return 1;
  	return 0;
  }

  static inline int ocfs2_dx_root_inline(struct ocfs2_dx_root_block *dx_root)
  {
  	return dx_root->dr_flags & OCFS2_DX_FLAG_INLINE;
  }

  /*
   * Hashing code adapted from ext3
   */
  #define DELTA 0x9E3779B9
  
  static void TEA_transform(__u32 buf[4], __u32 const in[])
  {
  	__u32	sum = 0;
  	__u32	b0 = buf[0], b1 = buf[1];
  	__u32	a = in[0], b = in[1], c = in[2], d = in[3];
  	int	n = 16;
  
  	do {
  		sum += DELTA;
  		b0 += ((b1 << 4)+a) ^ (b1+sum) ^ ((b1 >> 5)+b);
  		b1 += ((b0 << 4)+c) ^ (b0+sum) ^ ((b0 >> 5)+d);
  	} while (--n);
  
  	buf[0] += b0;
  	buf[1] += b1;
  }
  
  static void str2hashbuf(const char *msg, int len, __u32 *buf, int num)
  {
  	__u32	pad, val;
  	int	i;
  
  	pad = (__u32)len | ((__u32)len << 8);
  	pad |= pad << 16;
  
  	val = pad;
  	if (len > num*4)
  		len = num * 4;
  	for (i = 0; i < len; i++) {
  		if ((i % 4) == 0)
  			val = pad;
  		val = msg[i] + (val << 8);
  		if ((i % 4) == 3) {
  			*buf++ = val;
  			val = pad;
  			num--;
  		}
  	}
  	if (--num >= 0)
  		*buf++ = val;
  	while (--num >= 0)
  		*buf++ = pad;
  }
  
  static void ocfs2_dx_dir_name_hash(struct inode *dir, const char *name, int len,
  				   struct ocfs2_dx_hinfo *hinfo)
  {
  	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
  	const char	*p;
  	__u32		in[8], buf[4];
  
  	/*
  	 * XXX: Is this really necessary, if the index is never looked
  	 * at by readdir? Is a hash value of '0' a bad idea?
  	 */
  	if ((len == 1 && !strncmp(".", name, 1)) ||
  	    (len == 2 && !strncmp("..", name, 2))) {
  		buf[0] = buf[1] = 0;
  		goto out;
  	}
  
  #ifdef OCFS2_DEBUG_DX_DIRS
  	/*
  	 * This makes it very easy to debug indexing problems. We
  	 * should never allow this to be selected without hand editing
  	 * this file though.
  	 */
  	buf[0] = buf[1] = len;
  	goto out;
  #endif
  
  	memcpy(buf, osb->osb_dx_seed, sizeof(buf));
  
  	p = name;
  	while (len > 0) {
  		str2hashbuf(p, len, in, 4);
  		TEA_transform(buf, in);
  		len -= 16;
  		p += 16;
  	}
  
  out:
  	hinfo->major_hash = buf[0];
  	hinfo->minor_hash = buf[1];

  }

  /*

   * bh passed here can be an inode block or a dir data block, depending
   * on the inode inline data flag.
   */

  static int ocfs2_check_dir_entry(struct inode * dir,
  				 struct ocfs2_dir_entry * de,
  				 struct buffer_head * bh,
  				 unsigned long offset)

  {
  	const char *error_msg = NULL;
  	const int rlen = le16_to_cpu(de->rec_len);

  	if (unlikely(rlen < OCFS2_DIR_REC_LEN(1)))

  		error_msg = "rec_len is smaller than minimal";

  	else if (unlikely(rlen % 4 != 0))

  		error_msg = "rec_len % 4 != 0";

  	else if (unlikely(rlen < OCFS2_DIR_REC_LEN(de->name_len)))

  		error_msg = "rec_len is too small for name_len";

  	else if (unlikely(
  		 ((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize))

  		error_msg = "directory entry across blocks";

  	if (unlikely(error_msg != NULL))

  		mlog(ML_ERROR, "bad entry in directory #%llu: %s - "
  		     "offset=%lu, inode=%llu, rec_len=%d, name_len=%d
  ",
  		     (unsigned long long)OCFS2_I(dir)->ip_blkno, error_msg,
  		     offset, (unsigned long long)le64_to_cpu(de->inode), rlen,
  		     de->name_len);

  	return error_msg == NULL ? 1 : 0;
  }
  
  static inline int ocfs2_match(int len,
  			      const char * const name,
  			      struct ocfs2_dir_entry *de)
  {
  	if (len != de->name_len)
  		return 0;
  	if (!de->inode)
  		return 0;
  	return !memcmp(name, de->name, len);
  }
  
  /*
   * Returns 0 if not found, -1 on failure, and 1 on success
   */

  static inline int ocfs2_search_dirblock(struct buffer_head *bh,

  					struct inode *dir,
  					const char *name, int namelen,
  					unsigned long offset,

  					char *first_de,
  					unsigned int bytes,

  					struct ocfs2_dir_entry **res_dir)
  {
  	struct ocfs2_dir_entry *de;
  	char *dlimit, *de_buf;
  	int de_len;
  	int ret = 0;

  	de_buf = first_de;
  	dlimit = de_buf + bytes;

  
  	while (de_buf < dlimit) {
  		/* this code is executed quadratically often */
  		/* do minimal checking `by hand' */
  
  		de = (struct ocfs2_dir_entry *) de_buf;
  
  		if (de_buf + namelen <= dlimit &&
  		    ocfs2_match(namelen, name, de)) {
  			/* found a match - just to be sure, do a full check */
  			if (!ocfs2_check_dir_entry(dir, de, bh, offset)) {
  				ret = -1;
  				goto bail;
  			}
  			*res_dir = de;
  			ret = 1;
  			goto bail;
  		}
  
  		/* prevent looping on a bad block */
  		de_len = le16_to_cpu(de->rec_len);
  		if (de_len <= 0) {
  			ret = -1;
  			goto bail;
  		}
  
  		de_buf += de_len;
  		offset += de_len;
  	}
  
  bail:

  	trace_ocfs2_search_dirblock(ret);

  	return ret;
  }

  static struct buffer_head *ocfs2_find_entry_id(const char *name,
  					       int namelen,
  					       struct inode *dir,
  					       struct ocfs2_dir_entry **res_dir)
  {
  	int ret, found;
  	struct buffer_head *di_bh = NULL;
  	struct ocfs2_dinode *di;
  	struct ocfs2_inline_data *data;

  	ret = ocfs2_read_inode_block(dir, &di_bh);

  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  
  	di = (struct ocfs2_dinode *)di_bh->b_data;
  	data = &di->id2.i_data;
  
  	found = ocfs2_search_dirblock(di_bh, dir, name, namelen, 0,
  				      data->id_data, i_size_read(dir), res_dir);
  	if (found == 1)
  		return di_bh;
  
  	brelse(di_bh);
  out:
  	return NULL;
  }

  static int ocfs2_validate_dir_block(struct super_block *sb,
  				    struct buffer_head *bh)
  {

  	int rc;
  	struct ocfs2_dir_block_trailer *trailer =
  		ocfs2_trailer_from_bh(bh, sb);

  	/*

  	 * We don't validate dirents here, that's handled

  	 * in-place when the code walks them.
  	 */

  	trace_ocfs2_validate_dir_block((unsigned long long)bh->b_blocknr);

  	BUG_ON(!buffer_uptodate(bh));
  
  	/*
  	 * If the ecc fails, we return the error but otherwise
  	 * leave the filesystem running.  We know any error is
  	 * local to this block.
  	 *
  	 * Note that we are safe to call this even if the directory
  	 * doesn't have a trailer.  Filesystems without metaecc will do
  	 * nothing, and filesystems with it will have one.
  	 */
  	rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &trailer->db_check);
  	if (rc)
  		mlog(ML_ERROR, "Checksum failed for dinode %llu
  ",
  		     (unsigned long long)bh->b_blocknr);
  
  	return rc;

  }
  
  /*

   * Validate a directory trailer.
   *
   * We check the trailer here rather than in ocfs2_validate_dir_block()
   * because that function doesn't have the inode to test.
   */
  static int ocfs2_check_dir_trailer(struct inode *dir, struct buffer_head *bh)
  {
  	int rc = 0;
  	struct ocfs2_dir_block_trailer *trailer;
  
  	trailer = ocfs2_trailer_from_bh(bh, dir->i_sb);
  	if (!OCFS2_IS_VALID_DIR_TRAILER(trailer)) {

  		rc = ocfs2_error(dir->i_sb,

  				 "Invalid dirblock #%llu: signature = %.*s
  ",
  				 (unsigned long long)bh->b_blocknr, 7,
  				 trailer->db_signature);

  		goto out;
  	}
  	if (le64_to_cpu(trailer->db_blkno) != bh->b_blocknr) {

  		rc = ocfs2_error(dir->i_sb,

  				 "Directory block #%llu has an invalid db_blkno of %llu
  ",
  				 (unsigned long long)bh->b_blocknr,
  				 (unsigned long long)le64_to_cpu(trailer->db_blkno));

  		goto out;
  	}
  	if (le64_to_cpu(trailer->db_parent_dinode) !=
  	    OCFS2_I(dir)->ip_blkno) {

  		rc = ocfs2_error(dir->i_sb,

  				 "Directory block #%llu on dinode #%llu has an invalid parent_dinode of %llu
  ",
  				 (unsigned long long)bh->b_blocknr,
  				 (unsigned long long)OCFS2_I(dir)->ip_blkno,
  				 (unsigned long long)le64_to_cpu(trailer->db_blkno));

  		goto out;
  	}
  out:
  	return rc;
  }
  
  /*

   * This function forces all errors to -EIO for consistency with its
   * predecessor, ocfs2_bread().  We haven't audited what returning the
   * real error codes would do to callers.  We log the real codes with
   * mlog_errno() before we squash them.
   */
  static int ocfs2_read_dir_block(struct inode *inode, u64 v_block,
  				struct buffer_head **bh, int flags)
  {
  	int rc = 0;
  	struct buffer_head *tmp = *bh;

  	rc = ocfs2_read_virt_blocks(inode, v_block, 1, &tmp, flags,
  				    ocfs2_validate_dir_block);

  	if (rc) {

  		mlog_errno(rc);

  		goto out;
  	}

  	if (!(flags & OCFS2_BH_READAHEAD) &&

  	    ocfs2_supports_dir_trailer(inode)) {

  		rc = ocfs2_check_dir_trailer(inode, tmp);
  		if (rc) {
  			if (!*bh)
  				brelse(tmp);
  			mlog_errno(rc);

  			goto out;
  		}
  	}

  	/* If ocfs2_read_virt_blocks() got us a new bh, pass it up. */

  	if (!*bh)

  		*bh = tmp;

  out:

  	return rc ? -EIO : 0;
  }

  /*
   * Read the block at 'phys' which belongs to this directory
   * inode. This function does no virtual->physical block translation -
   * what's passed in is assumed to be a valid directory block.
   */
  static int ocfs2_read_dir_block_direct(struct inode *dir, u64 phys,
  				       struct buffer_head **bh)
  {
  	int ret;
  	struct buffer_head *tmp = *bh;

  	ret = ocfs2_read_block(INODE_CACHE(dir), phys, &tmp,
  			       ocfs2_validate_dir_block);

  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  
  	if (ocfs2_supports_dir_trailer(dir)) {
  		ret = ocfs2_check_dir_trailer(dir, tmp);
  		if (ret) {
  			if (!*bh)
  				brelse(tmp);
  			mlog_errno(ret);
  			goto out;
  		}
  	}
  
  	if (!ret && !*bh)
  		*bh = tmp;
  out:
  	return ret;
  }
  
  static int ocfs2_validate_dx_root(struct super_block *sb,
  				  struct buffer_head *bh)
  {
  	int ret;
  	struct ocfs2_dx_root_block *dx_root;
  
  	BUG_ON(!buffer_uptodate(bh));
  
  	dx_root = (struct ocfs2_dx_root_block *) bh->b_data;
  
  	ret = ocfs2_validate_meta_ecc(sb, bh->b_data, &dx_root->dr_check);
  	if (ret) {
  		mlog(ML_ERROR,
  		     "Checksum failed for dir index root block %llu
  ",
  		     (unsigned long long)bh->b_blocknr);
  		return ret;
  	}
  
  	if (!OCFS2_IS_VALID_DX_ROOT(dx_root)) {

  		ret = ocfs2_error(sb,

  				  "Dir Index Root # %llu has bad signature %.*s
  ",
  				  (unsigned long long)le64_to_cpu(dx_root->dr_blkno),
  				  7, dx_root->dr_signature);

  	}

  	return ret;

  }
  
  static int ocfs2_read_dx_root(struct inode *dir, struct ocfs2_dinode *di,
  			      struct buffer_head **dx_root_bh)
  {
  	int ret;
  	u64 blkno = le64_to_cpu(di->i_dx_root);
  	struct buffer_head *tmp = *dx_root_bh;

  	ret = ocfs2_read_block(INODE_CACHE(dir), blkno, &tmp,
  			       ocfs2_validate_dx_root);

  
  	/* If ocfs2_read_block() got us a new bh, pass it up. */
  	if (!ret && !*dx_root_bh)
  		*dx_root_bh = tmp;
  
  	return ret;
  }
  
  static int ocfs2_validate_dx_leaf(struct super_block *sb,
  				  struct buffer_head *bh)
  {
  	int ret;
  	struct ocfs2_dx_leaf *dx_leaf = (struct ocfs2_dx_leaf *)bh->b_data;
  
  	BUG_ON(!buffer_uptodate(bh));
  
  	ret = ocfs2_validate_meta_ecc(sb, bh->b_data, &dx_leaf->dl_check);
  	if (ret) {
  		mlog(ML_ERROR,
  		     "Checksum failed for dir index leaf block %llu
  ",
  		     (unsigned long long)bh->b_blocknr);
  		return ret;
  	}
  
  	if (!OCFS2_IS_VALID_DX_LEAF(dx_leaf)) {

  		ret = ocfs2_error(sb, "Dir Index Leaf has bad signature %.*s
  ",
  				  7, dx_leaf->dl_signature);

  	}

  	return ret;

  }
  
  static int ocfs2_read_dx_leaf(struct inode *dir, u64 blkno,
  			      struct buffer_head **dx_leaf_bh)
  {
  	int ret;
  	struct buffer_head *tmp = *dx_leaf_bh;

  	ret = ocfs2_read_block(INODE_CACHE(dir), blkno, &tmp,
  			       ocfs2_validate_dx_leaf);

  
  	/* If ocfs2_read_block() got us a new bh, pass it up. */
  	if (!ret && !*dx_leaf_bh)
  		*dx_leaf_bh = tmp;
  
  	return ret;
  }
  
  /*
   * Read a series of dx_leaf blocks. This expects all buffer_head
   * pointers to be NULL on function entry.
   */
  static int ocfs2_read_dx_leaves(struct inode *dir, u64 start, int num,
  				struct buffer_head **dx_leaf_bhs)
  {
  	int ret;

  	ret = ocfs2_read_blocks(INODE_CACHE(dir), start, num, dx_leaf_bhs, 0,

  				ocfs2_validate_dx_leaf);
  	if (ret)
  		mlog_errno(ret);
  
  	return ret;
  }

  static struct buffer_head *ocfs2_find_entry_el(const char *name, int namelen,
  					       struct inode *dir,
  					       struct ocfs2_dir_entry **res_dir)

  {
  	struct super_block *sb;
  	struct buffer_head *bh_use[NAMEI_RA_SIZE];
  	struct buffer_head *bh, *ret = NULL;
  	unsigned long start, block, b;
  	int ra_max = 0;		/* Number of bh's in the readahead
  				   buffer, bh_use[] */
  	int ra_ptr = 0;		/* Current index into readahead
  				   buffer */
  	int num = 0;

  	int nblocks, i;

  	sb = dir->i_sb;
  
  	nblocks = i_size_read(dir) >> sb->s_blocksize_bits;
  	start = OCFS2_I(dir)->ip_dir_start_lookup;
  	if (start >= nblocks)
  		start = 0;
  	block = start;
  
  restart:
  	do {
  		/*
  		 * We deal with the read-ahead logic here.
  		 */
  		if (ra_ptr >= ra_max) {
  			/* Refill the readahead buffer */
  			ra_ptr = 0;
  			b = block;
  			for (ra_max = 0; ra_max < NAMEI_RA_SIZE; ra_max++) {
  				/*
  				 * Terminate if we reach the end of the
  				 * directory and must wrap, or if our
  				 * search has finished at this block.
  				 */
  				if (b >= nblocks || (num && block == start)) {
  					bh_use[ra_max] = NULL;
  					break;
  				}
  				num++;

  				bh = NULL;

  				ocfs2_read_dir_block(dir, b++, &bh,

  							   OCFS2_BH_READAHEAD);

  				bh_use[ra_max] = bh;
  			}
  		}
  		if ((bh = bh_use[ra_ptr++]) == NULL)
  			goto next;

  		if (ocfs2_read_dir_block(dir, block, &bh, 0)) {

  			/* read error, skip block & hope for the best.

  			 * ocfs2_read_dir_block() has released the bh. */

  			mlog(ML_ERROR, "reading directory %llu, "

  				    "offset %lu
  ",
  				    (unsigned long long)OCFS2_I(dir)->ip_blkno,
  				    block);

  			goto next;
  		}
  		i = ocfs2_search_dirblock(bh, dir, name, namelen,
  					  block << sb->s_blocksize_bits,

  					  bh->b_data, sb->s_blocksize,

  					  res_dir);
  		if (i == 1) {
  			OCFS2_I(dir)->ip_dir_start_lookup = block;
  			ret = bh;
  			goto cleanup_and_exit;
  		} else {
  			brelse(bh);
  			if (i < 0)
  				goto cleanup_and_exit;
  		}
  	next:
  		if (++block >= nblocks)
  			block = 0;
  	} while (block != start);
  
  	/*
  	 * If the directory has grown while we were searching, then
  	 * search the last part of the directory before giving up.
  	 */
  	block = nblocks;
  	nblocks = i_size_read(dir) >> sb->s_blocksize_bits;
  	if (block < nblocks) {
  		start = 0;
  		goto restart;
  	}
  
  cleanup_and_exit:
  	/* Clean up the read-ahead blocks */
  	for (; ra_ptr < ra_max; ra_ptr++)
  		brelse(bh_use[ra_ptr]);

  	trace_ocfs2_find_entry_el(ret);

  	return ret;
  }

  static int ocfs2_dx_dir_lookup_rec(struct inode *inode,
  				   struct ocfs2_extent_list *el,
  				   u32 major_hash,
  				   u32 *ret_cpos,
  				   u64 *ret_phys_blkno,
  				   unsigned int *ret_clen)

  {

  	int ret = 0, i, found;
  	struct buffer_head *eb_bh = NULL;
  	struct ocfs2_extent_block *eb;
  	struct ocfs2_extent_rec *rec = NULL;

  	if (el->l_tree_depth) {

  		ret = ocfs2_find_leaf(INODE_CACHE(inode), el, major_hash,
  				      &eb_bh);

  		if (ret) {
  			mlog_errno(ret);
  			goto out;
  		}

  		eb = (struct ocfs2_extent_block *) eb_bh->b_data;
  		el = &eb->h_list;

  		if (el->l_tree_depth) {

  			ret = ocfs2_error(inode->i_sb,

  					  "Inode %lu has non zero tree depth in btree tree block %llu
  ",
  					  inode->i_ino,
  					  (unsigned long long)eb_bh->b_blocknr);

  			goto out;
  		}
  	}
  
  	found = 0;
  	for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) {
  		rec = &el->l_recs[i];
  
  		if (le32_to_cpu(rec->e_cpos) <= major_hash) {
  			found = 1;
  			break;
  		}
  	}
  
  	if (!found) {

  		ret = ocfs2_error(inode->i_sb,
  				  "Inode %lu has bad extent record (%u, %u, 0) in btree
  ",
  				  inode->i_ino,
  				  le32_to_cpu(rec->e_cpos),
  				  ocfs2_rec_clusters(el, rec));

  		goto out;
  	}
  
  	if (ret_phys_blkno)
  		*ret_phys_blkno = le64_to_cpu(rec->e_blkno);
  	if (ret_cpos)
  		*ret_cpos = le32_to_cpu(rec->e_cpos);
  	if (ret_clen)
  		*ret_clen = le16_to_cpu(rec->e_leaf_clusters);
  
  out:
  	brelse(eb_bh);
  	return ret;

  }

  /*

   * Returns the block index, from the start of the cluster which this
   * hash belongs too.

   */

  static inline unsigned int __ocfs2_dx_dir_hash_idx(struct ocfs2_super *osb,
  						   u32 minor_hash)

  {

  	return minor_hash & osb->osb_dx_mask;
  }

  static inline unsigned int ocfs2_dx_dir_hash_idx(struct ocfs2_super *osb,
  					  struct ocfs2_dx_hinfo *hinfo)
  {
  	return __ocfs2_dx_dir_hash_idx(osb, hinfo->minor_hash);
  }

  static int ocfs2_dx_dir_lookup(struct inode *inode,
  			       struct ocfs2_extent_list *el,
  			       struct ocfs2_dx_hinfo *hinfo,
  			       u32 *ret_cpos,
  			       u64 *ret_phys_blkno)
  {
  	int ret = 0;

  	unsigned int cend, clen;
  	u32 cpos;
  	u64 blkno;

  	u32 name_hash = hinfo->major_hash;

  	ret = ocfs2_dx_dir_lookup_rec(inode, el, name_hash, &cpos, &blkno,
  				      &clen);

  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}

  	cend = cpos + clen;
  	if (name_hash >= cend) {
  		/* We want the last cluster */
  		blkno += ocfs2_clusters_to_blocks(inode->i_sb, clen - 1);
  		cpos += clen - 1;
  	} else {
  		blkno += ocfs2_clusters_to_blocks(inode->i_sb,
  						  name_hash - cpos);
  		cpos = name_hash;
  	}

  	/*
  	 * We now have the cluster which should hold our entry. To
  	 * find the exact block from the start of the cluster to
  	 * search, we take the lower bits of the hash.
  	 */
  	blkno += ocfs2_dx_dir_hash_idx(OCFS2_SB(inode->i_sb), hinfo);
  
  	if (ret_phys_blkno)
  		*ret_phys_blkno = blkno;
  	if (ret_cpos)
  		*ret_cpos = cpos;

  
  out:

  	return ret;
  }

  static int ocfs2_dx_dir_search(const char *name, int namelen,
  			       struct inode *dir,

  			       struct ocfs2_dx_root_block *dx_root,

  			       struct ocfs2_dir_lookup_result *res)

  {

  	int ret, i, found;

  	u64 phys;

  	struct buffer_head *dx_leaf_bh = NULL;
  	struct ocfs2_dx_leaf *dx_leaf;
  	struct ocfs2_dx_entry *dx_entry = NULL;
  	struct buffer_head *dir_ent_bh = NULL;
  	struct ocfs2_dir_entry *dir_ent = NULL;
  	struct ocfs2_dx_hinfo *hinfo = &res->dl_hinfo;

  	struct ocfs2_extent_list *dr_el;
  	struct ocfs2_dx_entry_list *entry_list;

  
  	ocfs2_dx_dir_name_hash(dir, name, namelen, &res->dl_hinfo);

  	if (ocfs2_dx_root_inline(dx_root)) {
  		entry_list = &dx_root->dr_entries;
  		goto search;
  	}
  
  	dr_el = &dx_root->dr_list;

  	ret = ocfs2_dx_dir_lookup(dir, dr_el, hinfo, NULL, &phys);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}

  	trace_ocfs2_dx_dir_search((unsigned long long)OCFS2_I(dir)->ip_blkno,
  				  namelen, name, hinfo->major_hash,
  				  hinfo->minor_hash, (unsigned long long)phys);

  	ret = ocfs2_read_dx_leaf(dir, phys, &dx_leaf_bh);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}

  	dx_leaf = (struct ocfs2_dx_leaf *) dx_leaf_bh->b_data;

  	trace_ocfs2_dx_dir_search_leaf_info(
  			le16_to_cpu(dx_leaf->dl_list.de_num_used),
  			le16_to_cpu(dx_leaf->dl_list.de_count));

  	entry_list = &dx_leaf->dl_list;
  
  search:

  	/*
  	 * Empty leaf is legal, so no need to check for that.
  	 */
  	found = 0;

  	for (i = 0; i < le16_to_cpu(entry_list->de_num_used); i++) {
  		dx_entry = &entry_list->de_entries[i];

  
  		if (hinfo->major_hash != le32_to_cpu(dx_entry->dx_major_hash)
  		    || hinfo->minor_hash != le32_to_cpu(dx_entry->dx_minor_hash))
  			continue;
  
  		/*
  		 * Search unindexed leaf block now. We're not
  		 * guaranteed to find anything.
  		 */
  		ret = ocfs2_read_dir_block_direct(dir,
  					  le64_to_cpu(dx_entry->dx_dirent_blk),
  					  &dir_ent_bh);
  		if (ret) {
  			mlog_errno(ret);
  			goto out;

  		}

  
  		/*
  		 * XXX: We should check the unindexed block here,
  		 * before using it.
  		 */
  
  		found = ocfs2_search_dirblock(dir_ent_bh, dir, name, namelen,
  					      0, dir_ent_bh->b_data,
  					      dir->i_sb->s_blocksize, &dir_ent);
  		if (found == 1)
  			break;
  
  		if (found == -1) {
  			/* This means we found a bad directory entry. */
  			ret = -EIO;
  			mlog_errno(ret);
  			goto out;
  		}
  
  		brelse(dir_ent_bh);
  		dir_ent_bh = NULL;
  	}
  
  	if (found <= 0) {
  		ret = -ENOENT;
  		goto out;
  	}
  
  	res->dl_leaf_bh = dir_ent_bh;
  	res->dl_entry = dir_ent;
  	res->dl_dx_leaf_bh = dx_leaf_bh;
  	res->dl_dx_entry = dx_entry;
  
  	ret = 0;
  out:
  	if (ret) {
  		brelse(dx_leaf_bh);
  		brelse(dir_ent_bh);
  	}
  	return ret;
  }
  
  static int ocfs2_find_entry_dx(const char *name, int namelen,
  			       struct inode *dir,
  			       struct ocfs2_dir_lookup_result *lookup)
  {
  	int ret;
  	struct buffer_head *di_bh = NULL;
  	struct ocfs2_dinode *di;
  	struct buffer_head *dx_root_bh = NULL;
  	struct ocfs2_dx_root_block *dx_root;
  
  	ret = ocfs2_read_inode_block(dir, &di_bh);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  
  	di = (struct ocfs2_dinode *)di_bh->b_data;
  
  	ret = ocfs2_read_dx_root(dir, di, &dx_root_bh);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  	dx_root = (struct ocfs2_dx_root_block *) dx_root_bh->b_data;

  	ret = ocfs2_dx_dir_search(name, namelen, dir, dx_root, lookup);

  	if (ret) {
  		if (ret != -ENOENT)
  			mlog_errno(ret);
  		goto out;
  	}

  	lookup->dl_dx_root_bh = dx_root_bh;
  	dx_root_bh = NULL;

  out:
  	brelse(di_bh);
  	brelse(dx_root_bh);
  	return ret;
  }
  
  /*
   * Try to find an entry of the provided name within 'dir'.
   *
   * If nothing was found, -ENOENT is returned. Otherwise, zero is
   * returned and the struct 'res' will contain information useful to
   * other directory manipulation functions.
   *
   * Caller can NOT assume anything about the contents of the
   * buffer_heads - they are passed back only so that it can be passed
   * into any one of the manipulation functions (add entry, delete
   * entry, etc). As an example, bh in the extent directory case is a
   * data block, in the inline-data case it actually points to an inode,
   * in the indexed directory case, multiple buffers are involved.
   */
  int ocfs2_find_entry(const char *name, int namelen,
  		     struct inode *dir, struct ocfs2_dir_lookup_result *lookup)
  {
  	struct buffer_head *bh;
  	struct ocfs2_dir_entry *res_dir = NULL;
  
  	if (ocfs2_dir_indexed(dir))
  		return ocfs2_find_entry_dx(name, namelen, dir, lookup);
  
  	/*
  	 * The unindexed dir code only uses part of the lookup
  	 * structure, so there's no reason to push it down further
  	 * than this.
  	 */
  	if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
  		bh = ocfs2_find_entry_id(name, namelen, dir, &res_dir);
  	else
  		bh = ocfs2_find_entry_el(name, namelen, dir, &res_dir);
  
  	if (bh == NULL)
  		return -ENOENT;
  
  	lookup->dl_leaf_bh = bh;
  	lookup->dl_entry = res_dir;
  	return 0;
  }
  
  /*
   * Update inode number and type of a previously found directory entry.
   */
  int ocfs2_update_entry(struct inode *dir, handle_t *handle,
  		       struct ocfs2_dir_lookup_result *res,
  		       struct inode *new_entry_inode)
  {
  	int ret;
  	ocfs2_journal_access_func access = ocfs2_journal_access_db;
  	struct ocfs2_dir_entry *de = res->dl_entry;
  	struct buffer_head *de_bh = res->dl_leaf_bh;
  
  	/*
  	 * The same code works fine for both inline-data and extent
  	 * based directories, so no need to split this up.  The only
  	 * difference is the journal_access function.
  	 */
  
  	if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
  		access = ocfs2_journal_access_di;

  	ret = access(handle, INODE_CACHE(dir), de_bh,
  		     OCFS2_JOURNAL_ACCESS_WRITE);

  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  
  	de->inode = cpu_to_le64(OCFS2_I(new_entry_inode)->ip_blkno);
  	ocfs2_set_de_type(de, new_entry_inode->i_mode);
  
  	ocfs2_journal_dirty(handle, de_bh);
  
  out:
  	return ret;
  }
  
  /*
   * __ocfs2_delete_entry deletes a directory entry by merging it with the
   * previous entry
   */
  static int __ocfs2_delete_entry(handle_t *handle, struct inode *dir,
  				struct ocfs2_dir_entry *de_del,
  				struct buffer_head *bh, char *first_de,
  				unsigned int bytes)
  {
  	struct ocfs2_dir_entry *de, *pde;
  	int i, status = -ENOENT;
  	ocfs2_journal_access_func access = ocfs2_journal_access_db;

  	if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
  		access = ocfs2_journal_access_di;
  
  	i = 0;
  	pde = NULL;
  	de = (struct ocfs2_dir_entry *) first_de;
  	while (i < bytes) {
  		if (!ocfs2_check_dir_entry(dir, de, bh, i)) {
  			status = -EIO;
  			mlog_errno(status);
  			goto bail;
  		}
  		if (de == de_del)  {

  			status = access(handle, INODE_CACHE(dir), bh,

  					OCFS2_JOURNAL_ACCESS_WRITE);

  			if (status < 0) {
  				status = -EIO;
  				mlog_errno(status);
  				goto bail;
  			}
  			if (pde)

  				le16_add_cpu(&pde->rec_len,
  						le16_to_cpu(de->rec_len));

  			de->inode = 0;

  			inode_inc_iversion(dir);

  			ocfs2_journal_dirty(handle, bh);

  			goto bail;
  		}
  		i += le16_to_cpu(de->rec_len);
  		pde = de;
  		de = (struct ocfs2_dir_entry *)((char *)de + le16_to_cpu(de->rec_len));
  	}
  bail:

  	return status;
  }

  static unsigned int ocfs2_figure_dirent_hole(struct ocfs2_dir_entry *de)
  {
  	unsigned int hole;
  
  	if (le64_to_cpu(de->inode) == 0)
  		hole = le16_to_cpu(de->rec_len);
  	else
  		hole = le16_to_cpu(de->rec_len) -
  			OCFS2_DIR_REC_LEN(de->name_len);
  
  	return hole;
  }
  
  static int ocfs2_find_max_rec_len(struct super_block *sb,
  				  struct buffer_head *dirblock_bh)
  {
  	int size, this_hole, largest_hole = 0;
  	char *trailer, *de_buf, *limit, *start = dirblock_bh->b_data;
  	struct ocfs2_dir_entry *de;
  
  	trailer = (char *)ocfs2_trailer_from_bh(dirblock_bh, sb);
  	size = ocfs2_dir_trailer_blk_off(sb);
  	limit = start + size;
  	de_buf = start;
  	de = (struct ocfs2_dir_entry *)de_buf;
  	do {
  		if (de_buf != trailer) {
  			this_hole = ocfs2_figure_dirent_hole(de);
  			if (this_hole > largest_hole)
  				largest_hole = this_hole;
  		}
  
  		de_buf += le16_to_cpu(de->rec_len);
  		de = (struct ocfs2_dir_entry *)de_buf;
  	} while (de_buf < limit);
  
  	if (largest_hole >= OCFS2_DIR_MIN_REC_LEN)
  		return largest_hole;
  	return 0;
  }

  static void ocfs2_dx_list_remove_entry(struct ocfs2_dx_entry_list *entry_list,
  				       int index)

  {

  	int num_used = le16_to_cpu(entry_list->de_num_used);

  
  	if (num_used == 1 || index == (num_used - 1))
  		goto clear;

  	memmove(&entry_list->de_entries[index],
  		&entry_list->de_entries[index + 1],

  		(num_used - index - 1)*sizeof(struct ocfs2_dx_entry));
  clear:
  	num_used--;

  	memset(&entry_list->de_entries[num_used], 0,

  	       sizeof(struct ocfs2_dx_entry));

  	entry_list->de_num_used = cpu_to_le16(num_used);

  }
  
  static int ocfs2_delete_entry_dx(handle_t *handle, struct inode *dir,
  				 struct ocfs2_dir_lookup_result *lookup)
  {

  	int ret, index, max_rec_len, add_to_free_list = 0;

  	struct buffer_head *dx_root_bh = lookup->dl_dx_root_bh;

  	struct buffer_head *leaf_bh = lookup->dl_leaf_bh;
  	struct ocfs2_dx_leaf *dx_leaf;
  	struct ocfs2_dx_entry *dx_entry = lookup->dl_dx_entry;

  	struct ocfs2_dir_block_trailer *trailer;

  	struct ocfs2_dx_root_block *dx_root;
  	struct ocfs2_dx_entry_list *entry_list;

  	/*
  	 * This function gets a bit messy because we might have to
  	 * modify the root block, regardless of whether the indexed
  	 * entries are stored inline.
  	 */
  
  	/*
  	 * *Only* set 'entry_list' here, based on where we're looking
  	 * for the indexed entries. Later, we might still want to
  	 * journal both blocks, based on free list state.
  	 */

  	dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
  	if (ocfs2_dx_root_inline(dx_root)) {
  		entry_list = &dx_root->dr_entries;
  	} else {
  		dx_leaf = (struct ocfs2_dx_leaf *) lookup->dl_dx_leaf_bh->b_data;
  		entry_list = &dx_leaf->dl_list;
  	}

  	/* Neither of these are a disk corruption - that should have
  	 * been caught by lookup, before we got here. */

  	BUG_ON(le16_to_cpu(entry_list->de_count) <= 0);
  	BUG_ON(le16_to_cpu(entry_list->de_num_used) <= 0);

  	index = (char *)dx_entry - (char *)entry_list->de_entries;

  	index /= sizeof(*dx_entry);

  	if (index >= le16_to_cpu(entry_list->de_num_used)) {

  		mlog(ML_ERROR, "Dir %llu: Bad dx_entry ptr idx %d, (%p, %p)
  ",

  		     (unsigned long long)OCFS2_I(dir)->ip_blkno, index,
  		     entry_list, dx_entry);

  		return -EIO;
  	}

  	/*

  	 * We know that removal of this dirent will leave enough room
  	 * for a new one, so add this block to the free list if it
  	 * isn't already there.
  	 */
  	trailer = ocfs2_trailer_from_bh(leaf_bh, dir->i_sb);
  	if (trailer->db_free_rec_len == 0)
  		add_to_free_list = 1;
  
  	/*

  	 * Add the block holding our index into the journal before
  	 * removing the unindexed entry. If we get an error return
  	 * from __ocfs2_delete_entry(), then it hasn't removed the
  	 * entry yet. Likewise, successful return means we *must*
  	 * remove the indexed entry.
  	 *

  	 * We're also careful to journal the root tree block here as
  	 * the entry count needs to be updated. Also, we might be
  	 * adding to the start of the free list.

  	 */

  	ret = ocfs2_journal_access_dr(handle, INODE_CACHE(dir), dx_root_bh,

  				      OCFS2_JOURNAL_ACCESS_WRITE);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;

  	}
  
  	if (!ocfs2_dx_root_inline(dx_root)) {

  		ret = ocfs2_journal_access_dl(handle, INODE_CACHE(dir),

  					      lookup->dl_dx_leaf_bh,
  					      OCFS2_JOURNAL_ACCESS_WRITE);
  		if (ret) {
  			mlog_errno(ret);
  			goto out;
  		}

  	}

  	trace_ocfs2_delete_entry_dx((unsigned long long)OCFS2_I(dir)->ip_blkno,
  				    index);

  	ret = __ocfs2_delete_entry(handle, dir, lookup->dl_entry,
  				   leaf_bh, leaf_bh->b_data, leaf_bh->b_size);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}

  	max_rec_len = ocfs2_find_max_rec_len(dir->i_sb, leaf_bh);
  	trailer->db_free_rec_len = cpu_to_le16(max_rec_len);
  	if (add_to_free_list) {
  		trailer->db_free_next = dx_root->dr_free_blk;
  		dx_root->dr_free_blk = cpu_to_le64(leaf_bh->b_blocknr);
  		ocfs2_journal_dirty(handle, dx_root_bh);
  	}
  
  	/* leaf_bh was journal_accessed for us in __ocfs2_delete_entry */
  	ocfs2_journal_dirty(handle, leaf_bh);

  	le32_add_cpu(&dx_root->dr_num_entries, -1);
  	ocfs2_journal_dirty(handle, dx_root_bh);

  	ocfs2_dx_list_remove_entry(entry_list, index);

  	if (!ocfs2_dx_root_inline(dx_root))

  		ocfs2_journal_dirty(handle, lookup->dl_dx_leaf_bh);

  
  out:
  	return ret;
  }

  static inline int ocfs2_delete_entry_id(handle_t *handle,
  					struct inode *dir,
  					struct ocfs2_dir_entry *de_del,
  					struct buffer_head *bh)
  {
  	int ret;
  	struct buffer_head *di_bh = NULL;
  	struct ocfs2_dinode *di;
  	struct ocfs2_inline_data *data;

  	ret = ocfs2_read_inode_block(dir, &di_bh);

  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  
  	di = (struct ocfs2_dinode *)di_bh->b_data;
  	data = &di->id2.i_data;
  
  	ret = __ocfs2_delete_entry(handle, dir, de_del, bh, data->id_data,
  				   i_size_read(dir));
  
  	brelse(di_bh);
  out:
  	return ret;
  }
  
  static inline int ocfs2_delete_entry_el(handle_t *handle,
  					struct inode *dir,
  					struct ocfs2_dir_entry *de_del,
  					struct buffer_head *bh)
  {
  	return __ocfs2_delete_entry(handle, dir, de_del, bh, bh->b_data,
  				    bh->b_size);
  }
  
  /*

   * Delete a directory entry. Hide the details of directory
   * implementation from the caller.

   */
  int ocfs2_delete_entry(handle_t *handle,
  		       struct inode *dir,

  		       struct ocfs2_dir_lookup_result *res)

  {

  	if (ocfs2_dir_indexed(dir))
  		return ocfs2_delete_entry_dx(handle, dir, res);

  	if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL)

  		return ocfs2_delete_entry_id(handle, dir, res->dl_entry,
  					     res->dl_leaf_bh);

  	return ocfs2_delete_entry_el(handle, dir, res->dl_entry,
  				     res->dl_leaf_bh);

  }

  /*
   * Check whether 'de' has enough room to hold an entry of
   * 'new_rec_len' bytes.
   */
  static inline int ocfs2_dirent_would_fit(struct ocfs2_dir_entry *de,
  					 unsigned int new_rec_len)
  {
  	unsigned int de_really_used;
  
  	/* Check whether this is an empty record with enough space */
  	if (le64_to_cpu(de->inode) == 0 &&
  	    le16_to_cpu(de->rec_len) >= new_rec_len)
  		return 1;
  
  	/*
  	 * Record might have free space at the end which we can
  	 * use.
  	 */
  	de_really_used = OCFS2_DIR_REC_LEN(de->name_len);
  	if (le16_to_cpu(de->rec_len) >= (de_really_used + new_rec_len))
  	    return 1;
  
  	return 0;
  }

  static void ocfs2_dx_dir_leaf_insert_tail(struct ocfs2_dx_leaf *dx_leaf,
  					  struct ocfs2_dx_entry *dx_new_entry)
  {
  	int i;
  
  	i = le16_to_cpu(dx_leaf->dl_list.de_num_used);
  	dx_leaf->dl_list.de_entries[i] = *dx_new_entry;
  
  	le16_add_cpu(&dx_leaf->dl_list.de_num_used, 1);
  }

  static void ocfs2_dx_entry_list_insert(struct ocfs2_dx_entry_list *entry_list,
  				       struct ocfs2_dx_hinfo *hinfo,
  				       u64 dirent_blk)
  {
  	int i;
  	struct ocfs2_dx_entry *dx_entry;
  
  	i = le16_to_cpu(entry_list->de_num_used);
  	dx_entry = &entry_list->de_entries[i];
  
  	memset(dx_entry, 0, sizeof(*dx_entry));
  	dx_entry->dx_major_hash = cpu_to_le32(hinfo->major_hash);
  	dx_entry->dx_minor_hash = cpu_to_le32(hinfo->minor_hash);
  	dx_entry->dx_dirent_blk = cpu_to_le64(dirent_blk);
  
  	le16_add_cpu(&entry_list->de_num_used, 1);
  }

  static int __ocfs2_dx_dir_leaf_insert(struct inode *dir, handle_t *handle,
  				      struct ocfs2_dx_hinfo *hinfo,
  				      u64 dirent_blk,
  				      struct buffer_head *dx_leaf_bh)
  {

  	int ret;

  	struct ocfs2_dx_leaf *dx_leaf;

  	ret = ocfs2_journal_access_dl(handle, INODE_CACHE(dir), dx_leaf_bh,

  				      OCFS2_JOURNAL_ACCESS_WRITE);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  
  	dx_leaf = (struct ocfs2_dx_leaf *)dx_leaf_bh->b_data;

  	ocfs2_dx_entry_list_insert(&dx_leaf->dl_list, hinfo, dirent_blk);
  	ocfs2_journal_dirty(handle, dx_leaf_bh);

  out:
  	return ret;
  }

  static void ocfs2_dx_inline_root_insert(struct inode *dir, handle_t *handle,
  					struct ocfs2_dx_hinfo *hinfo,
  					u64 dirent_blk,
  					struct ocfs2_dx_root_block *dx_root)

  {

  	ocfs2_dx_entry_list_insert(&dx_root->dr_entries, hinfo, dirent_blk);
  }
  
  static int ocfs2_dx_dir_insert(struct inode *dir, handle_t *handle,
  			       struct ocfs2_dir_lookup_result *lookup)
  {
  	int ret = 0;

  	struct ocfs2_dx_root_block *dx_root;

  	struct buffer_head *dx_root_bh = lookup->dl_dx_root_bh;

  	ret = ocfs2_journal_access_dr(handle, INODE_CACHE(dir), dx_root_bh,

  				      OCFS2_JOURNAL_ACCESS_WRITE);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}

  	dx_root = (struct ocfs2_dx_root_block *)lookup->dl_dx_root_bh->b_data;
  	if (ocfs2_dx_root_inline(dx_root)) {
  		ocfs2_dx_inline_root_insert(dir, handle,
  					    &lookup->dl_hinfo,
  					    lookup->dl_leaf_bh->b_blocknr,
  					    dx_root);
  	} else {
  		ret = __ocfs2_dx_dir_leaf_insert(dir, handle, &lookup->dl_hinfo,
  						 lookup->dl_leaf_bh->b_blocknr,
  						 lookup->dl_dx_leaf_bh);
  		if (ret)
  			goto out;
  	}
  
  	le32_add_cpu(&dx_root->dr_num_entries, 1);

  	ocfs2_journal_dirty(handle, dx_root_bh);

  
  out:
  	return ret;
  }

  static void ocfs2_remove_block_from_free_list(struct inode *dir,
  				       handle_t *handle,
  				       struct ocfs2_dir_lookup_result *lookup)
  {
  	struct ocfs2_dir_block_trailer *trailer, *prev;
  	struct ocfs2_dx_root_block *dx_root;
  	struct buffer_head *bh;
  
  	trailer = ocfs2_trailer_from_bh(lookup->dl_leaf_bh, dir->i_sb);
  
  	if (ocfs2_free_list_at_root(lookup)) {
  		bh = lookup->dl_dx_root_bh;
  		dx_root = (struct ocfs2_dx_root_block *)bh->b_data;
  		dx_root->dr_free_blk = trailer->db_free_next;
  	} else {
  		bh = lookup->dl_prev_leaf_bh;
  		prev = ocfs2_trailer_from_bh(bh, dir->i_sb);
  		prev->db_free_next = trailer->db_free_next;
  	}
  
  	trailer->db_free_rec_len = cpu_to_le16(0);
  	trailer->db_free_next = cpu_to_le64(0);
  
  	ocfs2_journal_dirty(handle, bh);
  	ocfs2_journal_dirty(handle, lookup->dl_leaf_bh);
  }
  
  /*
   * This expects that a journal write has been reserved on
   * lookup->dl_prev_leaf_bh or lookup->dl_dx_root_bh
   */
  static void ocfs2_recalc_free_list(struct inode *dir, handle_t *handle,
  				   struct ocfs2_dir_lookup_result *lookup)
  {
  	int max_rec_len;
  	struct ocfs2_dir_block_trailer *trailer;
  
  	/* Walk dl_leaf_bh to figure out what the new free rec_len is. */
  	max_rec_len = ocfs2_find_max_rec_len(dir->i_sb, lookup->dl_leaf_bh);
  	if (max_rec_len) {
  		/*
  		 * There's still room in this block, so no need to remove it
  		 * from the free list. In this case, we just want to update
  		 * the rec len accounting.
  		 */
  		trailer = ocfs2_trailer_from_bh(lookup->dl_leaf_bh, dir->i_sb);
  		trailer->db_free_rec_len = cpu_to_le16(max_rec_len);
  		ocfs2_journal_dirty(handle, lookup->dl_leaf_bh);
  	} else {
  		ocfs2_remove_block_from_free_list(dir, handle, lookup);
  	}
  }

  /* we don't always have a dentry for what we want to add, so people
   * like orphan dir can call this instead.
   *

   * The lookup context must have been filled from
   * ocfs2_prepare_dir_for_insert.

   */
  int __ocfs2_add_entry(handle_t *handle,
  		      struct inode *dir,
  		      const char *name, int namelen,
  		      struct inode *inode, u64 blkno,
  		      struct buffer_head *parent_fe_bh,

  		      struct ocfs2_dir_lookup_result *lookup)

  {
  	unsigned long offset;
  	unsigned short rec_len;
  	struct ocfs2_dir_entry *de, *de1;

  	struct ocfs2_dinode *di = (struct ocfs2_dinode *)parent_fe_bh->b_data;
  	struct super_block *sb = dir->i_sb;

  	int retval;

  	unsigned int size = sb->s_blocksize;

  	struct buffer_head *insert_bh = lookup->dl_leaf_bh;

  	char *data_start = insert_bh->b_data;

  	if (!namelen)
  		return -EINVAL;

  	if (ocfs2_dir_indexed(dir)) {
  		struct buffer_head *bh;
  
  		/*
  		 * An indexed dir may require that we update the free space
  		 * list. Reserve a write to the previous node in the list so
  		 * that we don't fail later.
  		 *
  		 * XXX: This can be either a dx_root_block, or an unindexed
  		 * directory tree leaf block.
  		 */
  		if (ocfs2_free_list_at_root(lookup)) {
  			bh = lookup->dl_dx_root_bh;

  			retval = ocfs2_journal_access_dr(handle,
  						 INODE_CACHE(dir), bh,

  						 OCFS2_JOURNAL_ACCESS_WRITE);
  		} else {
  			bh = lookup->dl_prev_leaf_bh;

  			retval = ocfs2_journal_access_db(handle,
  						 INODE_CACHE(dir), bh,

  						 OCFS2_JOURNAL_ACCESS_WRITE);
  		}
  		if (retval) {
  			mlog_errno(retval);
  			return retval;
  		}
  	} else if (OCFS2_I(dir)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {

  		data_start = di->id2.i_data.id_data;
  		size = i_size_read(dir);
  
  		BUG_ON(insert_bh != parent_fe_bh);
  	}

  	rec_len = OCFS2_DIR_REC_LEN(namelen);
  	offset = 0;

  	de = (struct ocfs2_dir_entry *) data_start;

  	while (1) {

  		BUG_ON((char *)de >= (size + data_start));

  		/* These checks should've already been passed by the
  		 * prepare function, but I guess we can leave them
  		 * here anyway. */
  		if (!ocfs2_check_dir_entry(dir, de, insert_bh, offset)) {
  			retval = -ENOENT;
  			goto bail;
  		}
  		if (ocfs2_match(namelen, name, de)) {
  			retval = -EEXIST;
  			goto bail;
  		}

  		/* We're guaranteed that we should have space, so we
  		 * can't possibly have hit the trailer...right? */
  		mlog_bug_on_msg(ocfs2_skip_dir_trailer(dir, de, offset, size),
  				"Hit dir trailer trying to insert %.*s "
  			        "(namelen %d) into directory %llu.  "
  				"offset is %lu, trailer offset is %d
  ",
  				namelen, name, namelen,
  				(unsigned long long)parent_fe_bh->b_blocknr,
  				offset, ocfs2_dir_trailer_blk_off(dir->i_sb));

  		if (ocfs2_dirent_would_fit(de, rec_len)) {

  			dir->i_mtime = dir->i_ctime = current_time(dir);

  			retval = ocfs2_mark_inode_dirty(handle, dir, parent_fe_bh);
  			if (retval < 0) {
  				mlog_errno(retval);
  				goto bail;
  			}

  			if (insert_bh == parent_fe_bh)

  				retval = ocfs2_journal_access_di(handle,

  								 INODE_CACHE(dir),

  								 insert_bh,
  								 OCFS2_JOURNAL_ACCESS_WRITE);

  			else {

  				retval = ocfs2_journal_access_db(handle,

  								 INODE_CACHE(dir),

  								 insert_bh,

  					      OCFS2_JOURNAL_ACCESS_WRITE);

  				if (!retval && ocfs2_dir_indexed(dir))
  					retval = ocfs2_dx_dir_insert(dir,

  								handle,
  								lookup);

  			}
  
  			if (retval) {
  				mlog_errno(retval);
  				goto bail;

  			}

  			/* By now the buffer is marked for journaling */
  			offset += le16_to_cpu(de->rec_len);
  			if (le64_to_cpu(de->inode)) {
  				de1 = (struct ocfs2_dir_entry *)((char *) de +
  					OCFS2_DIR_REC_LEN(de->name_len));
  				de1->rec_len =
  					cpu_to_le16(le16_to_cpu(de->rec_len) -
  					OCFS2_DIR_REC_LEN(de->name_len));
  				de->rec_len = cpu_to_le16(OCFS2_DIR_REC_LEN(de->name_len));
  				de = de1;
  			}

  			de->file_type = FT_UNKNOWN;

  			if (blkno) {
  				de->inode = cpu_to_le64(blkno);
  				ocfs2_set_de_type(de, inode->i_mode);
  			} else
  				de->inode = 0;
  			de->name_len = namelen;
  			memcpy(de->name, name, namelen);

  			if (ocfs2_dir_indexed(dir))
  				ocfs2_recalc_free_list(dir, handle, lookup);

  			inode_inc_iversion(dir);

  			ocfs2_journal_dirty(handle, insert_bh);

  			retval = 0;
  			goto bail;
  		}

  		offset += le16_to_cpu(de->rec_len);
  		de = (struct ocfs2_dir_entry *) ((char *) de + le16_to_cpu(de->rec_len));
  	}
  
  	/* when you think about it, the assert above should prevent us
  	 * from ever getting here. */
  	retval = -ENOSPC;
  bail:

  	if (retval)
  		mlog_errno(retval);

  	return retval;
  }

  static int ocfs2_dir_foreach_blk_id(struct inode *inode,

  				    u64 *f_version,

  				    struct dir_context *ctx)

  {

  	int ret, i;
  	unsigned long offset = ctx->pos;

  	struct buffer_head *di_bh = NULL;
  	struct ocfs2_dinode *di;
  	struct ocfs2_inline_data *data;
  	struct ocfs2_dir_entry *de;

  	ret = ocfs2_read_inode_block(inode, &di_bh);

  	if (ret) {
  		mlog(ML_ERROR, "Unable to read inode block for dir %llu
  ",
  		     (unsigned long long)OCFS2_I(inode)->ip_blkno);
  		goto out;
  	}
  
  	di = (struct ocfs2_dinode *)di_bh->b_data;
  	data = &di->id2.i_data;

  	while (ctx->pos < i_size_read(inode)) {

  		/* If the dir block has changed since the last call to
  		 * readdir(2), then we might be pointing to an invalid
  		 * dirent right now.  Scan from the start of the block
  		 * to make sure. */

  		if (!inode_eq_iversion(inode, *f_version)) {

  			for (i = 0; i < i_size_read(inode) && i < offset; ) {
  				de = (struct ocfs2_dir_entry *)
  					(data->id_data + i);
  				/* It's too expensive to do a full
  				 * dirent test each time round this
  				 * loop, but we do have to test at
  				 * least that it is non-zero.  A
  				 * failure will be detected in the
  				 * dirent test below. */
  				if (le16_to_cpu(de->rec_len) <
  				    OCFS2_DIR_REC_LEN(1))
  					break;
  				i += le16_to_cpu(de->rec_len);
  			}

  			ctx->pos = offset = i;

  			*f_version = inode_query_iversion(inode);

  		}

  		de = (struct ocfs2_dir_entry *) (data->id_data + ctx->pos);
  		if (!ocfs2_check_dir_entry(inode, de, di_bh, ctx->pos)) {

  			/* On error, skip the f_pos to the end. */

  			ctx->pos = i_size_read(inode);
  			break;

  		}
  		offset += le16_to_cpu(de->rec_len);
  		if (le64_to_cpu(de->inode)) {

  			if (!dir_emit(ctx, de->name, de->name_len,

  				      le64_to_cpu(de->inode),
  				      fs_ftype_to_dtype(de->file_type)))

  				goto out;

  		}

  		ctx->pos += le16_to_cpu(de->rec_len);

  	}

  out:
  	brelse(di_bh);

  	return 0;
  }

  /*
   * NOTE: This function can be called against unindexed directories,
   * and indexed ones.
   */

  static int ocfs2_dir_foreach_blk_el(struct inode *inode,

  				    u64 *f_version,

  				    struct dir_context *ctx,
  				    bool persist)

  {

  	unsigned long offset, blk, last_ra_blk = 0;

  	int i;

  	struct buffer_head * bh, * tmp;
  	struct ocfs2_dir_entry * de;

  	struct super_block * sb = inode->i_sb;

  	unsigned int ra_sectors = 16;

  	int stored = 0;

  	bh = NULL;

  	offset = ctx->pos & (sb->s_blocksize - 1);

  	while (ctx->pos < i_size_read(inode)) {
  		blk = ctx->pos >> sb->s_blocksize_bits;

  		if (ocfs2_read_dir_block(inode, blk, &bh, 0)) {
  			/* Skip the corrupt dirblock and keep trying */

  			ctx->pos += sb->s_blocksize - offset;

  			continue;
  		}

  		/* The idea here is to begin with 8k read-ahead and to stay
  		 * 4k ahead of our current position.
  		 *
  		 * TODO: Use the pagecache for this. We just need to
  		 * make sure it's cluster-safe... */
  		if (!last_ra_blk
  		    || (((last_ra_blk - blk) << 9) <= (ra_sectors / 2))) {
  			for (i = ra_sectors >> (sb->s_blocksize_bits - 9);

  			     i > 0; i--) {

  				tmp = NULL;
  				if (!ocfs2_read_dir_block(inode, ++blk, &tmp,
  							  OCFS2_BH_READAHEAD))
  					brelse(tmp);

  			}

  			last_ra_blk = blk;
  			ra_sectors = 8;

  		}

  		/* If the dir block has changed since the last call to
  		 * readdir(2), then we might be pointing to an invalid
  		 * dirent right now.  Scan from the start of the block
  		 * to make sure. */

  		if (!inode_eq_iversion(inode, *f_version)) {

  			for (i = 0; i < sb->s_blocksize && i < offset; ) {
  				de = (struct ocfs2_dir_entry *) (bh->b_data + i);
  				/* It's too expensive to do a full
  				 * dirent test each time round this
  				 * loop, but we do have to test at
  				 * least that it is non-zero.  A
  				 * failure will be detected in the
  				 * dirent test below. */
  				if (le16_to_cpu(de->rec_len) <
  				    OCFS2_DIR_REC_LEN(1))
  					break;
  				i += le16_to_cpu(de->rec_len);
  			}
  			offset = i;

  			ctx->pos = (ctx->pos & ~(sb->s_blocksize - 1))

  				| offset;

  			*f_version = inode_query_iversion(inode);

  		}

  		while (ctx->pos < i_size_read(inode)

  		       && offset < sb->s_blocksize) {
  			de = (struct ocfs2_dir_entry *) (bh->b_data + offset);
  			if (!ocfs2_check_dir_entry(inode, de, bh, offset)) {
  				/* On error, skip the f_pos to the
  				   next block. */

  				ctx->pos = (ctx->pos | (sb->s_blocksize - 1)) + 1;

  				break;

  			}

  			if (le64_to_cpu(de->inode)) {

  				if (!dir_emit(ctx, de->name,

  						de->name_len,

  						le64_to_cpu(de->inode),

  					fs_ftype_to_dtype(de->file_type))) {

  					brelse(bh);
  					return 0;

  				}

  				stored++;

  			}

  			offset += le16_to_cpu(de->rec_len);
  			ctx->pos += le16_to_cpu(de->rec_len);

  		}
  		offset = 0;
  		brelse(bh);

  		bh = NULL;

  		if (!persist && stored)
  			break;

  	}

  	return 0;

  }

  static int ocfs2_dir_foreach_blk(struct inode *inode, u64 *f_version,

  				 struct dir_context *ctx,
  				 bool persist)

  {
  	if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)

  		return ocfs2_dir_foreach_blk_id(inode, f_version, ctx);
  	return ocfs2_dir_foreach_blk_el(inode, f_version, ctx, persist);

  }

  /*

   * This is intended to be called from inside other kernel functions,
   * so we fake some arguments.
   */

  int ocfs2_dir_foreach(struct inode *inode, struct dir_context *ctx)

  {

  	u64 version = inode_query_iversion(inode);

  	ocfs2_dir_foreach_blk(inode, &version, ctx, true);

  	return 0;
  }
  
  /*

   * ocfs2_readdir()
   *
   */

  int ocfs2_readdir(struct file *file, struct dir_context *ctx)

  {
  	int error = 0;

  	struct inode *inode = file_inode(file);

  	int lock_level = 0;

  	trace_ocfs2_readdir((unsigned long long)OCFS2_I(inode)->ip_blkno);

  	error = ocfs2_inode_lock_atime(inode, file->f_path.mnt, &lock_level, 1);

  	if (lock_level && error >= 0) {
  		/* We release EX lock which used to update atime
  		 * and get PR lock again to reduce contention
  		 * on commonly accessed directories. */

  		ocfs2_inode_unlock(inode, 1);

  		lock_level = 0;

  		error = ocfs2_inode_lock(inode, NULL, 0);

  	}
  	if (error < 0) {
  		if (error != -ENOENT)
  			mlog_errno(error);
  		/* we haven't got any yet, so propagate the error. */
  		goto bail_nolock;
  	}

  	error = ocfs2_dir_foreach_blk(inode, &file->f_version, ctx, false);

  	ocfs2_inode_unlock(inode, lock_level);

  	if (error)
  		mlog_errno(error);

  bail_nolock:

  	return error;

  }
  
  /*

   * NOTE: this should always be called with parent dir i_mutex taken.

   */
  int ocfs2_find_files_on_disk(const char *name,
  			     int namelen,
  			     u64 *blkno,
  			     struct inode *inode,

  			     struct ocfs2_dir_lookup_result *lookup)

  {
  	int status = -ENOENT;

  	trace_ocfs2_find_files_on_disk(namelen, name, blkno,
  				(unsigned long long)OCFS2_I(inode)->ip_blkno);

  	status = ocfs2_find_entry(name, namelen, inode, lookup);
  	if (status)

  		goto leave;

  	*blkno = le64_to_cpu(lookup->dl_entry->inode);

  
  	status = 0;
  leave:

  	return status;
  }

  /*
   * Convenience function for callers which just want the block number
   * mapped to a name and don't require the full dirent info, etc.
   */
  int ocfs2_lookup_ino_from_name(struct inode *dir, const char *name,
  			       int namelen, u64 *blkno)
  {
  	int ret;

  	struct ocfs2_dir_lookup_result lookup = { NULL, };

  	ret = ocfs2_find_files_on_disk(name, namelen, blkno, dir, &lookup);
  	ocfs2_free_dir_lookup_result(&lookup);

  
  	return ret;
  }

  /* Check for a name within a directory.
   *
   * Return 0 if the name does not exist
   * Return -EEXIST if the directory contains the name
   *

   * Callers should have i_mutex + a cluster lock on dir

   */
  int ocfs2_check_dir_for_entry(struct inode *dir,
  			      const char *name,
  			      int namelen)
  {

  	int ret = 0;

  	struct ocfs2_dir_lookup_result lookup = { NULL, };

  	trace_ocfs2_check_dir_for_entry(
  		(unsigned long long)OCFS2_I(dir)->ip_blkno, namelen, name);

  	if (ocfs2_find_entry(name, namelen, dir, &lookup) == 0) {
  		ret = -EEXIST;
  		mlog_errno(ret);
  	}

  	ocfs2_free_dir_lookup_result(&lookup);

  	return ret;
  }

  struct ocfs2_empty_dir_priv {

  	struct dir_context ctx;

  	unsigned seen_dot;
  	unsigned seen_dot_dot;
  	unsigned seen_other;

  	unsigned dx_dir;

  };

  static int ocfs2_empty_dir_filldir(struct dir_context *ctx, const char *name,
  				   int name_len, loff_t pos, u64 ino,
  				   unsigned type)

  {

  	struct ocfs2_empty_dir_priv *p =
  		container_of(ctx, struct ocfs2_empty_dir_priv, ctx);

  
  	/*
  	 * Check the positions of "." and ".." records to be sure
  	 * they're in the correct place.

  	 *
  	 * Indexed directories don't need to proceed past the first
  	 * two entries, so we end the scan after seeing '..'. Despite
  	 * that, we allow the scan to proceed In the event that we
  	 * have a corrupted indexed directory (no dot or dot dot
  	 * entries). This allows us to double check for existing
  	 * entries which might not have been found in the index.

  	 */
  	if (name_len == 1 && !strncmp(".", name, 1) && pos == 0) {
  		p->seen_dot = 1;
  		return 0;
  	}
  
  	if (name_len == 2 && !strncmp("..", name, 2) &&
  	    pos == OCFS2_DIR_REC_LEN(1)) {
  		p->seen_dot_dot = 1;

  
  		if (p->dx_dir && p->seen_dot)
  			return 1;

  		return 0;
  	}
  
  	p->seen_other = 1;
  	return 1;
  }

  
  static int ocfs2_empty_dir_dx(struct inode *inode,
  			      struct ocfs2_empty_dir_priv *priv)
  {
  	int ret;
  	struct buffer_head *di_bh = NULL;
  	struct buffer_head *dx_root_bh = NULL;
  	struct ocfs2_dinode *di;
  	struct ocfs2_dx_root_block *dx_root;
  
  	priv->dx_dir = 1;
  
  	ret = ocfs2_read_inode_block(inode, &di_bh);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  	di = (struct ocfs2_dinode *)di_bh->b_data;
  
  	ret = ocfs2_read_dx_root(inode, di, &dx_root_bh);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  	dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
  
  	if (le32_to_cpu(dx_root->dr_num_entries) != 2)
  		priv->seen_other = 1;
  
  out:
  	brelse(di_bh);
  	brelse(dx_root_bh);
  	return ret;
  }

  /*
   * routine to check that the specified directory is empty (for rmdir)

   *
   * Returns 1 if dir is empty, zero otherwise.

   *

   * XXX: This is a performance problem for unindexed directories.

   */
  int ocfs2_empty_dir(struct inode *inode)
  {

  	int ret;

  	struct ocfs2_empty_dir_priv priv = {

  		.ctx.actor = ocfs2_empty_dir_filldir,

  	};

  	if (ocfs2_dir_indexed(inode)) {
  		ret = ocfs2_empty_dir_dx(inode, &priv);
  		if (ret)
  			mlog_errno(ret);
  		/*
  		 * We still run ocfs2_dir_foreach to get the checks
  		 * for "." and "..".
  		 */
  	}

  	ret = ocfs2_dir_foreach(inode, &priv.ctx);

  	if (ret)
  		mlog_errno(ret);
  
  	if (!priv.seen_dot || !priv.seen_dot_dot) {
  		mlog(ML_ERROR, "bad directory (dir #%llu) - no `.' or `..'
  ",

  		     (unsigned long long)OCFS2_I(inode)->ip_blkno);

  		/*
  		 * XXX: Is it really safe to allow an unlink to continue?
  		 */

  		return 1;
  	}

  
  	return !priv.seen_other;

  }

  /*
   * Fills "." and ".." dirents in a new directory block. Returns dirent for
   * "..", which might be used during creation of a directory with a trailing
   * header. It is otherwise safe to ignore the return code.
   */
  static struct ocfs2_dir_entry *ocfs2_fill_initial_dirents(struct inode *inode,
  							  struct inode *parent,
  							  char *start,
  							  unsigned int size)

  {
  	struct ocfs2_dir_entry *de = (struct ocfs2_dir_entry *)start;
  
  	de->inode = cpu_to_le64(OCFS2_I(inode)->ip_blkno);
  	de->name_len = 1;
  	de->rec_len =
  		cpu_to_le16(OCFS2_DIR_REC_LEN(de->name_len));
  	strcpy(de->name, ".");
  	ocfs2_set_de_type(de, S_IFDIR);
  
  	de = (struct ocfs2_dir_entry *) ((char *)de + le16_to_cpu(de->rec_len));
  	de->inode = cpu_to_le64(OCFS2_I(parent)->ip_blkno);
  	de->rec_len = cpu_to_le16(size - OCFS2_DIR_REC_LEN(1));
  	de->name_len = 2;
  	strcpy(de->name, "..");
  	ocfs2_set_de_type(de, S_IFDIR);

  
  	return de;

  }
  
  /*
   * This works together with code in ocfs2_mknod_locked() which sets
   * the inline-data flag and initializes the inline-data section.
   */
  static int ocfs2_fill_new_dir_id(struct ocfs2_super *osb,
  				 handle_t *handle,
  				 struct inode *parent,
  				 struct inode *inode,
  				 struct buffer_head *di_bh)
  {
  	int ret;
  	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
  	struct ocfs2_inline_data *data = &di->id2.i_data;
  	unsigned int size = le16_to_cpu(data->id_count);

  	ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,

  				      OCFS2_JOURNAL_ACCESS_WRITE);

  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  
  	ocfs2_fill_initial_dirents(inode, parent, data->id_data, size);

  	ocfs2_journal_dirty(handle, di_bh);

  
  	i_size_write(inode, size);

  	set_nlink(inode, 2);

  	inode->i_blocks = ocfs2_inode_sector_count(inode);
  
  	ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);
  	if (ret < 0)
  		mlog_errno(ret);
  
  out:
  	return ret;
  }
  
  static int ocfs2_fill_new_dir_el(struct ocfs2_super *osb,
  				 handle_t *handle,
  				 struct inode *parent,
  				 struct inode *inode,
  				 struct buffer_head *fe_bh,

  				 struct ocfs2_alloc_context *data_ac,
  				 struct buffer_head **ret_new_bh)

  {
  	int status;

  	unsigned int size = osb->sb->s_blocksize;

  	struct buffer_head *new_bh = NULL;

  	struct ocfs2_dir_entry *de;

  	if (ocfs2_new_dir_wants_trailer(inode))

  		size = ocfs2_dir_trailer_blk_off(parent->i_sb);

  	status = ocfs2_do_extend_dir(osb->sb, handle, inode, fe_bh,
  				     data_ac, NULL, &new_bh);
  	if (status < 0) {
  		mlog_errno(status);
  		goto bail;
  	}

  	ocfs2_set_new_buffer_uptodate(INODE_CACHE(inode), new_bh);

  	status = ocfs2_journal_access_db(handle, INODE_CACHE(inode), new_bh,

  					 OCFS2_JOURNAL_ACCESS_CREATE);

  	if (status < 0) {
  		mlog_errno(status);
  		goto bail;
  	}
  	memset(new_bh->b_data, 0, osb->sb->s_blocksize);

  	de = ocfs2_fill_initial_dirents(inode, parent, new_bh->b_data, size);

  	if (ocfs2_new_dir_wants_trailer(inode)) {
  		int size = le16_to_cpu(de->rec_len);
  
  		/*
  		 * Figure out the size of the hole left over after
  		 * insertion of '.' and '..'. The trailer wants this
  		 * information.
  		 */
  		size -= OCFS2_DIR_REC_LEN(2);
  		size -= sizeof(struct ocfs2_dir_block_trailer);
  
  		ocfs2_init_dir_trailer(inode, new_bh, size);
  	}

  	ocfs2_journal_dirty(handle, new_bh);

  
  	i_size_write(inode, inode->i_sb->s_blocksize);

  	set_nlink(inode, 2);

  	inode->i_blocks = ocfs2_inode_sector_count(inode);
  	status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
  	if (status < 0) {
  		mlog_errno(status);
  		goto bail;
  	}
  
  	status = 0;

  	if (ret_new_bh) {
  		*ret_new_bh = new_bh;
  		new_bh = NULL;
  	}

  bail:

  	brelse(new_bh);

  	return status;
  }

  static int ocfs2_dx_dir_attach_index(struct ocfs2_super *osb,
  				     handle_t *handle, struct inode *dir,
  				     struct buffer_head *di_bh,

  				     struct buffer_head *dirdata_bh,

  				     struct ocfs2_alloc_context *meta_ac,

  				     int dx_inline, u32 num_entries,

  				     struct buffer_head **ret_dx_root_bh)

  {

  	int ret;
  	struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data;
  	u16 dr_suballoc_bit;

  	u64 suballoc_loc, dr_blkno;

  	unsigned int num_bits;
  	struct buffer_head *dx_root_bh = NULL;
  	struct ocfs2_dx_root_block *dx_root;

  	struct ocfs2_dir_block_trailer *trailer =
  		ocfs2_trailer_from_bh(dirdata_bh, dir->i_sb);

  	ret = ocfs2_claim_metadata(handle, meta_ac, 1, &suballoc_loc,
  				   &dr_suballoc_bit, &num_bits, &dr_blkno);

  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}

  	trace_ocfs2_dx_dir_attach_index(
  				(unsigned long long)OCFS2_I(dir)->ip_blkno,
  				(unsigned long long)dr_blkno);

  	dx_root_bh = sb_getblk(osb->sb, dr_blkno);
  	if (dx_root_bh == NULL) {

  		ret = -ENOMEM;

  		goto out;
  	}

  	ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir), dx_root_bh);

  	ret = ocfs2_journal_access_dr(handle, INODE_CACHE(dir), dx_root_bh,

  				      OCFS2_JOURNAL_ACCESS_CREATE);
  	if (ret < 0) {
  		mlog_errno(ret);
  		goto out;
  	}

  	dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
  	memset(dx_root, 0, osb->sb->s_blocksize);
  	strcpy(dx_root->dr_signature, OCFS2_DX_ROOT_SIGNATURE);

  	dx_root->dr_suballoc_slot = cpu_to_le16(meta_ac->ac_alloc_slot);

  	dx_root->dr_suballoc_loc = cpu_to_le64(suballoc_loc);

  	dx_root->dr_suballoc_bit = cpu_to_le16(dr_suballoc_bit);
  	dx_root->dr_fs_generation = cpu_to_le32(osb->fs_generation);
  	dx_root->dr_blkno = cpu_to_le64(dr_blkno);
  	dx_root->dr_dir_blkno = cpu_to_le64(OCFS2_I(dir)->ip_blkno);

  	dx_root->dr_num_entries = cpu_to_le32(num_entries);

  	if (le16_to_cpu(trailer->db_free_rec_len))
  		dx_root->dr_free_blk = cpu_to_le64(dirdata_bh->b_blocknr);
  	else
  		dx_root->dr_free_blk = cpu_to_le64(0);

  
  	if (dx_inline) {
  		dx_root->dr_flags |= OCFS2_DX_FLAG_INLINE;
  		dx_root->dr_entries.de_count =
  			cpu_to_le16(ocfs2_dx_entries_per_root(osb->sb));
  	} else {
  		dx_root->dr_list.l_count =
  			cpu_to_le16(ocfs2_extent_recs_per_dx_root(osb->sb));
  	}

  	ocfs2_journal_dirty(handle, dx_root_bh);

  	ret = ocfs2_journal_access_di(handle, INODE_CACHE(dir), di_bh,

  				      OCFS2_JOURNAL_ACCESS_CREATE);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  
  	di->i_dx_root = cpu_to_le64(dr_blkno);

  	spin_lock(&OCFS2_I(dir)->ip_lock);

  	OCFS2_I(dir)->ip_dyn_features |= OCFS2_INDEXED_DIR_FL;
  	di->i_dyn_features = cpu_to_le16(OCFS2_I(dir)->ip_dyn_features);

  	spin_unlock(&OCFS2_I(dir)->ip_lock);

  	ocfs2_journal_dirty(handle, di_bh);

  
  	*ret_dx_root_bh = dx_root_bh;
  	dx_root_bh = NULL;
  
  out:
  	brelse(dx_root_bh);
  	return ret;
  }
  
  static int ocfs2_dx_dir_format_cluster(struct ocfs2_super *osb,
  				       handle_t *handle, struct inode *dir,
  				       struct buffer_head **dx_leaves,
  				       int num_dx_leaves, u64 start_blk)
  {
  	int ret, i;
  	struct ocfs2_dx_leaf *dx_leaf;
  	struct buffer_head *bh;
  
  	for (i = 0; i < num_dx_leaves; i++) {
  		bh = sb_getblk(osb->sb, start_blk + i);
  		if (bh == NULL) {

  			ret = -ENOMEM;

  			goto out;
  		}
  		dx_leaves[i] = bh;

  		ocfs2_set_new_buffer_uptodate(INODE_CACHE(dir), bh);

  		ret = ocfs2_journal_access_dl(handle, INODE_CACHE(dir), bh,

  					      OCFS2_JOURNAL_ACCESS_CREATE);
  		if (ret < 0) {
  			mlog_errno(ret);
  			goto out;
  		}
  
  		dx_leaf = (struct ocfs2_dx_leaf *) bh->b_data;
  
  		memset(dx_leaf, 0, osb->sb->s_blocksize);
  		strcpy(dx_leaf->dl_signature, OCFS2_DX_LEAF_SIGNATURE);
  		dx_leaf->dl_fs_generation = cpu_to_le32(osb->fs_generation);
  		dx_leaf->dl_blkno = cpu_to_le64(bh->b_blocknr);
  		dx_leaf->dl_list.de_count =
  			cpu_to_le16(ocfs2_dx_entries_per_leaf(osb->sb));

  		trace_ocfs2_dx_dir_format_cluster(
  				(unsigned long long)OCFS2_I(dir)->ip_blkno,
  				(unsigned long long)bh->b_blocknr,
  				le16_to_cpu(dx_leaf->dl_list.de_count));

  
  		ocfs2_journal_dirty(handle, bh);
  	}
  
  	ret = 0;
  out:
  	return ret;
  }
  
  /*
   * Allocates and formats a new cluster for use in an indexed dir
   * leaf. This version will not do the extent insert, so that it can be
   * used by operations which need careful ordering.
   */
  static int __ocfs2_dx_dir_new_cluster(struct inode *dir,
  				      u32 cpos, handle_t *handle,
  				      struct ocfs2_alloc_context *data_ac,
  				      struct buffer_head **dx_leaves,
  				      int num_dx_leaves, u64 *ret_phys_blkno)
  {
  	int ret;
  	u32 phys, num;
  	u64 phys_blkno;
  	struct ocfs2_super *osb = OCFS2_SB(dir->i_sb);
  
  	/*
  	 * XXX: For create, this should claim cluster for the index
  	 * *before* the unindexed insert so that we have a better
  	 * chance of contiguousness as the directory grows in number
  	 * of entries.
  	 */

  	ret = __ocfs2_claim_clusters(handle, data_ac, 1, 1, &phys, &num);

  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  
  	/*
  	 * Format the new cluster first. That way, we're inserting
  	 * valid data.
  	 */
  	phys_blkno = ocfs2_clusters_to_blocks(osb->sb, phys);
  	ret = ocfs2_dx_dir_format_cluster(osb, handle, dir, dx_leaves,
  					  num_dx_leaves, phys_blkno);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}
  
  	*ret_phys_blkno = phys_blkno;
  out:
  	return ret;
  }
  
  static int ocfs2_dx_dir_new_cluster(struct inode *dir,
  				    struct ocfs2_extent_tree *et,
  				    u32 cpos, handle_t *handle,
  				    struct ocfs2_alloc_context *data_ac,
  				    struct ocfs2_alloc_context *meta_ac,
  				    struct buffer_head **dx_leaves,
  				    int num_dx_leaves)
  {
  	int ret;
  	u64 phys_blkno;

  
  	ret = __ocfs2_dx_dir_new_cluster(dir, cpos, handle, data_ac, dx_leaves,
  					 num_dx_leaves, &phys_blkno);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}

  	ret = ocfs2_insert_extent(handle, et, cpos, phys_blkno, 1, 0,

  				  meta_ac);
  	if (ret)
  		mlog_errno(ret);
  out:
  	return ret;
  }
  
  static struct buffer_head **ocfs2_dx_dir_kmalloc_leaves(struct super_block *sb,
  							int *ret_num_leaves)
  {
  	int num_dx_leaves = ocfs2_clusters_to_blocks(sb, 1);
  	struct buffer_head **dx_leaves;
  
  	dx_leaves = kcalloc(num_dx_leaves, sizeof(struct buffer_head *),
  			    GFP_NOFS);
  	if (dx_leaves && ret_num_leaves)
  		*ret_num_leaves = num_dx_leaves;
  
  	return dx_leaves;
  }
  
  static int ocfs2_fill_new_dir_dx(struct ocfs2_super *osb,
  				 handle_t *handle,
  				 struct inode *parent,
  				 struct inode *inode,
  				 struct buffer_head *di_bh,
  				 struct ocfs2_alloc_context *data_ac,
  				 struct ocfs2_alloc_context *meta_ac)
  {

  	int ret;

  	struct buffer_head *leaf_bh = NULL;
  	struct buffer_head *dx_root_bh = NULL;

  	struct ocfs2_dx_hinfo hinfo;

  	struct ocfs2_dx_root_block *dx_root;
  	struct ocfs2_dx_entry_list *entry_list;

  
  	/*
  	 * Our strategy is to create the directory as though it were
  	 * unindexed, then add the index block. This works with very
  	 * little complication since the state of a new directory is a
  	 * very well known quantity.
  	 *
  	 * Essentially, we have two dirents ("." and ".."), in the 1st

  	 * block which need indexing. These are easily inserted into
  	 * the index block.

  	 */
  
  	ret = ocfs2_fill_new_dir_el(osb, handle, parent, inode, di_bh,
  				    data_ac, &leaf_bh);
  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}

  	ret = ocfs2_dx_dir_attach_index(osb, handle, inode, di_bh, leaf_bh,

  					meta_ac, 1, 2, &dx_root_bh);

  	if (ret) {
  		mlog_errno(ret);
  		goto out;
  	}

  	dx_root = (struct ocfs2_dx_root_block *)dx_root_bh->b_data;
  	entry_list = &dx_root->dr_entries;

  	/* Buffer has been journaled for us by ocfs2_dx_dir_attach_index */

  	ocfs2_dx_dir_name_hash(inode, ".", 1, &hinfo);

  	ocfs2_dx_entry_list_insert(entry_list, &hinfo, leaf_bh->b_blocknr);

  
  	ocfs2_dx_dir_name_hash(inode, "..", 2, &hinfo);

  	ocfs2_dx_entry_list_insert(entry_list, &hinfo, leaf_bh->b_blocknr);

  
  out:

  	brelse(dx_root_bh);
  	brelse(leaf_bh);
  	return ret;
  }
  
  int ocfs2_fill_new_dir(struct ocfs2_super *osb,
  		       handle_t *handle,
  		       struct inode *parent,
  		       struct inode *inode,
  		       struct buffer_head *fe_bh,
  		       struct ocfs2_alloc_context *data_ac,
  		       struct ocfs2_alloc_context *meta_ac)
  
  {
  	BUG_ON(!ocfs2_supports_inline_data(osb) && data_ac == NULL);
  
  	if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
  		return ocfs2_fill_new_dir_id(osb, handle, parent, inode, fe_bh);
  
  	if (ocfs2_supports_indexed_dirs(osb))
  		return ocfs2_fill_new_dir_dx(osb, handle, parent, inode, fe_bh,
  					     data_ac, meta_ac);
  
  	return ocfs2_fill_new_dir_el(osb, handle, parent, inode, fe_bh,
  				     data_ac, NULL);
  }
  
  static int ocfs2_dx_dir_index_block(struct inode *dir,
  				    handle_t *handle,
  				    struct buffer_head **dx_leaves,
  				    int num_dx_leaves,

  				    u32 *num_dx_entries,

  				    struct buffer_head *dirent_bh)
  {

  	int ret = 0, namelen, i;

  	char *de_buf, *limit;
  	struct ocfs2_dir_entry *de;
  	struct buffer_head *dx_leaf_bh;
  	struct ocfs2_dx_hinfo hinfo;
  	u64 dirent_blk = dirent_bh->b_blocknr;
  
  	de_buf = dirent_bh->b_data;
  	limit = de_buf + dir->i_sb->s_blocksize;
  
  	while (de_buf < limit) {
  		de = (struct ocfs2_dir_entry *)de_buf;
  
  		namelen = de->name_len;
  		if (!namelen || !de->inode)
  			goto inc;
  
  		ocfs2_dx_dir_name_hash(dir, de->name, namelen, &hinfo);
  
  		i = ocfs2_dx_dir_hash_idx(OCFS2_SB(dir->i_sb), &hinfo);
  		dx_leaf_bh = dx_leaves[i];
  
  		ret = __ocfs2_dx_dir_leaf_insert(dir, handle, &hinfo,
  						 dirent_blk, dx_leaf_bh);
  		if (ret) {
  			mlog_errno(ret);
  			goto out;
  		}

  		*num_dx_entries = *num_dx_entries + 1;

  inc:
  		de_buf += le16_to_cpu(de->rec_len);
  	}
  
  out:
  	return ret;
  }

  
  /*