[linux-2.6-block.git] / fs / ext4 / dir.c

/*
 *  linux/fs/ext4/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
 *
 *  ext4 directory handling functions
 *
 *  Big-endian to little-endian byte-swapping/bitmaps by
 *        David S. Miller (davem@caip.rutgers.edu), 1995
 *
 * Hash Tree Directory indexing (c) 2001  Daniel Phillips
 *
 */

#include <linux/fs.h>
#include <linux/buffer_head.h>
#include <linux/slab.h>
#include "ext4.h"
#include "xattr.h"

static int ext4_dx_readdir(struct file *, struct dir_context *);

/**
 * Check if the given dir-inode refers to an htree-indexed directory
 * (or a directory which could potentially get converted to use htree
 * indexing).
 *
 * Return 1 if it is a dx dir, 0 if not
 */
static int is_dx_dir(struct inode *inode)
{
	struct super_block *sb = inode->i_sb;

	if (EXT4_HAS_COMPAT_FEATURE(inode->i_sb,
		     EXT4_FEATURE_COMPAT_DIR_INDEX) &&
	    ((ext4_test_inode_flag(inode, EXT4_INODE_INDEX)) ||
	     ((inode->i_size >> sb->s_blocksize_bits) == 1) ||
	     ext4_has_inline_data(inode)))
		return 1;

	return 0;
}

/*
 * Return 0 if the directory entry is OK, and 1 if there is a problem
 *
 * Note: this is the opposite of what ext2 and ext3 historically returned...
 *
 * bh passed here can be an inode block or a dir data block, depending
 * on the inode inline data flag.
 */
int __ext4_check_dir_entry(const char *function, unsigned int line,
			   struct inode *dir, struct file *filp,
			   struct ext4_dir_entry_2 *de,
			   struct buffer_head *bh, char *buf, int size,
			   unsigned int offset)
{
	const char *error_msg = NULL;
	const int rlen = ext4_rec_len_from_disk(de->rec_len,
						dir->i_sb->s_blocksize);

	if (unlikely(rlen < EXT4_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 < EXT4_DIR_REC_LEN(de->name_len)))
		error_msg = "rec_len is too small for name_len";
	else if (unlikely(((char *) de - buf) + rlen > size))
		error_msg = "directory entry across range";
	else if (unlikely(le32_to_cpu(de->inode) >
			le32_to_cpu(EXT4_SB(dir->i_sb)->s_es->s_inodes_count)))
		error_msg = "inode out of bounds";
	else
		return 0;

	if (filp)
		ext4_error_file(filp, function, line, bh->b_blocknr,
				"bad entry in directory: %s - offset=%u(%u), "
				"inode=%u, rec_len=%d, name_len=%d",
				error_msg, (unsigned) (offset % size),
				offset, le32_to_cpu(de->inode),
				rlen, de->name_len);
	else
		ext4_error_inode(dir, function, line, bh->b_blocknr,
				"bad entry in directory: %s - offset=%u(%u), "
				"inode=%u, rec_len=%d, name_len=%d",
				error_msg, (unsigned) (offset % size),
				offset, le32_to_cpu(de->inode),
				rlen, de->name_len);

	return 1;
}

static int ext4_readdir(struct file *file, struct dir_context *ctx)
{
	unsigned int offset;
	int i;
	struct ext4_dir_entry_2 *de;
	int err;
	struct inode *inode = file_inode(file);
	struct super_block *sb = inode->i_sb;
	struct buffer_head *bh = NULL;
	int dir_has_error = 0;
	struct ext4_fname_crypto_ctx *enc_ctx = NULL;
	struct ext4_str fname_crypto_str = {.name = NULL, .len = 0};

	if (is_dx_dir(inode)) {
		err = ext4_dx_readdir(file, ctx);
		if (err != ERR_BAD_DX_DIR) {
			return err;
		}
		/*
		 * We don't set the inode dirty flag since it's not
		 * critical that it get flushed back to the disk.
		 */
		ext4_clear_inode_flag(file_inode(file),
				      EXT4_INODE_INDEX);
	}

	if (ext4_has_inline_data(inode)) {
		int has_inline_data = 1;
		err = ext4_read_inline_dir(file, ctx,
					   &has_inline_data);
		if (has_inline_data)
			return err;
	}

	enc_ctx = ext4_get_fname_crypto_ctx(inode, EXT4_NAME_LEN);
	if (IS_ERR(enc_ctx))
		return PTR_ERR(enc_ctx);
	if (enc_ctx) {
		err = ext4_fname_crypto_alloc_buffer(enc_ctx, EXT4_NAME_LEN,
						     &fname_crypto_str);
		if (err < 0) {
			ext4_put_fname_crypto_ctx(&enc_ctx);
			return err;
		}
	}

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

	while (ctx->pos < inode->i_size) {
		struct ext4_map_blocks map;

		map.m_lblk = ctx->pos >> EXT4_BLOCK_SIZE_BITS(sb);
		map.m_len = 1;
		err = ext4_map_blocks(NULL, inode, &map, 0);
		if (err > 0) {
			pgoff_t index = map.m_pblk >>
					(PAGE_CACHE_SHIFT - inode->i_blkbits);
			if (!ra_has_index(&file->f_ra, index))
				page_cache_sync_readahead(
					sb->s_bdev->bd_inode->i_mapping,
					&file->f_ra, file,
					index, 1);
			file->f_ra.prev_pos = (loff_t)index << PAGE_CACHE_SHIFT;
			bh = ext4_bread(NULL, inode, map.m_lblk, 0);
			if (IS_ERR(bh))
				return PTR_ERR(bh);
		}

		if (!bh) {
			if (!dir_has_error) {
				EXT4_ERROR_FILE(file, 0,
						"directory contains a "
						"hole at offset %llu",
					   (unsigned long long) ctx->pos);
				dir_has_error = 1;
			}
			/* corrupt size?  Maybe no more blocks to read */
			if (ctx->pos > inode->i_blocks << 9)
				break;
			ctx->pos += sb->s_blocksize - offset;
			continue;
		}

		/* Check the checksum */
		if (!buffer_verified(bh) &&
		    !ext4_dirent_csum_verify(inode,
				(struct ext4_dir_entry *)bh->b_data)) {
			EXT4_ERROR_FILE(file, 0, "directory fails checksum "
					"at offset %llu",
					(unsigned long long)ctx->pos);
			ctx->pos += sb->s_blocksize - offset;
			brelse(bh);
			bh = NULL;
			continue;
		}
		set_buffer_verified(bh);

		/* 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 (file->f_version != inode->i_version) {
			for (i = 0; i < sb->s_blocksize && i < offset; ) {
				de = (struct ext4_dir_entry_2 *)
					(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 (ext4_rec_len_from_disk(de->rec_len,
					sb->s_blocksize) < EXT4_DIR_REC_LEN(1))
					break;
				i += ext4_rec_len_from_disk(de->rec_len,
							    sb->s_blocksize);
			}
			offset = i;
			ctx->pos = (ctx->pos & ~(sb->s_blocksize - 1))
				| offset;
			file->f_version = inode->i_version;
		}

		while (ctx->pos < inode->i_size
		       && offset < sb->s_blocksize) {
			de = (struct ext4_dir_entry_2 *) (bh->b_data + offset);
			if (ext4_check_dir_entry(inode, file, de, bh,
						 bh->b_data, bh->b_size,
						 offset)) {
				/*
				 * On error, skip to the next block
				 */
				ctx->pos = (ctx->pos |
						(sb->s_blocksize - 1)) + 1;
				break;
			}
			offset += ext4_rec_len_from_disk(de->rec_len,
					sb->s_blocksize);
			if (le32_to_cpu(de->inode)) {
				if (enc_ctx == NULL) {
					/* Directory is not encrypted */
					if (!dir_emit(ctx, de->name,
					    de->name_len,
					    le32_to_cpu(de->inode),
					    get_dtype(sb, de->file_type)))
						goto done;
				} else {
					/* Directory is encrypted */
					err = ext4_fname_disk_to_usr(enc_ctx,
						NULL, de, &fname_crypto_str);
					if (err < 0)
						goto errout;
					if (!dir_emit(ctx,
					    fname_crypto_str.name, err,
					    le32_to_cpu(de->inode),
					    get_dtype(sb, de->file_type)))
						goto done;
				}
			}
			ctx->pos += ext4_rec_len_from_disk(de->rec_len,
						sb->s_blocksize);
		}
		if ((ctx->pos < inode->i_size) && !dir_relax(inode))
			goto done;
		brelse(bh);
		bh = NULL;
		offset = 0;
	}
done:
	err = 0;
errout:
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	ext4_put_fname_crypto_ctx(&enc_ctx);
	ext4_fname_crypto_free_buffer(&fname_crypto_str);
#endif
	brelse(bh);
	return err;
}

static inline int is_32bit_api(void)
{
#ifdef CONFIG_COMPAT
	return is_compat_task();
#else
	return (BITS_PER_LONG == 32);
#endif
}

/*
 * These functions convert from the major/minor hash to an f_pos
 * value for dx directories
 *
 * Upper layer (for example NFS) should specify FMODE_32BITHASH or
 * FMODE_64BITHASH explicitly. On the other hand, we allow ext4 to be mounted
 * directly on both 32-bit and 64-bit nodes, under such case, neither
 * FMODE_32BITHASH nor FMODE_64BITHASH is specified.
 */
static inline loff_t hash2pos(struct file *filp, __u32 major, __u32 minor)
{
	if ((filp->f_mode & FMODE_32BITHASH) ||
	    (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
		return major >> 1;
	else
		return ((__u64)(major >> 1) << 32) | (__u64)minor;
}

static inline __u32 pos2maj_hash(struct file *filp, loff_t pos)
{
	if ((filp->f_mode & FMODE_32BITHASH) ||
	    (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
		return (pos << 1) & 0xffffffff;
	else
		return ((pos >> 32) << 1) & 0xffffffff;
}

static inline __u32 pos2min_hash(struct file *filp, loff_t pos)
{
	if ((filp->f_mode & FMODE_32BITHASH) ||
	    (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
		return 0;
	else
		return pos & 0xffffffff;
}

/*
 * Return 32- or 64-bit end-of-file for dx directories
 */
static inline loff_t ext4_get_htree_eof(struct file *filp)
{
	if ((filp->f_mode & FMODE_32BITHASH) ||
	    (!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
		return EXT4_HTREE_EOF_32BIT;
	else
		return EXT4_HTREE_EOF_64BIT;
}


/*
 * ext4_dir_llseek() calls generic_file_llseek_size to handle htree
 * directories, where the "offset" is in terms of the filename hash
 * value instead of the byte offset.
 *
 * Because we may return a 64-bit hash that is well beyond offset limits,
 * we need to pass the max hash as the maximum allowable offset in
 * the htree directory case.
 *
 * For non-htree, ext4_llseek already chooses the proper max offset.
 */
static loff_t ext4_dir_llseek(struct file *file, loff_t offset, int whence)
{
	struct inode *inode = file->f_mapping->host;
	int dx_dir = is_dx_dir(inode);
	loff_t htree_max = ext4_get_htree_eof(file);

	if (likely(dx_dir))
		return generic_file_llseek_size(file, offset, whence,
						    htree_max, htree_max);
	else
		return ext4_llseek(file, offset, whence);
}

/*
 * This structure holds the nodes of the red-black tree used to store
 * the directory entry in hash order.
 */
struct fname {
	__u32		hash;
	__u32		minor_hash;
	struct rb_node	rb_hash;
	struct fname	*next;
	__u32		inode;
	__u8		name_len;
	__u8		file_type;
	char		name[0];
};

/*
 * This functoin implements a non-recursive way of freeing all of the
 * nodes in the red-black tree.
 */
static void free_rb_tree_fname(struct rb_root *root)
{
	struct fname *fname, *next;

	rbtree_postorder_for_each_entry_safe(fname, next, root, rb_hash)
		while (fname) {
			struct fname *old = fname;
			fname = fname->next;
			kfree(old);
		}

	*root = RB_ROOT;
}


static struct dir_private_info *ext4_htree_create_dir_info(struct file *filp,
							   loff_t pos)
{
	struct dir_private_info *p;

	p = kzalloc(sizeof(struct dir_private_info), GFP_KERNEL);
	if (!p)
		return NULL;
	p->curr_hash = pos2maj_hash(filp, pos);
	p->curr_minor_hash = pos2min_hash(filp, pos);
	return p;
}

void ext4_htree_free_dir_info(struct dir_private_info *p)
{
	free_rb_tree_fname(&p->root);
	kfree(p);
}

/*
 * Given a directory entry, enter it into the fname rb tree.
 *
 * When filename encryption is enabled, the dirent will hold the
 * encrypted filename, while the htree will hold decrypted filename.
 * The decrypted filename is passed in via ent_name.  parameter.
 */
int ext4_htree_store_dirent(struct file *dir_file, __u32 hash,
			     __u32 minor_hash,
			    struct ext4_dir_entry_2 *dirent,
			    struct ext4_str *ent_name)
{
	struct rb_node **p, *parent = NULL;
	struct fname *fname, *new_fn;
	struct dir_private_info *info;
	int len;

	info = dir_file->private_data;
	p = &info->root.rb_node;

	/* Create and allocate the fname structure */
	len = sizeof(struct fname) + ent_name->len + 1;
	new_fn = kzalloc(len, GFP_KERNEL);
	if (!new_fn)
		return -ENOMEM;
	new_fn->hash = hash;
	new_fn->minor_hash = minor_hash;
	new_fn->inode = le32_to_cpu(dirent->inode);
	new_fn->name_len = ent_name->len;
	new_fn->file_type = dirent->file_type;
	memcpy(new_fn->name, ent_name->name, ent_name->len);
	new_fn->name[ent_name->len] = 0;

	while (*p) {
		parent = *p;
		fname = rb_entry(parent, struct fname, rb_hash);

		/*
		 * If the hash and minor hash match up, then we put
		 * them on a linked list.  This rarely happens...
		 */
		if ((new_fn->hash == fname->hash) &&
		    (new_fn->minor_hash == fname->minor_hash)) {
			new_fn->next = fname->next;
			fname->next = new_fn;
			return 0;
		}

		if (new_fn->hash < fname->hash)
			p = &(*p)->rb_left;
		else if (new_fn->hash > fname->hash)
			p = &(*p)->rb_right;
		else if (new_fn->minor_hash < fname->minor_hash)
			p = &(*p)->rb_left;
		else /* if (new_fn->minor_hash > fname->minor_hash) */
			p = &(*p)->rb_right;
	}

	rb_link_node(&new_fn->rb_hash, parent, p);
	rb_insert_color(&new_fn->rb_hash, &info->root);
	return 0;
}


/*
 * This is a helper function for ext4_dx_readdir.  It calls filldir
 * for all entres on the fname linked list.  (Normally there is only
 * one entry on the linked list, unless there are 62 bit hash collisions.)
 */
static int call_filldir(struct file *file, struct dir_context *ctx,
			struct fname *fname)
{
	struct dir_private_info *info = file->private_data;
	struct inode *inode = file_inode(file);
	struct super_block *sb = inode->i_sb;

	if (!fname) {
		ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: comm %s: "
			 "called with null fname?!?", __func__, __LINE__,
			 inode->i_ino, current->comm);
		return 0;
	}
	ctx->pos = hash2pos(file, fname->hash, fname->minor_hash);
	while (fname) {
		if (!dir_emit(ctx, fname->name,
				fname->name_len,
				fname->inode,
				get_dtype(sb, fname->file_type))) {
			info->extra_fname = fname;
			return 1;
		}
		fname = fname->next;
	}
	return 0;
}

static int ext4_dx_readdir(struct file *file, struct dir_context *ctx)
{
	struct dir_private_info *info = file->private_data;
	struct inode *inode = file_inode(file);
	struct fname *fname;
	int	ret;

	if (!info) {
		info = ext4_htree_create_dir_info(file, ctx->pos);
		if (!info)
			return -ENOMEM;
		file->private_data = info;
	}

	if (ctx->pos == ext4_get_htree_eof(file))
		return 0;	/* EOF */

	/* Some one has messed with f_pos; reset the world */
	if (info->last_pos != ctx->pos) {
		free_rb_tree_fname(&info->root);
		info->curr_node = NULL;
		info->extra_fname = NULL;
		info->curr_hash = pos2maj_hash(file, ctx->pos);
		info->curr_minor_hash = pos2min_hash(file, ctx->pos);
	}

	/*
	 * If there are any leftover names on the hash collision
	 * chain, return them first.
	 */
	if (info->extra_fname) {
		if (call_filldir(file, ctx, info->extra_fname))
			goto finished;
		info->extra_fname = NULL;
		goto next_node;
	} else if (!info->curr_node)
		info->curr_node = rb_first(&info->root);

	while (1) {
		/*
		 * Fill the rbtree if we have no more entries,
		 * or the inode has changed since we last read in the
		 * cached entries.
		 */
		if ((!info->curr_node) ||
		    (file->f_version != inode->i_version)) {
			info->curr_node = NULL;
			free_rb_tree_fname(&info->root);
			file->f_version = inode->i_version;
			ret = ext4_htree_fill_tree(file, info->curr_hash,
						   info->curr_minor_hash,
						   &info->next_hash);
			if (ret < 0)
				return ret;
			if (ret == 0) {
				ctx->pos = ext4_get_htree_eof(file);
				break;
			}
			info->curr_node = rb_first(&info->root);
		}

		fname = rb_entry(info->curr_node, struct fname, rb_hash);
		info->curr_hash = fname->hash;
		info->curr_minor_hash = fname->minor_hash;
		if (call_filldir(file, ctx, fname))
			break;
	next_node:
		info->curr_node = rb_next(info->curr_node);
		if (info->curr_node) {
			fname = rb_entry(info->curr_node, struct fname,
					 rb_hash);
			info->curr_hash = fname->hash;
			info->curr_minor_hash = fname->minor_hash;
		} else {
			if (info->next_hash == ~0) {
				ctx->pos = ext4_get_htree_eof(file);
				break;
			}
			info->curr_hash = info->next_hash;
			info->curr_minor_hash = 0;
		}
	}
finished:
	info->last_pos = ctx->pos;
	return 0;
}

static int ext4_release_dir(struct inode *inode, struct file *filp)
{
	if (filp->private_data)
		ext4_htree_free_dir_info(filp->private_data);

	return 0;
}

int ext4_check_all_de(struct inode *dir, struct buffer_head *bh, void *buf,
		      int buf_size)
{
	struct ext4_dir_entry_2 *de;
	int nlen, rlen;
	unsigned int offset = 0;
	char *top;

	de = (struct ext4_dir_entry_2 *)buf;
	top = buf + buf_size;
	while ((char *) de < top) {
		if (ext4_check_dir_entry(dir, NULL, de, bh,
					 buf, buf_size, offset))
			return -EIO;
		nlen = EXT4_DIR_REC_LEN(de->name_len);
		rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
		de = (struct ext4_dir_entry_2 *)((char *)de + rlen);
		offset += rlen;
	}
	if ((char *) de > top)
		return -EIO;

	return 0;
}

const struct file_operations ext4_dir_operations = {
	.llseek		= ext4_dir_llseek,
	.read		= generic_read_dir,
	.iterate	= ext4_readdir,
	.unlocked_ioctl = ext4_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= ext4_compat_ioctl,
#endif
	.fsync		= ext4_sync_file,
	.release	= ext4_release_dir,
};
Commit	Line	Data
ac27a0ec	1	/*
617ba13b	2	* linux/fs/ext4/dir.c
ac27a0ec DK	3	*
	4	* Copyright (C) 1992, 1993, 1994, 1995
	5	* Remy Card (card@masi.ibp.fr)
	6	* Laboratoire MASI - Institut Blaise Pascal
	7	* Universite Pierre et Marie Curie (Paris VI)
	8	*
	9	* from
	10	*
	11	* linux/fs/minix/dir.c
	12	*
	13	* Copyright (C) 1991, 1992 Linus Torvalds
	14	*
617ba13b	15	* ext4 directory handling functions
ac27a0ec DK	16	*
	17	* Big-endian to little-endian byte-swapping/bitmaps by
	18	* David S. Miller (davem@caip.rutgers.edu), 1995
	19	*
	20	* Hash Tree Directory indexing (c) 2001 Daniel Phillips
	21	*
	22	*/
	23
	24	#include <linux/fs.h>
ac27a0ec	25	#include <linux/buffer_head.h>
ac27a0ec	26	#include <linux/slab.h>
3dcf5451	27	#include "ext4.h"
65d165d9	28	#include "xattr.h"
ac27a0ec	29
725bebb2	30	static int ext4_dx_readdir(struct file , struct dir_context );
ac27a0ec	31
d1f5273e FY	32	/**
d1f5273e FY	33	* Check if the given dir-inode refers to an htree-indexed directory
70261f56	34	* (or a directory which could potentially get converted to use htree
d1f5273e FY	35	* indexing).
	36	*
	37	* Return 1 if it is a dx dir, 0 if not
	38	*/
	39	static int is_dx_dir(struct inode *inode)
	40	{
	41	struct super_block *sb = inode->i_sb;
	42
	43	if (EXT4_HAS_COMPAT_FEATURE(inode->i_sb,
	44	EXT4_FEATURE_COMPAT_DIR_INDEX) &&
	45	((ext4_test_inode_flag(inode, EXT4_INODE_INDEX)) \|\|
8af0f082 TM	46	((inode->i_size >> sb->s_blocksize_bits) == 1) \|\|
8af0f082 TM	47	ext4_has_inline_data(inode)))
d1f5273e FY	48	return 1;
	49
	50	return 0;
	51	}
	52
cad3f007 TT	53	/*
	54	* Return 0 if the directory entry is OK, and 1 if there is a problem
	55	*
	56	* Note: this is the opposite of what ext2 and ext3 historically returned...
65d165d9 TM	57	*
	58	* bh passed here can be an inode block or a dir data block, depending
	59	* on the inode inline data flag.
cad3f007	60	*/
60fd4da3	61	int __ext4_check_dir_entry(const char *function, unsigned int line,
f7c21177	62	struct inode dir, struct file filp,
60fd4da3	63	struct ext4_dir_entry_2 *de,
226ba972	64	struct buffer_head bh, char buf, int size,
60fd4da3	65	unsigned int offset)
ac27a0ec	66	{
af5bc92d	67	const char *error_msg = NULL;
3d0518f4 WY	68	const int rlen = ext4_rec_len_from_disk(de->rec_len,
3d0518f4 WY	69	dir->i_sb->s_blocksize);
ac27a0ec	70
cad3f007	71	if (unlikely(rlen < EXT4_DIR_REC_LEN(1)))
ac27a0ec	72	error_msg = "rec_len is smaller than minimal";
cad3f007	73	else if (unlikely(rlen % 4 != 0))
ac27a0ec	74	error_msg = "rec_len % 4 != 0";
cad3f007	75	else if (unlikely(rlen < EXT4_DIR_REC_LEN(de->name_len)))
ac27a0ec	76	error_msg = "rec_len is too small for name_len";
226ba972 TM	77	else if (unlikely(((char *) de - buf) + rlen > size))
226ba972 TM	78	error_msg = "directory entry across range";
cad3f007 TT	79	else if (unlikely(le32_to_cpu(de->inode) >
cad3f007 TT	80	le32_to_cpu(EXT4_SB(dir->i_sb)->s_es->s_inodes_count)))
ac27a0ec	81	error_msg = "inode out of bounds";
cad3f007 TT	82	else
	83	return 0;
	84
f7c21177	85	if (filp)
4fda4003	86	ext4_error_file(filp, function, line, bh->b_blocknr,
f7c21177 TT	87	"bad entry in directory: %s - offset=%u(%u), "
f7c21177 TT	88	"inode=%u, rec_len=%d, name_len=%d",
226ba972	89	error_msg, (unsigned) (offset % size),
f7c21177 TT	90	offset, le32_to_cpu(de->inode),
	91	rlen, de->name_len);
	92	else
4fda4003	93	ext4_error_inode(dir, function, line, bh->b_blocknr,
f7c21177 TT	94	"bad entry in directory: %s - offset=%u(%u), "
f7c21177 TT	95	"inode=%u, rec_len=%d, name_len=%d",
226ba972	96	error_msg, (unsigned) (offset % size),
f7c21177 TT	97	offset, le32_to_cpu(de->inode),
	98	rlen, de->name_len);
	99
cad3f007	100	return 1;
ac27a0ec DK	101	}
ac27a0ec DK	102
725bebb2	103	static int ext4_readdir(struct file file, struct dir_context ctx)
ac27a0ec	104	{
498e5f24	105	unsigned int offset;
aa13d5f6	106	int i;
617ba13b	107	struct ext4_dir_entry_2 *de;
ac27a0ec	108	int err;
725bebb2	109	struct inode *inode = file_inode(file);
d1f5273e	110	struct super_block *sb = inode->i_sb;
44614711	111	struct buffer_head *bh = NULL;
9d9f1775	112	int dir_has_error = 0;
44614711 MH	113	struct ext4_fname_crypto_ctx *enc_ctx = NULL;
44614711 MH	114	struct ext4_str fname_crypto_str = {.name = NULL, .len = 0};
ac27a0ec	115
d1f5273e	116	if (is_dx_dir(inode)) {
725bebb2	117	err = ext4_dx_readdir(file, ctx);
ac27a0ec	118	if (err != ERR_BAD_DX_DIR) {
725bebb2	119	return err;
ac27a0ec DK	120	}
	121	/*
	122	* We don't set the inode dirty flag since it's not
	123	* critical that it get flushed back to the disk.
	124	*/
725bebb2	125	ext4_clear_inode_flag(file_inode(file),
07a03824	126	EXT4_INODE_INDEX);
ac27a0ec	127	}
8af0f082 TM	128
	129	if (ext4_has_inline_data(inode)) {
	130	int has_inline_data = 1;
44614711	131	err = ext4_read_inline_dir(file, ctx,
8af0f082 TM	132	&has_inline_data);
8af0f082 TM	133	if (has_inline_data)
44614711 MH	134	return err;
	135	}
	136
	137	enc_ctx = ext4_get_fname_crypto_ctx(inode, EXT4_NAME_LEN);
	138	if (IS_ERR(enc_ctx))
	139	return PTR_ERR(enc_ctx);
	140	if (enc_ctx) {
	141	err = ext4_fname_crypto_alloc_buffer(enc_ctx, EXT4_NAME_LEN,
	142	&fname_crypto_str);
	143	if (err < 0) {
	144	ext4_put_fname_crypto_ctx(&enc_ctx);
	145	return err;
	146	}
8af0f082 TM	147	}
8af0f082 TM	148
725bebb2	149	offset = ctx->pos & (sb->s_blocksize - 1);
ac27a0ec	150
725bebb2	151	while (ctx->pos < inode->i_size) {
2ed88685	152	struct ext4_map_blocks map;
ac27a0ec	153
725bebb2	154	map.m_lblk = ctx->pos >> EXT4_BLOCK_SIZE_BITS(sb);
2ed88685 TT	155	map.m_len = 1;
2ed88685 TT	156	err = ext4_map_blocks(NULL, inode, &map, 0);
ac27a0ec	157	if (err > 0) {
2ed88685	158	pgoff_t index = map.m_pblk >>
dc7868fc	159	(PAGE_CACHE_SHIFT - inode->i_blkbits);
725bebb2	160	if (!ra_has_index(&file->f_ra, index))
cf914a7d	161	page_cache_sync_readahead(
dc7868fc	162	sb->s_bdev->bd_inode->i_mapping,
725bebb2	163	&file->f_ra, file,
cf914a7d	164	index, 1);
725bebb2	165	file->f_ra.prev_pos = (loff_t)index << PAGE_CACHE_SHIFT;
1c215028 TT	166	bh = ext4_bread(NULL, inode, map.m_lblk, 0);
	167	if (IS_ERR(bh))
	168	return PTR_ERR(bh);
ac27a0ec DK	169	}
ac27a0ec DK	170
ac27a0ec	171	if (!bh) {
9d9f1775	172	if (!dir_has_error) {
725bebb2	173	EXT4_ERROR_FILE(file, 0,
f7c21177 TT	174	"directory contains a "
f7c21177 TT	175	"hole at offset %llu",
725bebb2	176	(unsigned long long) ctx->pos);
9d9f1775 ES	177	dir_has_error = 1;
9d9f1775 ES	178	}
e6c40211	179	/* corrupt size? Maybe no more blocks to read */
725bebb2	180	if (ctx->pos > inode->i_blocks << 9)
e6c40211	181	break;
725bebb2	182	ctx->pos += sb->s_blocksize - offset;
ac27a0ec DK	183	continue;
	184	}
	185
b0336e8d DW	186	/* Check the checksum */
	187	if (!buffer_verified(bh) &&
	188	!ext4_dirent_csum_verify(inode,
	189	(struct ext4_dir_entry *)bh->b_data)) {
725bebb2	190	EXT4_ERROR_FILE(file, 0, "directory fails checksum "
b0336e8d	191	"at offset %llu",
725bebb2 AV	192	(unsigned long long)ctx->pos);
725bebb2 AV	193	ctx->pos += sb->s_blocksize - offset;
d5ac7773	194	brelse(bh);
44614711	195	bh = NULL;
b0336e8d DW	196	continue;
	197	}
	198	set_buffer_verified(bh);
	199
ac27a0ec DK	200	/* If the dir block has changed since the last call to
	201	* readdir(2), then we might be pointing to an invalid
	202	* dirent right now. Scan from the start of the block
	203	* to make sure. */
725bebb2	204	if (file->f_version != inode->i_version) {
ac27a0ec	205	for (i = 0; i < sb->s_blocksize && i < offset; ) {
617ba13b	206	de = (struct ext4_dir_entry_2 *)
ac27a0ec DK	207	(bh->b_data + i);
	208	/* It's too expensive to do a full
	209	* dirent test each time round this
	210	* loop, but we do have to test at
	211	* least that it is non-zero. A
	212	* failure will be detected in the
	213	* dirent test below. */
3d0518f4 WY	214	if (ext4_rec_len_from_disk(de->rec_len,
3d0518f4 WY	215	sb->s_blocksize) < EXT4_DIR_REC_LEN(1))
ac27a0ec	216	break;
3d0518f4 WY	217	i += ext4_rec_len_from_disk(de->rec_len,
3d0518f4 WY	218	sb->s_blocksize);
ac27a0ec DK	219	}
ac27a0ec DK	220	offset = i;
725bebb2	221	ctx->pos = (ctx->pos & ~(sb->s_blocksize - 1))
ac27a0ec	222	\| offset;
725bebb2	223	file->f_version = inode->i_version;
ac27a0ec DK	224	}
ac27a0ec DK	225
725bebb2	226	while (ctx->pos < inode->i_size
ac27a0ec	227	&& offset < sb->s_blocksize) {
617ba13b	228	de = (struct ext4_dir_entry_2 *) (bh->b_data + offset);
725bebb2	229	if (ext4_check_dir_entry(inode, file, de, bh,
226ba972 TM	230	bh->b_data, bh->b_size,
226ba972 TM	231	offset)) {
63f57933	232	/*
725bebb2	233	* On error, skip to the next block
63f57933	234	*/
725bebb2	235	ctx->pos = (ctx->pos \|
ac27a0ec	236	(sb->s_blocksize - 1)) + 1;
725bebb2	237	break;
ac27a0ec	238	}
3d0518f4 WY	239	offset += ext4_rec_len_from_disk(de->rec_len,
3d0518f4 WY	240	sb->s_blocksize);
ac27a0ec	241	if (le32_to_cpu(de->inode)) {
44614711 MH	242	if (enc_ctx == NULL) {
	243	/* Directory is not encrypted */
	244	if (!dir_emit(ctx, de->name,
	245	de->name_len,
	246	le32_to_cpu(de->inode),
	247	get_dtype(sb, de->file_type)))
	248	goto done;
	249	} else {
	250	/* Directory is encrypted */
	251	err = ext4_fname_disk_to_usr(enc_ctx,
5de0b4d0	252	NULL, de, &fname_crypto_str);
44614711 MH	253	if (err < 0)
	254	goto errout;
	255	if (!dir_emit(ctx,
	256	fname_crypto_str.name, err,
	257	le32_to_cpu(de->inode),
	258	get_dtype(sb, de->file_type)))
	259	goto done;
725bebb2	260	}
ac27a0ec	261	}
725bebb2	262	ctx->pos += ext4_rec_len_from_disk(de->rec_len,
3d0518f4	263	sb->s_blocksize);
ac27a0ec	264	}
44614711 MH	265	if ((ctx->pos < inode->i_size) && !dir_relax(inode))
44614711 MH	266	goto done;
af5bc92d	267	brelse(bh);
44614711 MH	268	bh = NULL;
44614711 MH	269	offset = 0;
ac27a0ec	270	}
44614711 MH	271	done:
	272	err = 0;
	273	errout:
	274	#ifdef CONFIG_EXT4_FS_ENCRYPTION
	275	ext4_put_fname_crypto_ctx(&enc_ctx);
	276	ext4_fname_crypto_free_buffer(&fname_crypto_str);
	277	#endif
	278	brelse(bh);
	279	return err;
ac27a0ec DK	280	}
ac27a0ec DK	281
d1f5273e FY	282	static inline int is_32bit_api(void)
	283	{
	284	#ifdef CONFIG_COMPAT
	285	return is_compat_task();
	286	#else
	287	return (BITS_PER_LONG == 32);
	288	#endif
	289	}
	290
ac27a0ec DK	291	/*
ac27a0ec DK	292	* These functions convert from the major/minor hash to an f_pos
d1f5273e FY	293	* value for dx directories
	294	*
	295	* Upper layer (for example NFS) should specify FMODE_32BITHASH or
	296	* FMODE_64BITHASH explicitly. On the other hand, we allow ext4 to be mounted
	297	* directly on both 32-bit and 64-bit nodes, under such case, neither
	298	* FMODE_32BITHASH nor FMODE_64BITHASH is specified.
	299	*/
	300	static inline loff_t hash2pos(struct file *filp, __u32 major, __u32 minor)
	301	{
	302	if ((filp->f_mode & FMODE_32BITHASH) \|\|
	303	(!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
	304	return major >> 1;
	305	else
	306	return ((__u64)(major >> 1) << 32) \| (__u64)minor;
	307	}
	308
	309	static inline __u32 pos2maj_hash(struct file *filp, loff_t pos)
	310	{
	311	if ((filp->f_mode & FMODE_32BITHASH) \|\|
	312	(!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
	313	return (pos << 1) & 0xffffffff;
	314	else
	315	return ((pos >> 32) << 1) & 0xffffffff;
	316	}
	317
	318	static inline __u32 pos2min_hash(struct file *filp, loff_t pos)
	319	{
	320	if ((filp->f_mode & FMODE_32BITHASH) \|\|
	321	(!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
	322	return 0;
	323	else
	324	return pos & 0xffffffff;
	325	}
	326
	327	/*
	328	* Return 32- or 64-bit end-of-file for dx directories
	329	*/
	330	static inline loff_t ext4_get_htree_eof(struct file *filp)
	331	{
	332	if ((filp->f_mode & FMODE_32BITHASH) \|\|
	333	(!(filp->f_mode & FMODE_64BITHASH) && is_32bit_api()))
	334	return EXT4_HTREE_EOF_32BIT;
	335	else
	336	return EXT4_HTREE_EOF_64BIT;
	337	}
	338
	339
	340	/*
ec7268ce ES	341	* ext4_dir_llseek() calls generic_file_llseek_size to handle htree
	342	* directories, where the "offset" is in terms of the filename hash
	343	* value instead of the byte offset.
ac27a0ec	344	*
ec7268ce ES	345	* Because we may return a 64-bit hash that is well beyond offset limits,
	346	* we need to pass the max hash as the maximum allowable offset in
	347	* the htree directory case.
	348	*
	349	* For non-htree, ext4_llseek already chooses the proper max offset.
ac27a0ec	350	*/
d4e43954	351	static loff_t ext4_dir_llseek(struct file *file, loff_t offset, int whence)
d1f5273e FY	352	{
d1f5273e FY	353	struct inode *inode = file->f_mapping->host;
d1f5273e	354	int dx_dir = is_dx_dir(inode);
ec7268ce	355	loff_t htree_max = ext4_get_htree_eof(file);
d1f5273e	356
ec7268ce	357	if (likely(dx_dir))
965c8e59	358	return generic_file_llseek_size(file, offset, whence,
ec7268ce ES	359	htree_max, htree_max);
ec7268ce ES	360	else
965c8e59	361	return ext4_llseek(file, offset, whence);
d1f5273e	362	}
ac27a0ec DK	363
	364	/*
	365	* This structure holds the nodes of the red-black tree used to store
	366	* the directory entry in hash order.
	367	*/
	368	struct fname {
	369	__u32 hash;
	370	__u32 minor_hash;
	371	struct rb_node rb_hash;
	372	struct fname *next;
	373	__u32 inode;
	374	__u8 name_len;
	375	__u8 file_type;
	376	char name[0];
	377	};
	378
	379	/*
	380	* This functoin implements a non-recursive way of freeing all of the
	381	* nodes in the red-black tree.
	382	*/
	383	static void free_rb_tree_fname(struct rb_root *root)
	384	{
d1866bd0 CS	385	struct fname fname, next;
	386
	387	rbtree_postorder_for_each_entry_safe(fname, next, root, rb_hash)
ac27a0ec	388	while (fname) {
af5bc92d	389	struct fname *old = fname;
ac27a0ec	390	fname = fname->next;
af5bc92d	391	kfree(old);
ac27a0ec	392	}
d1866bd0 CS	393
d1866bd0 CS	394	*root = RB_ROOT;
ac27a0ec DK	395	}
	396
	397
d1f5273e FY	398	static struct dir_private_info ext4_htree_create_dir_info(struct file filp,
d1f5273e FY	399	loff_t pos)
ac27a0ec DK	400	{
	401	struct dir_private_info *p;
	402
69baee06	403	p = kzalloc(sizeof(struct dir_private_info), GFP_KERNEL);
ac27a0ec DK	404	if (!p)
ac27a0ec DK	405	return NULL;
d1f5273e FY	406	p->curr_hash = pos2maj_hash(filp, pos);
d1f5273e FY	407	p->curr_minor_hash = pos2min_hash(filp, pos);
ac27a0ec DK	408	return p;
	409	}
	410
617ba13b	411	void ext4_htree_free_dir_info(struct dir_private_info *p)
ac27a0ec DK	412	{
	413	free_rb_tree_fname(&p->root);
	414	kfree(p);
	415	}
	416
	417	/*
	418	* Given a directory entry, enter it into the fname rb tree.
2f61830a TT	419	*
	420	* When filename encryption is enabled, the dirent will hold the
	421	* encrypted filename, while the htree will hold decrypted filename.
	422	* The decrypted filename is passed in via ent_name. parameter.
ac27a0ec	423	*/
617ba13b	424	int ext4_htree_store_dirent(struct file *dir_file, __u32 hash,
ac27a0ec	425	__u32 minor_hash,
2f61830a TT	426	struct ext4_dir_entry_2 *dirent,
2f61830a TT	427	struct ext4_str *ent_name)
ac27a0ec DK	428	{
ac27a0ec DK	429	struct rb_node *p, parent = NULL;
af5bc92d	430	struct fname fname, new_fn;
ac27a0ec DK	431	struct dir_private_info *info;
	432	int len;
	433
a271fe85	434	info = dir_file->private_data;
ac27a0ec DK	435	p = &info->root.rb_node;
	436
	437	/* Create and allocate the fname structure */
2f61830a	438	len = sizeof(struct fname) + ent_name->len + 1;
ac27a0ec DK	439	new_fn = kzalloc(len, GFP_KERNEL);
	440	if (!new_fn)
	441	return -ENOMEM;
	442	new_fn->hash = hash;
	443	new_fn->minor_hash = minor_hash;
	444	new_fn->inode = le32_to_cpu(dirent->inode);
2f61830a	445	new_fn->name_len = ent_name->len;
ac27a0ec	446	new_fn->file_type = dirent->file_type;
2f61830a TT	447	memcpy(new_fn->name, ent_name->name, ent_name->len);
2f61830a TT	448	new_fn->name[ent_name->len] = 0;
ac27a0ec DK	449
	450	while (*p) {
	451	parent = *p;
	452	fname = rb_entry(parent, struct fname, rb_hash);
	453
	454	/*
	455	* If the hash and minor hash match up, then we put
	456	* them on a linked list. This rarely happens...
	457	*/
	458	if ((new_fn->hash == fname->hash) &&
	459	(new_fn->minor_hash == fname->minor_hash)) {
	460	new_fn->next = fname->next;
	461	fname->next = new_fn;
	462	return 0;
	463	}
	464
	465	if (new_fn->hash < fname->hash)
	466	p = &(*p)->rb_left;
	467	else if (new_fn->hash > fname->hash)
	468	p = &(*p)->rb_right;
	469	else if (new_fn->minor_hash < fname->minor_hash)
	470	p = &(*p)->rb_left;
	471	else /* if (new_fn->minor_hash > fname->minor_hash) */
	472	p = &(*p)->rb_right;
	473	}
	474
	475	rb_link_node(&new_fn->rb_hash, parent, p);
	476	rb_insert_color(&new_fn->rb_hash, &info->root);
	477	return 0;
	478	}
	479
	480
	481
	482	/*
617ba13b	483	* This is a helper function for ext4_dx_readdir. It calls filldir
ac27a0ec DK	484	* for all entres on the fname linked list. (Normally there is only
	485	* one entry on the linked list, unless there are 62 bit hash collisions.)
	486	*/
725bebb2 AV	487	static int call_filldir(struct file file, struct dir_context ctx,
725bebb2 AV	488	struct fname *fname)
ac27a0ec	489	{
725bebb2 AV	490	struct dir_private_info *info = file->private_data;
	491	struct inode *inode = file_inode(file);
	492	struct super_block *sb = inode->i_sb;
ac27a0ec DK	493
ac27a0ec DK	494	if (!fname) {
92b97816 TT	495	ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: comm %s: "
	496	"called with null fname?!?", __func__, __LINE__,
	497	inode->i_ino, current->comm);
ac27a0ec DK	498	return 0;
ac27a0ec DK	499	}
725bebb2	500	ctx->pos = hash2pos(file, fname->hash, fname->minor_hash);
ac27a0ec	501	while (fname) {
725bebb2 AV	502	if (!dir_emit(ctx, fname->name,
725bebb2 AV	503	fname->name_len,
ac27a0ec	504	fname->inode,
725bebb2	505	get_dtype(sb, fname->file_type))) {
d0156417	506	info->extra_fname = fname;
725bebb2	507	return 1;
ac27a0ec DK	508	}
	509	fname = fname->next;
	510	}
	511	return 0;
	512	}
	513
725bebb2	514	static int ext4_dx_readdir(struct file file, struct dir_context ctx)
ac27a0ec	515	{
725bebb2 AV	516	struct dir_private_info *info = file->private_data;
725bebb2 AV	517	struct inode *inode = file_inode(file);
ac27a0ec DK	518	struct fname *fname;
	519	int ret;
	520
	521	if (!info) {
725bebb2	522	info = ext4_htree_create_dir_info(file, ctx->pos);
ac27a0ec DK	523	if (!info)
ac27a0ec DK	524	return -ENOMEM;
725bebb2	525	file->private_data = info;
ac27a0ec DK	526	}
ac27a0ec DK	527
725bebb2	528	if (ctx->pos == ext4_get_htree_eof(file))
ac27a0ec DK	529	return 0; /* EOF */
	530
	531	/* Some one has messed with f_pos; reset the world */
725bebb2	532	if (info->last_pos != ctx->pos) {
ac27a0ec DK	533	free_rb_tree_fname(&info->root);
	534	info->curr_node = NULL;
	535	info->extra_fname = NULL;
725bebb2 AV	536	info->curr_hash = pos2maj_hash(file, ctx->pos);
725bebb2 AV	537	info->curr_minor_hash = pos2min_hash(file, ctx->pos);
ac27a0ec DK	538	}
	539
	540	/*
	541	* If there are any leftover names on the hash collision
	542	* chain, return them first.
	543	*/
d0156417	544	if (info->extra_fname) {
725bebb2	545	if (call_filldir(file, ctx, info->extra_fname))
d0156417	546	goto finished;
d0156417	547	info->extra_fname = NULL;
3c37fc86	548	goto next_node;
d0156417	549	} else if (!info->curr_node)
ac27a0ec DK	550	info->curr_node = rb_first(&info->root);
	551
	552	while (1) {
	553	/*
	554	* Fill the rbtree if we have no more entries,
	555	* or the inode has changed since we last read in the
	556	* cached entries.
	557	*/
	558	if ((!info->curr_node) \|\|
725bebb2	559	(file->f_version != inode->i_version)) {
ac27a0ec DK	560	info->curr_node = NULL;
ac27a0ec DK	561	free_rb_tree_fname(&info->root);
725bebb2 AV	562	file->f_version = inode->i_version;
725bebb2 AV	563	ret = ext4_htree_fill_tree(file, info->curr_hash,
ac27a0ec DK	564	info->curr_minor_hash,
	565	&info->next_hash);
	566	if (ret < 0)
	567	return ret;
	568	if (ret == 0) {
725bebb2	569	ctx->pos = ext4_get_htree_eof(file);
ac27a0ec DK	570	break;
	571	}
	572	info->curr_node = rb_first(&info->root);
	573	}
	574
	575	fname = rb_entry(info->curr_node, struct fname, rb_hash);
	576	info->curr_hash = fname->hash;
	577	info->curr_minor_hash = fname->minor_hash;
725bebb2	578	if (call_filldir(file, ctx, fname))
ac27a0ec	579	break;
3c37fc86	580	next_node:
ac27a0ec	581	info->curr_node = rb_next(info->curr_node);
3c37fc86 TT	582	if (info->curr_node) {
	583	fname = rb_entry(info->curr_node, struct fname,
	584	rb_hash);
	585	info->curr_hash = fname->hash;
	586	info->curr_minor_hash = fname->minor_hash;
	587	} else {
ac27a0ec	588	if (info->next_hash == ~0) {
725bebb2	589	ctx->pos = ext4_get_htree_eof(file);
ac27a0ec DK	590	break;
	591	}
	592	info->curr_hash = info->next_hash;
	593	info->curr_minor_hash = 0;
	594	}
	595	}
	596	finished:
725bebb2	597	info->last_pos = ctx->pos;
ac27a0ec DK	598	return 0;
	599	}
	600
af5bc92d	601	static int ext4_release_dir(struct inode inode, struct file filp)
ac27a0ec	602	{
63f57933	603	if (filp->private_data)
617ba13b	604	ext4_htree_free_dir_info(filp->private_data);
ac27a0ec DK	605
	606	return 0;
	607	}
d1f5273e	608
40b163f1 DW	609	int ext4_check_all_de(struct inode dir, struct buffer_head bh, void *buf,
	610	int buf_size)
	611	{
	612	struct ext4_dir_entry_2 *de;
	613	int nlen, rlen;
	614	unsigned int offset = 0;
	615	char *top;
	616
	617	de = (struct ext4_dir_entry_2 *)buf;
	618	top = buf + buf_size;
	619	while ((char *) de < top) {
	620	if (ext4_check_dir_entry(dir, NULL, de, bh,
	621	buf, buf_size, offset))
	622	return -EIO;
	623	nlen = EXT4_DIR_REC_LEN(de->name_len);
	624	rlen = ext4_rec_len_from_disk(de->rec_len, buf_size);
	625	de = (struct ext4_dir_entry_2 )((char )de + rlen);
	626	offset += rlen;
	627	}
	628	if ((char *) de > top)
	629	return -EIO;
	630
	631	return 0;
	632	}
	633
d1f5273e FY	634	const struct file_operations ext4_dir_operations = {
	635	.llseek = ext4_dir_llseek,
	636	.read = generic_read_dir,
725bebb2	637	.iterate = ext4_readdir,
d1f5273e FY	638	.unlocked_ioctl = ext4_ioctl,
	639	#ifdef CONFIG_COMPAT
	640	.compat_ioctl = ext4_compat_ioctl,
	641	#endif
	642	.fsync = ext4_sync_file,
	643	.release = ext4_release_dir,
	644	};