xfs_dir2_readdir.c 18.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * 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"
21
#include "xfs_format.h"
22 23
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
24 25 26 27
#include "xfs_bit.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_mount.h"
28
#include "xfs_da_format.h"
29 30
#include "xfs_da_btree.h"
#include "xfs_inode.h"
31
#include "xfs_dir2.h"
32 33 34 35
#include "xfs_dir2_priv.h"
#include "xfs_error.h"
#include "xfs_trace.h"
#include "xfs_bmap.h"
36
#include "xfs_trans.h"
37
#include "xfs_dinode.h"
38

39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
/*
 * 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,
};

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];
}
/*
 * @mode, if set, indicates that the type field needs to be set up.
 * This uses the transformation from file mode to DT_* as defined in linux/fs.h
 * for file type specification. This will be propagated into the directory
 * structure if appropriate for the given operation and filesystem config.
 */
const unsigned char xfs_mode_to_ftype[S_IFMT >> S_SHIFT] = {
	[0]			= XFS_DIR3_FT_UNKNOWN,
	[S_IFREG >> S_SHIFT]    = XFS_DIR3_FT_REG_FILE,
	[S_IFDIR >> S_SHIFT]    = XFS_DIR3_FT_DIR,
	[S_IFCHR >> S_SHIFT]    = XFS_DIR3_FT_CHRDEV,
	[S_IFBLK >> S_SHIFT]    = XFS_DIR3_FT_BLKDEV,
	[S_IFIFO >> S_SHIFT]    = XFS_DIR3_FT_FIFO,
	[S_IFSOCK >> S_SHIFT]   = XFS_DIR3_FT_SOCK,
	[S_IFLNK >> S_SHIFT]    = XFS_DIR3_FT_SYMLINK,
};

77 78
STATIC int
xfs_dir2_sf_getdents(
79
	struct xfs_da_args	*args,
80 81 82
	struct dir_context	*ctx)
{
	int			i;		/* shortform entry number */
83
	struct xfs_inode	*dp = args->dp;	/* incore directory inode */
84 85 86 87 88 89
	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;
90
	struct xfs_da_geometry	*geo = args->geo;
91 92 93 94 95 96

	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)) {
97
		ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
98 99 100 101 102 103 104 105 106 107 108 109 110
		return XFS_ERROR(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.
	 */
111
	if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk)
112 113 114 115 116 117
		return 0;

	/*
	 * Precalculate offsets for . and .. as we will always need them.
	 *
	 * XXX(hch): the second argument is sometimes 0 and sometimes
118
	 * geo->datablk
119
	 */
120
	dot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
121
						dp->d_ops->data_dot_offset);
122
	dotdot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
123
						dp->d_ops->data_dotdot_offset);
124 125 126 127 128 129 130 131 132 133 134 135 136 137

	/*
	 * 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) {
138
		ino = dp->d_ops->sf_get_parent_ino(sfp);
139 140 141 142 143 144 145 146 147 148
		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++) {
149 150
		__uint8_t filetype;

151
		off = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
152 153 154
				xfs_dir2_sf_get_offset(sfep));

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

159 160
		ino = dp->d_ops->sf_get_ino(sfp, sfep);
		filetype = dp->d_ops->sf_get_ftype(sfep);
161
		ctx->pos = off & 0x7fffffff;
162
		if (!dir_emit(ctx, (char *)sfep->name, sfep->namelen, ino,
163
			    xfs_dir3_get_dtype(dp->i_mount, filetype)))
164
			return 0;
165
		sfep = dp->d_ops->sf_nextentry(sfp, sfep);
166 167
	}

168
	ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
169
								0x7fffffff;
170 171 172 173 174 175 176 177
	return 0;
}

/*
 * Readdir for block directories.
 */
STATIC int
xfs_dir2_block_getdents(
178
	struct xfs_da_args	*args,
179 180
	struct dir_context	*ctx)
{
181
	struct xfs_inode	*dp = args->dp;	/* incore directory inode */
182 183 184 185 186 187 188 189 190 191
	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;
192
	struct xfs_da_geometry	*geo = args->geo;
193 194 195 196

	/*
	 * If the block number in the offset is out of range, we're done.
	 */
197
	if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk)
198 199 200 201 202 203 204 205 206 207
		return 0;

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

	/*
	 * Extract the byte offset we start at from the seek pointer.
	 * We'll skip entries before this.
	 */
208
	wantoff = xfs_dir2_dataptr_to_off(geo, ctx->pos);
209 210 211 212 213
	hdr = bp->b_addr;
	xfs_dir3_data_check(dp, bp);
	/*
	 * Set up values for the loop.
	 */
214
	btp = xfs_dir2_block_tail_p(geo, hdr);
215
	ptr = (char *)dp->d_ops->data_entry_p(hdr);
216 217 218 219 220 221 222
	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) {
223 224
		__uint8_t filetype;

225 226 227 228 229 230 231 232 233 234 235 236 237 238
		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.
		 */
239
		ptr += dp->d_ops->data_entsize(dep->namelen);
240 241 242 243 244 245
		/*
		 * The entry is before the desired starting point, skip it.
		 */
		if ((char *)dep - (char *)hdr < wantoff)
			continue;

246
		cook = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
247 248 249
					    (char *)dep - (char *)hdr);

		ctx->pos = cook & 0x7fffffff;
250
		filetype = dp->d_ops->data_get_ftype(dep);
251 252 253 254
		/*
		 * If it didn't fit, set the final offset to here & return.
		 */
		if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
255
			    be64_to_cpu(dep->inumber),
256
			    xfs_dir3_get_dtype(dp->i_mount, filetype))) {
257 258 259 260 261 262 263 264 265
			xfs_trans_brelse(NULL, bp);
			return 0;
		}
	}

	/*
	 * Reached the end of the block.
	 * Set the offset to a non-existent block 1 and return.
	 */
266
	ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
267
								0x7fffffff;
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
	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(
288
	struct xfs_da_args	*args,
289 290 291 292 293
	size_t			bufsize,
	struct xfs_dir2_leaf_map_info *mip,
	xfs_dir2_off_t		*curoff,
	struct xfs_buf		**bpp)
{
294
	struct xfs_inode	*dp = args->dp;
295 296 297 298 299 300 301
	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;
302
	struct xfs_da_geometry	*geo = args->geo;
303 304 305 306 307 308 309 310 311

	/*
	 * 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;
312
		mip->map_blocks -= geo->fsbcount;
313 314 315 316
		/*
		 * Loop to get rid of the extents for the
		 * directory block.
		 */
317
		for (i = geo->fsbcount; i > 0; ) {
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
			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.
	 */
336
	mip->ra_want = howmany(bufsize + geo->blksize, (1 << geo->fsblog)) - 1;
337 338 339 340 341 342 343
	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 &&
344
	    mip->map_off < xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET)) {
345 346 347 348 349 350
		/*
		 * 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,
351
				xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET) -
352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
								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
372
			mip->map_off = xfs_dir2_byte_to_da(geo,
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
							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) {
398
		*curoff = xfs_dir2_da_to_byte(geo, mip->map_off);
399 400 401 402 403 404
		goto out;
	}

	/*
	 * Read the directory block starting at the first mapping.
	 */
405
	mip->curdb = xfs_dir2_da_to_db(geo, map->br_startoff);
406
	error = xfs_dir3_data_read(NULL, dp, map->br_startoff,
407
			map->br_blockcount >= geo->fsbcount ?
408 409
			    XFS_FSB_TO_DADDR(dp->i_mount, map->br_startblock) :
			    -1, &bp);
410 411 412 413 414 415 416 417 418 419 420
	/*
	 * 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)
421
		mip->ra_current -= geo->fsbcount;
422 423 424 425 426 427 428

	/*
	 * 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;
429
	     i += geo->fsbcount) {
430 431 432 433 434
		ASSERT(mip->ra_index < mip->map_valid);
		/*
		 * Read-ahead a contiguous directory block.
		 */
		if (i > mip->ra_current &&
435
		    map[mip->ra_index].br_blockcount >= geo->fsbcount) {
436
			xfs_dir3_data_readahead(dp,
437
				map[mip->ra_index].br_startoff + mip->ra_offset,
438
				XFS_FSB_TO_DADDR(dp->i_mount,
439 440 441 442 443 444 445 446 447 448
					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) {
449
			xfs_dir3_data_readahead(dp,
450 451 452 453 454 455 456 457
					map[mip->ra_index].br_startoff +
							mip->ra_offset, -1);
			mip->ra_current = i;
		}

		/*
		 * Advance offset through the mapping table.
		 */
458
		for (j = 0; j < geo->fsbcount; j += length ) {
459 460 461 462
			/*
			 * The rest of this extent but not more than a dir
			 * block.
			 */
463
			length = min_t(int, geo->fsbcount,
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
					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(
490
	struct xfs_da_args	*args,
491 492 493
	struct dir_context	*ctx,
	size_t			bufsize)
{
494
	struct xfs_inode	*dp = args->dp;
495 496 497 498 499 500 501 502 503 504 505
	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;
506
	struct xfs_da_geometry	*geo = args->geo;
507 508 509 510 511 512 513 514 515 516 517 518 519

	/*
	 * 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.
	 */
520
	length = howmany(bufsize + geo->blksize, (1 << geo->fsblog));
521 522 523 524 525 526 527 528 529
	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.
	 */
530
	curoff = xfs_dir2_dataptr_to_byte(ctx->pos);
531 532 533 534 535

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

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

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

552
			error = xfs_dir2_leaf_readbuf(args, bufsize, map_info,
553 554 555 556 557 558 559
						      &curoff, &bp);
			if (error || !map_info->map_valid)
				break;

			/*
			 * Having done a read, we need to set a new offset.
			 */
560
			newoff = xfs_dir2_db_off_to_byte(geo,
561
							 map_info->curdb, 0);
562 563 564 565 566 567 568 569 570
			/*
			 * Start of the current block.
			 */
			if (curoff < newoff)
				curoff = newoff;
			/*
			 * Make sure we're in the right block.
			 */
			else if (curoff > newoff)
571
				ASSERT(xfs_dir2_byte_to_db(geo, curoff) ==
572 573 574 575 576 577
				       map_info->curdb);
			hdr = bp->b_addr;
			xfs_dir3_data_check(dp, bp);
			/*
			 * Find our position in the block.
			 */
578
			ptr = (char *)dp->d_ops->data_entry_p(hdr);
579
			byteoff = xfs_dir2_byte_to_off(geo, curoff);
580 581 582 583
			/*
			 * Skip past the header.
			 */
			if (byteoff == 0)
584
				curoff += dp->d_ops->data_entry_offset;
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
			/*
			 * 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 =
601
					   dp->d_ops->data_entsize(dep->namelen);
602 603 604 605 606 607
					ptr += length;
				}
				/*
				 * Now set our real offset.
				 */
				curoff =
608 609
					xfs_dir2_db_off_to_byte(geo,
					    xfs_dir2_byte_to_db(geo, curoff),
610
					    (char *)ptr - (char *)hdr);
611
				if (ptr >= (char *)hdr + geo->blksize) {
612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
					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;
632 633
		length = dp->d_ops->data_entsize(dep->namelen);
		filetype = dp->d_ops->data_get_ftype(dep);
634

635
		ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
636
		if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
637
			    be64_to_cpu(dep->inumber),
638
			    xfs_dir3_get_dtype(dp->i_mount, filetype)))
639 640 641 642 643 644 645 646 647 648 649 650 651 652
			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.
	 */
653
	if (curoff > xfs_dir2_dataptr_to_byte(XFS_DIR2_MAX_DATAPTR))
654 655
		ctx->pos = XFS_DIR2_MAX_DATAPTR & 0x7fffffff;
	else
656
		ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
657 658 659 660 661 662 663 664 665 666 667
	kmem_free(map_info);
	if (bp)
		xfs_trans_brelse(NULL, bp);
	return error;
}

/*
 * Read a directory.
 */
int
xfs_readdir(
668 669 670
	struct xfs_inode	*dp,
	struct dir_context	*ctx,
	size_t			bufsize)
671
{
672 673 674 675
	struct xfs_da_args	args = {0};
	int			rval;
	int			v;
	uint			lock_mode;
676 677 678 679 680 681 682 683 684

	trace_xfs_readdir(dp);

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

	ASSERT(S_ISDIR(dp->i_d.di_mode));
	XFS_STATS_INC(xs_dir_getdents);

685 686 687
	args.dp = dp;
	args.geo = dp->i_mount->m_dir_geo;

688
	lock_mode = xfs_ilock_data_map_shared(dp);
689
	if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
690 691
		rval = xfs_dir2_sf_getdents(&args, ctx);
	else if ((rval = xfs_dir2_isblock(&args, &v)))
692 693
		;
	else if (v)
694
		rval = xfs_dir2_block_getdents(&args, ctx);
695
	else
696
		rval = xfs_dir2_leaf_getdents(&args, ctx, bufsize);
697 698
	xfs_iunlock(dp, lock_mode);

699 700
	return rval;
}