[linux.git] / fs / xfs / xfs_dir2_readdir.c

/*
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
 * Copyright (c) 2013 Red Hat, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
#include "xfs_bit.h"
#include "xfs_mount.h"
#include "xfs_da_format.h"
#include "xfs_da_btree.h"
#include "xfs_inode.h"
#include "xfs_dir2.h"
#include "xfs_dir2_priv.h"
#include "xfs_error.h"
#include "xfs_trace.h"
#include "xfs_bmap.h"
#include "xfs_trans.h"

/*
 * Directory file type support functions
 */
static unsigned char xfs_dir3_filetype_table[] = {
	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK,
	DT_FIFO, DT_SOCK, DT_LNK, DT_WHT,
};

static unsigned char
xfs_dir3_get_dtype(
	struct xfs_mount	*mp,
	__uint8_t		filetype)
{
	if (!xfs_sb_version_hasftype(&mp->m_sb))
		return DT_UNKNOWN;

	if (filetype >= XFS_DIR3_FT_MAX)
		return DT_UNKNOWN;

	return xfs_dir3_filetype_table[filetype];
}

STATIC int
xfs_dir2_sf_getdents(
	struct xfs_da_args	*args,
	struct dir_context	*ctx)
{
	int			i;		/* shortform entry number */
	struct xfs_inode	*dp = args->dp;	/* incore directory inode */
	xfs_dir2_dataptr_t	off;		/* current entry's offset */
	xfs_dir2_sf_entry_t	*sfep;		/* shortform directory entry */
	xfs_dir2_sf_hdr_t	*sfp;		/* shortform structure */
	xfs_dir2_dataptr_t	dot_offset;
	xfs_dir2_dataptr_t	dotdot_offset;
	xfs_ino_t		ino;
	struct xfs_da_geometry	*geo = args->geo;

	ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
	/*
	 * Give up if the directory is way too short.
	 */
	if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
		ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
		return -EIO;
	}

	ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
	ASSERT(dp->i_df.if_u1.if_data != NULL);

	sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;

	ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->i8count));

	/*
	 * If the block number in the offset is out of range, we're done.
	 */
	if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk)
		return 0;

	/*
	 * Precalculate offsets for . and .. as we will always need them.
	 *
	 * XXX(hch): the second argument is sometimes 0 and sometimes
	 * geo->datablk
	 */
	dot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
						dp->d_ops->data_dot_offset);
	dotdot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
						dp->d_ops->data_dotdot_offset);

	/*
	 * Put . entry unless we're starting past it.
	 */
	if (ctx->pos <= dot_offset) {
		ctx->pos = dot_offset & 0x7fffffff;
		if (!dir_emit(ctx, ".", 1, dp->i_ino, DT_DIR))
			return 0;
	}

	/*
	 * Put .. entry unless we're starting past it.
	 */
	if (ctx->pos <= dotdot_offset) {
		ino = dp->d_ops->sf_get_parent_ino(sfp);
		ctx->pos = dotdot_offset & 0x7fffffff;
		if (!dir_emit(ctx, "..", 2, ino, DT_DIR))
			return 0;
	}

	/*
	 * Loop while there are more entries and put'ing works.
	 */
	sfep = xfs_dir2_sf_firstentry(sfp);
	for (i = 0; i < sfp->count; i++) {
		__uint8_t filetype;

		off = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
				xfs_dir2_sf_get_offset(sfep));

		if (ctx->pos > off) {
			sfep = dp->d_ops->sf_nextentry(sfp, sfep);
			continue;
		}

		ino = dp->d_ops->sf_get_ino(sfp, sfep);
		filetype = dp->d_ops->sf_get_ftype(sfep);
		ctx->pos = off & 0x7fffffff;
		if (!dir_emit(ctx, (char *)sfep->name, sfep->namelen, ino,
			    xfs_dir3_get_dtype(dp->i_mount, filetype)))
			return 0;
		sfep = dp->d_ops->sf_nextentry(sfp, sfep);
	}

	ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
								0x7fffffff;
	return 0;
}

/*
 * Readdir for block directories.
 */
STATIC int
xfs_dir2_block_getdents(
	struct xfs_da_args	*args,
	struct dir_context	*ctx)
{
	struct xfs_inode	*dp = args->dp;	/* incore directory inode */
	xfs_dir2_data_hdr_t	*hdr;		/* block header */
	struct xfs_buf		*bp;		/* buffer for block */
	xfs_dir2_block_tail_t	*btp;		/* block tail */
	xfs_dir2_data_entry_t	*dep;		/* block data entry */
	xfs_dir2_data_unused_t	*dup;		/* block unused entry */
	char			*endptr;	/* end of the data entries */
	int			error;		/* error return value */
	char			*ptr;		/* current data entry */
	int			wantoff;	/* starting block offset */
	xfs_off_t		cook;
	struct xfs_da_geometry	*geo = args->geo;
	int			lock_mode;

	/*
	 * If the block number in the offset is out of range, we're done.
	 */
	if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk)
		return 0;

	lock_mode = xfs_ilock_data_map_shared(dp);
	error = xfs_dir3_block_read(NULL, dp, &bp);
	xfs_iunlock(dp, lock_mode);
	if (error)
		return error;

	/*
	 * Extract the byte offset we start at from the seek pointer.
	 * We'll skip entries before this.
	 */
	wantoff = xfs_dir2_dataptr_to_off(geo, ctx->pos);
	hdr = bp->b_addr;
	xfs_dir3_data_check(dp, bp);
	/*
	 * Set up values for the loop.
	 */
	btp = xfs_dir2_block_tail_p(geo, hdr);
	ptr = (char *)dp->d_ops->data_entry_p(hdr);
	endptr = (char *)xfs_dir2_block_leaf_p(btp);

	/*
	 * Loop over the data portion of the block.
	 * Each object is a real entry (dep) or an unused one (dup).
	 */
	while (ptr < endptr) {
		__uint8_t filetype;

		dup = (xfs_dir2_data_unused_t *)ptr;
		/*
		 * Unused, skip it.
		 */
		if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
			ptr += be16_to_cpu(dup->length);
			continue;
		}

		dep = (xfs_dir2_data_entry_t *)ptr;

		/*
		 * Bump pointer for the next iteration.
		 */
		ptr += dp->d_ops->data_entsize(dep->namelen);
		/*
		 * The entry is before the desired starting point, skip it.
		 */
		if ((char *)dep - (char *)hdr < wantoff)
			continue;

		cook = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
					    (char *)dep - (char *)hdr);

		ctx->pos = cook & 0x7fffffff;
		filetype = dp->d_ops->data_get_ftype(dep);
		/*
		 * If it didn't fit, set the final offset to here & return.
		 */
		if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
			    be64_to_cpu(dep->inumber),
			    xfs_dir3_get_dtype(dp->i_mount, filetype))) {
			xfs_trans_brelse(NULL, bp);
			return 0;
		}
	}

	/*
	 * Reached the end of the block.
	 * Set the offset to a non-existent block 1 and return.
	 */
	ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
								0x7fffffff;
	xfs_trans_brelse(NULL, bp);
	return 0;
}

struct xfs_dir2_leaf_map_info {
	xfs_extlen_t	map_blocks;	/* number of fsbs in map */
	xfs_dablk_t	map_off;	/* last mapped file offset */
	int		map_size;	/* total entries in *map */
	int		map_valid;	/* valid entries in *map */
	int		nmap;		/* mappings to ask xfs_bmapi */
	xfs_dir2_db_t	curdb;		/* db for current block */
	int		ra_current;	/* number of read-ahead blks */
	int		ra_index;	/* *map index for read-ahead */
	int		ra_offset;	/* map entry offset for ra */
	int		ra_want;	/* readahead count wanted */
	struct xfs_bmbt_irec map[];	/* map vector for blocks */
};

STATIC int
xfs_dir2_leaf_readbuf(
	struct xfs_da_args	*args,
	size_t			bufsize,
	struct xfs_dir2_leaf_map_info *mip,
	xfs_dir2_off_t		*curoff,
	struct xfs_buf		**bpp)
{
	struct xfs_inode	*dp = args->dp;
	struct xfs_buf		*bp = *bpp;
	struct xfs_bmbt_irec	*map = mip->map;
	struct blk_plug		plug;
	int			error = 0;
	int			length;
	int			i;
	int			j;
	struct xfs_da_geometry	*geo = args->geo;

	/*
	 * If we have a buffer, we need to release it and
	 * take it out of the mapping.
	 */

	if (bp) {
		xfs_trans_brelse(NULL, bp);
		bp = NULL;
		mip->map_blocks -= geo->fsbcount;
		/*
		 * Loop to get rid of the extents for the
		 * directory block.
		 */
		for (i = geo->fsbcount; i > 0; ) {
			j = min_t(int, map->br_blockcount, i);
			map->br_blockcount -= j;
			map->br_startblock += j;
			map->br_startoff += j;
			/*
			 * If mapping is done, pitch it from
			 * the table.
			 */
			if (!map->br_blockcount && --mip->map_valid)
				memmove(&map[0], &map[1],
					sizeof(map[0]) * mip->map_valid);
			i -= j;
		}
	}

	/*
	 * Recalculate the readahead blocks wanted.
	 */
	mip->ra_want = howmany(bufsize + geo->blksize, (1 << geo->fsblog)) - 1;
	ASSERT(mip->ra_want >= 0);

	/*
	 * If we don't have as many as we want, and we haven't
	 * run out of data blocks, get some more mappings.
	 */
	if (1 + mip->ra_want > mip->map_blocks &&
	    mip->map_off < xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET)) {
		/*
		 * Get more bmaps, fill in after the ones
		 * we already have in the table.
		 */
		mip->nmap = mip->map_size - mip->map_valid;
		error = xfs_bmapi_read(dp, mip->map_off,
				xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET) -
								mip->map_off,
				&map[mip->map_valid], &mip->nmap, 0);

		/*
		 * Don't know if we should ignore this or try to return an
		 * error.  The trouble with returning errors is that readdir
		 * will just stop without actually passing the error through.
		 */
		if (error)
			goto out;	/* XXX */

		/*
		 * If we got all the mappings we asked for, set the final map
		 * offset based on the last bmap value received.  Otherwise,
		 * we've reached the end.
		 */
		if (mip->nmap == mip->map_size - mip->map_valid) {
			i = mip->map_valid + mip->nmap - 1;
			mip->map_off = map[i].br_startoff + map[i].br_blockcount;
		} else
			mip->map_off = xfs_dir2_byte_to_da(geo,
							XFS_DIR2_LEAF_OFFSET);

		/*
		 * Look for holes in the mapping, and eliminate them.  Count up
		 * the valid blocks.
		 */
		for (i = mip->map_valid; i < mip->map_valid + mip->nmap; ) {
			if (map[i].br_startblock == HOLESTARTBLOCK) {
				mip->nmap--;
				length = mip->map_valid + mip->nmap - i;
				if (length)
					memmove(&map[i], &map[i + 1],
						sizeof(map[i]) * length);
			} else {
				mip->map_blocks += map[i].br_blockcount;
				i++;
			}
		}
		mip->map_valid += mip->nmap;
	}

	/*
	 * No valid mappings, so no more data blocks.
	 */
	if (!mip->map_valid) {
		*curoff = xfs_dir2_da_to_byte(geo, mip->map_off);
		goto out;
	}

	/*
	 * Read the directory block starting at the first mapping.
	 */
	mip->curdb = xfs_dir2_da_to_db(geo, map->br_startoff);
	error = xfs_dir3_data_read(NULL, dp, map->br_startoff,
			map->br_blockcount >= geo->fsbcount ?
			    XFS_FSB_TO_DADDR(dp->i_mount, map->br_startblock) :
			    -1, &bp);
	/*
	 * Should just skip over the data block instead of giving up.
	 */
	if (error)
		goto out;	/* XXX */

	/*
	 * Adjust the current amount of read-ahead: we just read a block that
	 * was previously ra.
	 */
	if (mip->ra_current)
		mip->ra_current -= geo->fsbcount;

	/*
	 * Do we need more readahead?
	 */
	blk_start_plug(&plug);
	for (mip->ra_index = mip->ra_offset = i = 0;
	     mip->ra_want > mip->ra_current && i < mip->map_blocks;
	     i += geo->fsbcount) {
		ASSERT(mip->ra_index < mip->map_valid);
		/*
		 * Read-ahead a contiguous directory block.
		 */
		if (i > mip->ra_current &&
		    map[mip->ra_index].br_blockcount >= geo->fsbcount) {
			xfs_dir3_data_readahead(dp,
				map[mip->ra_index].br_startoff + mip->ra_offset,
				XFS_FSB_TO_DADDR(dp->i_mount,
					map[mip->ra_index].br_startblock +
							mip->ra_offset));
			mip->ra_current = i;
		}

		/*
		 * Read-ahead a non-contiguous directory block.  This doesn't
		 * use our mapping, but this is a very rare case.
		 */
		else if (i > mip->ra_current) {
			xfs_dir3_data_readahead(dp,
					map[mip->ra_index].br_startoff +
							mip->ra_offset, -1);
			mip->ra_current = i;
		}

		/*
		 * Advance offset through the mapping table.
		 */
		for (j = 0; j < geo->fsbcount; j += length ) {
			/*
			 * The rest of this extent but not more than a dir
			 * block.
			 */
			length = min_t(int, geo->fsbcount,
					map[mip->ra_index].br_blockcount -
							mip->ra_offset);
			mip->ra_offset += length;

			/*
			 * Advance to the next mapping if this one is used up.
			 */
			if (mip->ra_offset == map[mip->ra_index].br_blockcount) {
				mip->ra_offset = 0;
				mip->ra_index++;
			}
		}
	}
	blk_finish_plug(&plug);

out:
	*bpp = bp;
	return error;
}

/*
 * Getdents (readdir) for leaf and node directories.
 * This reads the data blocks only, so is the same for both forms.
 */
STATIC int
xfs_dir2_leaf_getdents(
	struct xfs_da_args	*args,
	struct dir_context	*ctx,
	size_t			bufsize)
{
	struct xfs_inode	*dp = args->dp;
	struct xfs_buf		*bp = NULL;	/* data block buffer */
	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
	xfs_dir2_data_entry_t	*dep;		/* data entry */
	xfs_dir2_data_unused_t	*dup;		/* unused entry */
	int			error = 0;	/* error return value */
	int			length;		/* temporary length value */
	int			byteoff;	/* offset in current block */
	xfs_dir2_off_t		curoff;		/* current overall offset */
	xfs_dir2_off_t		newoff;		/* new curoff after new blk */
	char			*ptr = NULL;	/* pointer to current data */
	struct xfs_dir2_leaf_map_info *map_info;
	struct xfs_da_geometry	*geo = args->geo;

	/*
	 * If the offset is at or past the largest allowed value,
	 * give up right away.
	 */
	if (ctx->pos >= XFS_DIR2_MAX_DATAPTR)
		return 0;

	/*
	 * Set up to bmap a number of blocks based on the caller's
	 * buffer size, the directory block size, and the filesystem
	 * block size.
	 */
	length = howmany(bufsize + geo->blksize, (1 << geo->fsblog));
	map_info = kmem_zalloc(offsetof(struct xfs_dir2_leaf_map_info, map) +
				(length * sizeof(struct xfs_bmbt_irec)),
			       KM_SLEEP | KM_NOFS);
	map_info->map_size = length;

	/*
	 * Inside the loop we keep the main offset value as a byte offset
	 * in the directory file.
	 */
	curoff = xfs_dir2_dataptr_to_byte(ctx->pos);

	/*
	 * Force this conversion through db so we truncate the offset
	 * down to get the start of the data block.
	 */
	map_info->map_off = xfs_dir2_db_to_da(geo,
					      xfs_dir2_byte_to_db(geo, curoff));

	/*
	 * Loop over directory entries until we reach the end offset.
	 * Get more blocks and readahead as necessary.
	 */
	while (curoff < XFS_DIR2_LEAF_OFFSET) {
		__uint8_t filetype;

		/*
		 * If we have no buffer, or we're off the end of the
		 * current buffer, need to get another one.
		 */
		if (!bp || ptr >= (char *)bp->b_addr + geo->blksize) {
			int	lock_mode;

			lock_mode = xfs_ilock_data_map_shared(dp);
			error = xfs_dir2_leaf_readbuf(args, bufsize, map_info,
						      &curoff, &bp);
			xfs_iunlock(dp, lock_mode);
			if (error || !map_info->map_valid)
				break;

			/*
			 * Having done a read, we need to set a new offset.
			 */
			newoff = xfs_dir2_db_off_to_byte(geo,
							 map_info->curdb, 0);
			/*
			 * Start of the current block.
			 */
			if (curoff < newoff)
				curoff = newoff;
			/*
			 * Make sure we're in the right block.
			 */
			else if (curoff > newoff)
				ASSERT(xfs_dir2_byte_to_db(geo, curoff) ==
				       map_info->curdb);
			hdr = bp->b_addr;
			xfs_dir3_data_check(dp, bp);
			/*
			 * Find our position in the block.
			 */
			ptr = (char *)dp->d_ops->data_entry_p(hdr);
			byteoff = xfs_dir2_byte_to_off(geo, curoff);
			/*
			 * Skip past the header.
			 */
			if (byteoff == 0)
				curoff += dp->d_ops->data_entry_offset;
			/*
			 * Skip past entries until we reach our offset.
			 */
			else {
				while ((char *)ptr - (char *)hdr < byteoff) {
					dup = (xfs_dir2_data_unused_t *)ptr;

					if (be16_to_cpu(dup->freetag)
						  == XFS_DIR2_DATA_FREE_TAG) {

						length = be16_to_cpu(dup->length);
						ptr += length;
						continue;
					}
					dep = (xfs_dir2_data_entry_t *)ptr;
					length =
					   dp->d_ops->data_entsize(dep->namelen);
					ptr += length;
				}
				/*
				 * Now set our real offset.
				 */
				curoff =
					xfs_dir2_db_off_to_byte(geo,
					    xfs_dir2_byte_to_db(geo, curoff),
					    (char *)ptr - (char *)hdr);
				if (ptr >= (char *)hdr + geo->blksize) {
					continue;
				}
			}
		}
		/*
		 * We have a pointer to an entry.
		 * Is it a live one?
		 */
		dup = (xfs_dir2_data_unused_t *)ptr;
		/*
		 * No, it's unused, skip over it.
		 */
		if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
			length = be16_to_cpu(dup->length);
			ptr += length;
			curoff += length;
			continue;
		}

		dep = (xfs_dir2_data_entry_t *)ptr;
		length = dp->d_ops->data_entsize(dep->namelen);
		filetype = dp->d_ops->data_get_ftype(dep);

		ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
		if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
			    be64_to_cpu(dep->inumber),
			    xfs_dir3_get_dtype(dp->i_mount, filetype)))
			break;

		/*
		 * Advance to next entry in the block.
		 */
		ptr += length;
		curoff += length;
		/* bufsize may have just been a guess; don't go negative */
		bufsize = bufsize > length ? bufsize - length : 0;
	}

	/*
	 * All done.  Set output offset value to current offset.
	 */
	if (curoff > xfs_dir2_dataptr_to_byte(XFS_DIR2_MAX_DATAPTR))
		ctx->pos = XFS_DIR2_MAX_DATAPTR & 0x7fffffff;
	else
		ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
	kmem_free(map_info);
	if (bp)
		xfs_trans_brelse(NULL, bp);
	return error;
}

/*
 * Read a directory.
 */
int
xfs_readdir(
	struct xfs_inode	*dp,
	struct dir_context	*ctx,
	size_t			bufsize)
{
	struct xfs_da_args	args = { NULL };
	int			rval;
	int			v;

	trace_xfs_readdir(dp);

	if (XFS_FORCED_SHUTDOWN(dp->i_mount))
		return -EIO;

	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
	XFS_STATS_INC(dp->i_mount, xs_dir_getdents);

	args.dp = dp;
	args.geo = dp->i_mount->m_dir_geo;

	xfs_ilock(dp, XFS_IOLOCK_SHARED);
	if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
		rval = xfs_dir2_sf_getdents(&args, ctx);
	else if ((rval = xfs_dir2_isblock(&args, &v)))
		;
	else if (v)
		rval = xfs_dir2_block_getdents(&args, ctx);
	else
		rval = xfs_dir2_leaf_getdents(&args, ctx, bufsize);
	xfs_iunlock(dp, XFS_IOLOCK_SHARED);

	return rval;
}
Commit	Line	Data
4a8af273 DC	1	/*
	2	* Copyright (c) 2000-2005 Silicon Graphics, Inc.
	3	* Copyright (c) 2013 Red Hat, Inc.
	4	* All Rights Reserved.
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License as
	8	* published by the Free Software Foundation.
	9	*
	10	* This program is distributed in the hope that it would be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write the Free Software Foundation,
	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18	*/
	19	#include "xfs.h"
	20	#include "xfs_fs.h"
a4fbe6ab	21	#include "xfs_format.h"
239880ef DC	22	#include "xfs_log_format.h"
239880ef DC	23	#include "xfs_trans_resv.h"
4a8af273	24	#include "xfs_bit.h"
4a8af273	25	#include "xfs_mount.h"
57062787	26	#include "xfs_da_format.h"
4a8af273	27	#include "xfs_da_btree.h"
4a8af273	28	#include "xfs_inode.h"
2b9ab5ab	29	#include "xfs_dir2.h"
4a8af273 DC	30	#include "xfs_dir2_priv.h"
	31	#include "xfs_error.h"
	32	#include "xfs_trace.h"
	33	#include "xfs_bmap.h"
239880ef	34	#include "xfs_trans.h"
4a8af273	35
0cb97766 DC	36	/*
	37	* Directory file type support functions
	38	*/
	39	static unsigned char xfs_dir3_filetype_table[] = {
	40	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK,
	41	DT_FIFO, DT_SOCK, DT_LNK, DT_WHT,
	42	};
	43
1b767ee3	44	static unsigned char
0cb97766 DC	45	xfs_dir3_get_dtype(
	46	struct xfs_mount *mp,
	47	__uint8_t filetype)
	48	{
	49	if (!xfs_sb_version_hasftype(&mp->m_sb))
	50	return DT_UNKNOWN;
	51
	52	if (filetype >= XFS_DIR3_FT_MAX)
	53	return DT_UNKNOWN;
	54
	55	return xfs_dir3_filetype_table[filetype];
	56	}
0cb97766	57
4a8af273 DC	58	STATIC int
4a8af273 DC	59	xfs_dir2_sf_getdents(
53f82db0	60	struct xfs_da_args *args,
4a8af273 DC	61	struct dir_context *ctx)
	62	{
	63	int i; /* shortform entry number */
53f82db0	64	struct xfs_inode dp = args->dp; / incore directory inode */
4a8af273 DC	65	xfs_dir2_dataptr_t off; /* current entry's offset */
	66	xfs_dir2_sf_entry_t sfep; / shortform directory entry */
	67	xfs_dir2_sf_hdr_t sfp; / shortform structure */
	68	xfs_dir2_dataptr_t dot_offset;
	69	xfs_dir2_dataptr_t dotdot_offset;
	70	xfs_ino_t ino;
53f82db0	71	struct xfs_da_geometry *geo = args->geo;
4a8af273 DC	72
	73	ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
	74	/*
	75	* Give up if the directory is way too short.
	76	*/
	77	if (dp->i_d.di_size < offsetof(xfs_dir2_sf_hdr_t, parent)) {
53f82db0	78	ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
2451337d	79	return -EIO;
4a8af273 DC	80	}
	81
	82	ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
	83	ASSERT(dp->i_df.if_u1.if_data != NULL);
	84
	85	sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
	86
	87	ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->i8count));
	88
	89	/*
	90	* If the block number in the offset is out of range, we're done.
	91	*/
7dda6e86	92	if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk)
4a8af273 DC	93	return 0;
	94
	95	/*
	96	* Precalculate offsets for . and .. as we will always need them.
	97	*
	98	* XXX(hch): the second argument is sometimes 0 and sometimes
7dda6e86	99	* geo->datablk
4a8af273	100	*/
7dda6e86	101	dot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
1c9a5b2e	102	dp->d_ops->data_dot_offset);
7dda6e86	103	dotdot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
1c9a5b2e	104	dp->d_ops->data_dotdot_offset);
4a8af273 DC	105
	106	/*
	107	* Put . entry unless we're starting past it.
	108	*/
	109	if (ctx->pos <= dot_offset) {
	110	ctx->pos = dot_offset & 0x7fffffff;
	111	if (!dir_emit(ctx, ".", 1, dp->i_ino, DT_DIR))
	112	return 0;
	113	}
	114
	115	/*
	116	* Put .. entry unless we're starting past it.
	117	*/
	118	if (ctx->pos <= dotdot_offset) {
4740175e	119	ino = dp->d_ops->sf_get_parent_ino(sfp);
4a8af273 DC	120	ctx->pos = dotdot_offset & 0x7fffffff;
	121	if (!dir_emit(ctx, "..", 2, ino, DT_DIR))
	122	return 0;
	123	}
	124
	125	/*
	126	* Loop while there are more entries and put'ing works.
	127	*/
	128	sfep = xfs_dir2_sf_firstentry(sfp);
	129	for (i = 0; i < sfp->count; i++) {
0cb97766 DC	130	__uint8_t filetype;
0cb97766 DC	131
7dda6e86	132	off = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
4a8af273 DC	133	xfs_dir2_sf_get_offset(sfep));
	134
	135	if (ctx->pos > off) {
32c5483a	136	sfep = dp->d_ops->sf_nextentry(sfp, sfep);
4a8af273 DC	137	continue;
	138	}
	139
4740175e DC	140	ino = dp->d_ops->sf_get_ino(sfp, sfep);
4740175e DC	141	filetype = dp->d_ops->sf_get_ftype(sfep);
4a8af273	142	ctx->pos = off & 0x7fffffff;
0cb97766	143	if (!dir_emit(ctx, (char *)sfep->name, sfep->namelen, ino,
53f82db0	144	xfs_dir3_get_dtype(dp->i_mount, filetype)))
4a8af273	145	return 0;
32c5483a	146	sfep = dp->d_ops->sf_nextentry(sfp, sfep);
4a8af273 DC	147	}
4a8af273 DC	148
7dda6e86	149	ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
53f82db0	150	0x7fffffff;
4a8af273 DC	151	return 0;
	152	}
	153
	154	/*
	155	* Readdir for block directories.
	156	*/
	157	STATIC int
	158	xfs_dir2_block_getdents(
53f82db0	159	struct xfs_da_args *args,
4a8af273 DC	160	struct dir_context *ctx)
4a8af273 DC	161	{
53f82db0	162	struct xfs_inode dp = args->dp; / incore directory inode */
4a8af273 DC	163	xfs_dir2_data_hdr_t hdr; / block header */
	164	struct xfs_buf bp; / buffer for block */
	165	xfs_dir2_block_tail_t btp; / block tail */
	166	xfs_dir2_data_entry_t dep; / block data entry */
	167	xfs_dir2_data_unused_t dup; / block unused entry */
	168	char endptr; / end of the data entries */
	169	int error; /* error return value */
4a8af273 DC	170	char ptr; / current data entry */
	171	int wantoff; /* starting block offset */
	172	xfs_off_t cook;
53f82db0	173	struct xfs_da_geometry *geo = args->geo;
dbad7c99	174	int lock_mode;
4a8af273	175
4a8af273 DC	176	/*
	177	* If the block number in the offset is out of range, we're done.
	178	*/
7dda6e86	179	if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk)
4a8af273 DC	180	return 0;
4a8af273 DC	181
dbad7c99	182	lock_mode = xfs_ilock_data_map_shared(dp);
4a8af273	183	error = xfs_dir3_block_read(NULL, dp, &bp);
dbad7c99	184	xfs_iunlock(dp, lock_mode);
4a8af273 DC	185	if (error)
	186	return error;
	187
	188	/*
	189	* Extract the byte offset we start at from the seek pointer.
	190	* We'll skip entries before this.
	191	*/
30028030	192	wantoff = xfs_dir2_dataptr_to_off(geo, ctx->pos);
4a8af273 DC	193	hdr = bp->b_addr;
	194	xfs_dir3_data_check(dp, bp);
	195	/*
	196	* Set up values for the loop.
	197	*/
8f66193c	198	btp = xfs_dir2_block_tail_p(geo, hdr);
2ca98774	199	ptr = (char *)dp->d_ops->data_entry_p(hdr);
4a8af273 DC	200	endptr = (char *)xfs_dir2_block_leaf_p(btp);
	201
	202	/*
	203	* Loop over the data portion of the block.
	204	* Each object is a real entry (dep) or an unused one (dup).
	205	*/
	206	while (ptr < endptr) {
0cb97766 DC	207	__uint8_t filetype;
0cb97766 DC	208
4a8af273 DC	209	dup = (xfs_dir2_data_unused_t *)ptr;
	210	/*
	211	* Unused, skip it.
	212	*/
	213	if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
	214	ptr += be16_to_cpu(dup->length);
	215	continue;
	216	}
	217
	218	dep = (xfs_dir2_data_entry_t *)ptr;
	219
	220	/*
	221	* Bump pointer for the next iteration.
	222	*/
9d23fc85	223	ptr += dp->d_ops->data_entsize(dep->namelen);
4a8af273 DC	224	/*
	225	* The entry is before the desired starting point, skip it.
	226	*/
	227	if ((char )dep - (char )hdr < wantoff)
	228	continue;
	229
7dda6e86	230	cook = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
4a8af273 DC	231	(char )dep - (char )hdr);
	232
	233	ctx->pos = cook & 0x7fffffff;
9d23fc85	234	filetype = dp->d_ops->data_get_ftype(dep);
4a8af273 DC	235	/*
	236	* If it didn't fit, set the final offset to here & return.
	237	*/
	238	if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
0cb97766	239	be64_to_cpu(dep->inumber),
53f82db0	240	xfs_dir3_get_dtype(dp->i_mount, filetype))) {
4a8af273 DC	241	xfs_trans_brelse(NULL, bp);
	242	return 0;
	243	}
	244	}
	245
	246	/*
	247	* Reached the end of the block.
	248	* Set the offset to a non-existent block 1 and return.
	249	*/
7dda6e86	250	ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
53f82db0	251	0x7fffffff;
4a8af273 DC	252	xfs_trans_brelse(NULL, bp);
	253	return 0;
	254	}
	255
	256	struct xfs_dir2_leaf_map_info {
	257	xfs_extlen_t map_blocks; /* number of fsbs in map */
	258	xfs_dablk_t map_off; /* last mapped file offset */
	259	int map_size; /* total entries in map /
	260	int map_valid; /* valid entries in map /
	261	int nmap; /* mappings to ask xfs_bmapi */
	262	xfs_dir2_db_t curdb; /* db for current block */
	263	int ra_current; /* number of read-ahead blks */
	264	int ra_index; /* map index for read-ahead /
	265	int ra_offset; /* map entry offset for ra */
	266	int ra_want; /* readahead count wanted */
	267	struct xfs_bmbt_irec map[]; /* map vector for blocks */
	268	};
	269
	270	STATIC int
	271	xfs_dir2_leaf_readbuf(
53f82db0	272	struct xfs_da_args *args,
4a8af273 DC	273	size_t bufsize,
	274	struct xfs_dir2_leaf_map_info *mip,
	275	xfs_dir2_off_t *curoff,
	276	struct xfs_buf **bpp)
	277	{
53f82db0	278	struct xfs_inode *dp = args->dp;
4a8af273 DC	279	struct xfs_buf bp = bpp;
	280	struct xfs_bmbt_irec *map = mip->map;
	281	struct blk_plug plug;
	282	int error = 0;
	283	int length;
	284	int i;
	285	int j;
53f82db0	286	struct xfs_da_geometry *geo = args->geo;
4a8af273 DC	287
	288	/*
	289	* If we have a buffer, we need to release it and
	290	* take it out of the mapping.
	291	*/
	292
	293	if (bp) {
	294	xfs_trans_brelse(NULL, bp);
	295	bp = NULL;
d6cf1305	296	mip->map_blocks -= geo->fsbcount;
4a8af273 DC	297	/*
	298	* Loop to get rid of the extents for the
	299	* directory block.
	300	*/
d6cf1305	301	for (i = geo->fsbcount; i > 0; ) {
4a8af273 DC	302	j = min_t(int, map->br_blockcount, i);
	303	map->br_blockcount -= j;
	304	map->br_startblock += j;
	305	map->br_startoff += j;
	306	/*
	307	* If mapping is done, pitch it from
	308	* the table.
	309	*/
	310	if (!map->br_blockcount && --mip->map_valid)
	311	memmove(&map[0], &map[1],
	312	sizeof(map[0]) * mip->map_valid);
	313	i -= j;
	314	}
	315	}
	316
	317	/*
	318	* Recalculate the readahead blocks wanted.
	319	*/
53f82db0	320	mip->ra_want = howmany(bufsize + geo->blksize, (1 << geo->fsblog)) - 1;
4a8af273 DC	321	ASSERT(mip->ra_want >= 0);
	322
	323	/*
	324	* If we don't have as many as we want, and we haven't
	325	* run out of data blocks, get some more mappings.
	326	*/
	327	if (1 + mip->ra_want > mip->map_blocks &&
30028030	328	mip->map_off < xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET)) {
4a8af273 DC	329	/*
	330	* Get more bmaps, fill in after the ones
	331	* we already have in the table.
	332	*/
	333	mip->nmap = mip->map_size - mip->map_valid;
	334	error = xfs_bmapi_read(dp, mip->map_off,
30028030	335	xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET) -
4a8af273 DC	336	mip->map_off,
	337	&map[mip->map_valid], &mip->nmap, 0);
	338
	339	/*
	340	* Don't know if we should ignore this or try to return an
	341	* error. The trouble with returning errors is that readdir
	342	* will just stop without actually passing the error through.
	343	*/
	344	if (error)
	345	goto out; /* XXX */
	346
	347	/*
	348	* If we got all the mappings we asked for, set the final map
	349	* offset based on the last bmap value received. Otherwise,
	350	* we've reached the end.
	351	*/
	352	if (mip->nmap == mip->map_size - mip->map_valid) {
	353	i = mip->map_valid + mip->nmap - 1;
	354	mip->map_off = map[i].br_startoff + map[i].br_blockcount;
	355	} else
30028030	356	mip->map_off = xfs_dir2_byte_to_da(geo,
4a8af273 DC	357	XFS_DIR2_LEAF_OFFSET);
	358
	359	/*
	360	* Look for holes in the mapping, and eliminate them. Count up
	361	* the valid blocks.
	362	*/
	363	for (i = mip->map_valid; i < mip->map_valid + mip->nmap; ) {
	364	if (map[i].br_startblock == HOLESTARTBLOCK) {
	365	mip->nmap--;
	366	length = mip->map_valid + mip->nmap - i;
	367	if (length)
	368	memmove(&map[i], &map[i + 1],
	369	sizeof(map[i]) * length);
	370	} else {
	371	mip->map_blocks += map[i].br_blockcount;
	372	i++;
	373	}
	374	}
	375	mip->map_valid += mip->nmap;
	376	}
	377
	378	/*
	379	* No valid mappings, so no more data blocks.
	380	*/
	381	if (!mip->map_valid) {
30028030	382	*curoff = xfs_dir2_da_to_byte(geo, mip->map_off);
4a8af273 DC	383	goto out;
	384	}
	385
	386	/*
	387	* Read the directory block starting at the first mapping.
	388	*/
30028030	389	mip->curdb = xfs_dir2_da_to_db(geo, map->br_startoff);
4a8af273	390	error = xfs_dir3_data_read(NULL, dp, map->br_startoff,
d6cf1305	391	map->br_blockcount >= geo->fsbcount ?
53f82db0 DC	392	XFS_FSB_TO_DADDR(dp->i_mount, map->br_startblock) :
53f82db0 DC	393	-1, &bp);
4a8af273 DC	394	/*
	395	* Should just skip over the data block instead of giving up.
	396	*/
	397	if (error)
	398	goto out; /* XXX */
	399
	400	/*
	401	* Adjust the current amount of read-ahead: we just read a block that
	402	* was previously ra.
	403	*/
	404	if (mip->ra_current)
d6cf1305	405	mip->ra_current -= geo->fsbcount;
4a8af273 DC	406
	407	/*
	408	* Do we need more readahead?
	409	*/
	410	blk_start_plug(&plug);
	411	for (mip->ra_index = mip->ra_offset = i = 0;
	412	mip->ra_want > mip->ra_current && i < mip->map_blocks;
d6cf1305	413	i += geo->fsbcount) {
4a8af273 DC	414	ASSERT(mip->ra_index < mip->map_valid);
	415	/*
	416	* Read-ahead a contiguous directory block.
	417	*/
	418	if (i > mip->ra_current &&
d6cf1305	419	map[mip->ra_index].br_blockcount >= geo->fsbcount) {
9df2dd0b	420	xfs_dir3_data_readahead(dp,
4a8af273	421	map[mip->ra_index].br_startoff + mip->ra_offset,
53f82db0	422	XFS_FSB_TO_DADDR(dp->i_mount,
4a8af273 DC	423	map[mip->ra_index].br_startblock +
	424	mip->ra_offset));
	425	mip->ra_current = i;
	426	}
	427
	428	/*
	429	* Read-ahead a non-contiguous directory block. This doesn't
	430	* use our mapping, but this is a very rare case.
	431	*/
	432	else if (i > mip->ra_current) {
9df2dd0b	433	xfs_dir3_data_readahead(dp,
4a8af273 DC	434	map[mip->ra_index].br_startoff +
	435	mip->ra_offset, -1);
	436	mip->ra_current = i;
	437	}
	438
	439	/*
	440	* Advance offset through the mapping table.
	441	*/
d6cf1305	442	for (j = 0; j < geo->fsbcount; j += length ) {
4a8af273 DC	443	/*
	444	* The rest of this extent but not more than a dir
	445	* block.
	446	*/
d6cf1305	447	length = min_t(int, geo->fsbcount,
4a8af273 DC	448	map[mip->ra_index].br_blockcount -
4a8af273 DC	449	mip->ra_offset);
4a8af273 DC	450	mip->ra_offset += length;
	451
	452	/*
	453	* Advance to the next mapping if this one is used up.
	454	*/
	455	if (mip->ra_offset == map[mip->ra_index].br_blockcount) {
	456	mip->ra_offset = 0;
	457	mip->ra_index++;
	458	}
	459	}
	460	}
	461	blk_finish_plug(&plug);
	462
	463	out:
	464	*bpp = bp;
	465	return error;
	466	}
	467
	468	/*
	469	* Getdents (readdir) for leaf and node directories.
	470	* This reads the data blocks only, so is the same for both forms.
	471	*/
	472	STATIC int
	473	xfs_dir2_leaf_getdents(
53f82db0	474	struct xfs_da_args *args,
4a8af273 DC	475	struct dir_context *ctx,
	476	size_t bufsize)
	477	{
53f82db0	478	struct xfs_inode *dp = args->dp;
4a8af273 DC	479	struct xfs_buf bp = NULL; / data block buffer */
	480	xfs_dir2_data_hdr_t hdr; / data block header */
	481	xfs_dir2_data_entry_t dep; / data entry */
	482	xfs_dir2_data_unused_t dup; / unused entry */
	483	int error = 0; /* error return value */
	484	int length; /* temporary length value */
4a8af273 DC	485	int byteoff; /* offset in current block */
	486	xfs_dir2_off_t curoff; /* current overall offset */
	487	xfs_dir2_off_t newoff; /* new curoff after new blk */
	488	char ptr = NULL; / pointer to current data */
	489	struct xfs_dir2_leaf_map_info *map_info;
53f82db0	490	struct xfs_da_geometry *geo = args->geo;
4a8af273 DC	491
	492	/*
	493	* If the offset is at or past the largest allowed value,
	494	* give up right away.
	495	*/
	496	if (ctx->pos >= XFS_DIR2_MAX_DATAPTR)
	497	return 0;
	498
4a8af273 DC	499	/*
	500	* Set up to bmap a number of blocks based on the caller's
	501	* buffer size, the directory block size, and the filesystem
	502	* block size.
	503	*/
53f82db0	504	length = howmany(bufsize + geo->blksize, (1 << geo->fsblog));
4a8af273 DC	505	map_info = kmem_zalloc(offsetof(struct xfs_dir2_leaf_map_info, map) +
	506	(length * sizeof(struct xfs_bmbt_irec)),
	507	KM_SLEEP \| KM_NOFS);
	508	map_info->map_size = length;
	509
	510	/*
	511	* Inside the loop we keep the main offset value as a byte offset
	512	* in the directory file.
	513	*/
25994053	514	curoff = xfs_dir2_dataptr_to_byte(ctx->pos);
4a8af273 DC	515
	516	/*
	517	* Force this conversion through db so we truncate the offset
	518	* down to get the start of the data block.
	519	*/
30028030 DC	520	map_info->map_off = xfs_dir2_db_to_da(geo,
30028030 DC	521	xfs_dir2_byte_to_db(geo, curoff));
4a8af273 DC	522
	523	/*
	524	* Loop over directory entries until we reach the end offset.
	525	* Get more blocks and readahead as necessary.
	526	*/
	527	while (curoff < XFS_DIR2_LEAF_OFFSET) {
0cb97766 DC	528	__uint8_t filetype;
0cb97766 DC	529
4a8af273 DC	530	/*
	531	* If we have no buffer, or we're off the end of the
	532	* current buffer, need to get another one.
	533	*/
8f66193c	534	if (!bp \|\| ptr >= (char *)bp->b_addr + geo->blksize) {
dbad7c99	535	int lock_mode;
4a8af273	536
dbad7c99	537	lock_mode = xfs_ilock_data_map_shared(dp);
53f82db0	538	error = xfs_dir2_leaf_readbuf(args, bufsize, map_info,
4a8af273	539	&curoff, &bp);
dbad7c99	540	xfs_iunlock(dp, lock_mode);
4a8af273 DC	541	if (error \|\| !map_info->map_valid)
	542	break;
	543
	544	/*
	545	* Having done a read, we need to set a new offset.
	546	*/
53f82db0	547	newoff = xfs_dir2_db_off_to_byte(geo,
9b3b5522	548	map_info->curdb, 0);
4a8af273 DC	549	/*
	550	* Start of the current block.
	551	*/
	552	if (curoff < newoff)
	553	curoff = newoff;
	554	/*
	555	* Make sure we're in the right block.
	556	*/
	557	else if (curoff > newoff)
30028030	558	ASSERT(xfs_dir2_byte_to_db(geo, curoff) ==
4a8af273 DC	559	map_info->curdb);
	560	hdr = bp->b_addr;
	561	xfs_dir3_data_check(dp, bp);
	562	/*
	563	* Find our position in the block.
	564	*/
2ca98774	565	ptr = (char *)dp->d_ops->data_entry_p(hdr);
53f82db0	566	byteoff = xfs_dir2_byte_to_off(geo, curoff);
4a8af273 DC	567	/*
	568	* Skip past the header.
	569	*/
	570	if (byteoff == 0)
1c9a5b2e	571	curoff += dp->d_ops->data_entry_offset;
4a8af273 DC	572	/*
	573	* Skip past entries until we reach our offset.
	574	*/
	575	else {
	576	while ((char )ptr - (char )hdr < byteoff) {
	577	dup = (xfs_dir2_data_unused_t *)ptr;
	578
	579	if (be16_to_cpu(dup->freetag)
	580	== XFS_DIR2_DATA_FREE_TAG) {
	581
	582	length = be16_to_cpu(dup->length);
	583	ptr += length;
	584	continue;
	585	}
	586	dep = (xfs_dir2_data_entry_t *)ptr;
	587	length =
9d23fc85	588	dp->d_ops->data_entsize(dep->namelen);
4a8af273 DC	589	ptr += length;
	590	}
	591	/*
	592	* Now set our real offset.
	593	*/
	594	curoff =
30028030 DC	595	xfs_dir2_db_off_to_byte(geo,
30028030 DC	596	xfs_dir2_byte_to_db(geo, curoff),
4a8af273	597	(char )ptr - (char )hdr);
8f66193c	598	if (ptr >= (char *)hdr + geo->blksize) {
4a8af273 DC	599	continue;
	600	}
	601	}
	602	}
	603	/*
	604	* We have a pointer to an entry.
	605	* Is it a live one?
	606	*/
	607	dup = (xfs_dir2_data_unused_t *)ptr;
	608	/*
	609	* No, it's unused, skip over it.
	610	*/
	611	if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
	612	length = be16_to_cpu(dup->length);
	613	ptr += length;
	614	curoff += length;
	615	continue;
	616	}
	617
	618	dep = (xfs_dir2_data_entry_t *)ptr;
9d23fc85 DC	619	length = dp->d_ops->data_entsize(dep->namelen);
9d23fc85 DC	620	filetype = dp->d_ops->data_get_ftype(dep);
4a8af273	621
25994053	622	ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
4a8af273	623	if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
0cb97766	624	be64_to_cpu(dep->inumber),
53f82db0	625	xfs_dir3_get_dtype(dp->i_mount, filetype)))
4a8af273 DC	626	break;
	627
	628	/*
	629	* Advance to next entry in the block.
	630	*/
	631	ptr += length;
	632	curoff += length;
	633	/* bufsize may have just been a guess; don't go negative */
	634	bufsize = bufsize > length ? bufsize - length : 0;
	635	}
	636
	637	/*
	638	* All done. Set output offset value to current offset.
	639	*/
25994053	640	if (curoff > xfs_dir2_dataptr_to_byte(XFS_DIR2_MAX_DATAPTR))
4a8af273 DC	641	ctx->pos = XFS_DIR2_MAX_DATAPTR & 0x7fffffff;
4a8af273 DC	642	else
25994053	643	ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
4a8af273 DC	644	kmem_free(map_info);
	645	if (bp)
	646	xfs_trans_brelse(NULL, bp);
	647	return error;
	648	}
	649
	650	/*
	651	* Read a directory.
	652	*/
	653	int
	654	xfs_readdir(
53f82db0 DC	655	struct xfs_inode *dp,
	656	struct dir_context *ctx,
	657	size_t bufsize)
4a8af273	658	{
35f46c5f	659	struct xfs_da_args args = { NULL };
53f82db0 DC	660	int rval;
53f82db0 DC	661	int v;
4a8af273 DC	662
	663	trace_xfs_readdir(dp);
	664
	665	if (XFS_FORCED_SHUTDOWN(dp->i_mount))
2451337d	666	return -EIO;
4a8af273	667
c19b3b05	668	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
ff6d6af2	669	XFS_STATS_INC(dp->i_mount, xs_dir_getdents);
4a8af273	670
53f82db0 DC	671	args.dp = dp;
	672	args.geo = dp->i_mount->m_dir_geo;
	673
dbad7c99	674	xfs_ilock(dp, XFS_IOLOCK_SHARED);
4a8af273	675	if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
53f82db0 DC	676	rval = xfs_dir2_sf_getdents(&args, ctx);
53f82db0 DC	677	else if ((rval = xfs_dir2_isblock(&args, &v)))
4a8af273 DC	678	;
4a8af273 DC	679	else if (v)
53f82db0	680	rval = xfs_dir2_block_getdents(&args, ctx);
4a8af273	681	else
53f82db0	682	rval = xfs_dir2_leaf_getdents(&args, ctx, bufsize);
dbad7c99	683	xfs_iunlock(dp, XFS_IOLOCK_SHARED);
40194ecc	684
4a8af273 DC	685	return rval;
4a8af273 DC	686	}