xfs_dir2_readdir.c 17.8 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
#include "xfs_bit.h"
#include "xfs_mount.h"
26
#include "xfs_da_format.h"
27 28
#include "xfs_da_btree.h"
#include "xfs_inode.h"
29
#include "xfs_dir2.h"
30 31 32 33
#include "xfs_dir2_priv.h"
#include "xfs_error.h"
#include "xfs_trace.h"
#include "xfs_bmap.h"
34
#include "xfs_trans.h"
35

36 37 38 39 40 41 42 43
/*
 * 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,
};

44
static unsigned char
45 46 47 48 49 50 51 52 53 54 55 56 57
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];
}

58 59
STATIC int
xfs_dir2_sf_getdents(
60
	struct xfs_da_args	*args,
61 62 63
	struct dir_context	*ctx)
{
	int			i;		/* shortform entry number */
64
	struct xfs_inode	*dp = args->dp;	/* incore directory inode */
65 66 67 68 69 70
	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;
71
	struct xfs_da_geometry	*geo = args->geo;
72 73 74 75 76 77

	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)) {
78
		ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
D
Dave Chinner 已提交
79
		return -EIO;
80 81 82 83 84 85 86
	}

	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;

87 88
	if (dp->i_d.di_size < xfs_dir2_sf_hdr_size(sfp->i8count))
		return -EFSCORRUPTED;
89 90 91 92

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

	/*
	 * Precalculate offsets for . and .. as we will always need them.
	 *
	 * XXX(hch): the second argument is sometimes 0 and sometimes
100
	 * geo->datablk
101
	 */
102
	dot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
103
						dp->d_ops->data_dot_offset);
104
	dotdot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
105
						dp->d_ops->data_dotdot_offset);
106 107 108 109 110 111 112 113 114 115 116 117 118 119

	/*
	 * 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) {
120
		ino = dp->d_ops->sf_get_parent_ino(sfp);
121 122 123 124 125 126 127 128 129 130
		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++) {
131 132
		__uint8_t filetype;

133
		off = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
134 135 136
				xfs_dir2_sf_get_offset(sfep));

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

141 142
		ino = dp->d_ops->sf_get_ino(sfp, sfep);
		filetype = dp->d_ops->sf_get_ftype(sfep);
143
		ctx->pos = off & 0x7fffffff;
144
		if (!dir_emit(ctx, (char *)sfep->name, sfep->namelen, ino,
145
			    xfs_dir3_get_dtype(dp->i_mount, filetype)))
146
			return 0;
147
		sfep = dp->d_ops->sf_nextentry(sfp, sfep);
148 149
	}

150
	ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
151
								0x7fffffff;
152 153 154 155 156 157 158 159
	return 0;
}

/*
 * Readdir for block directories.
 */
STATIC int
xfs_dir2_block_getdents(
160
	struct xfs_da_args	*args,
161 162
	struct dir_context	*ctx)
{
163
	struct xfs_inode	*dp = args->dp;	/* incore directory inode */
164 165 166 167 168 169 170 171 172 173
	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;
174
	struct xfs_da_geometry	*geo = args->geo;
175
	int			lock_mode;
176 177 178 179

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

183
	lock_mode = xfs_ilock_data_map_shared(dp);
184
	error = xfs_dir3_block_read(NULL, dp, &bp);
185
	xfs_iunlock(dp, lock_mode);
186 187 188 189 190 191 192
	if (error)
		return error;

	/*
	 * Extract the byte offset we start at from the seek pointer.
	 * We'll skip entries before this.
	 */
193
	wantoff = xfs_dir2_dataptr_to_off(geo, ctx->pos);
194 195 196 197 198
	hdr = bp->b_addr;
	xfs_dir3_data_check(dp, bp);
	/*
	 * Set up values for the loop.
	 */
199
	btp = xfs_dir2_block_tail_p(geo, hdr);
200
	ptr = (char *)dp->d_ops->data_entry_p(hdr);
201 202 203 204 205 206 207
	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) {
208 209
		__uint8_t filetype;

210 211 212 213 214 215 216 217 218 219 220 221 222 223
		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.
		 */
224
		ptr += dp->d_ops->data_entsize(dep->namelen);
225 226 227 228 229 230
		/*
		 * The entry is before the desired starting point, skip it.
		 */
		if ((char *)dep - (char *)hdr < wantoff)
			continue;

231
		cook = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
232 233 234
					    (char *)dep - (char *)hdr);

		ctx->pos = cook & 0x7fffffff;
235
		filetype = dp->d_ops->data_get_ftype(dep);
236 237 238 239
		/*
		 * If it didn't fit, set the final offset to here & return.
		 */
		if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
240
			    be64_to_cpu(dep->inumber),
241
			    xfs_dir3_get_dtype(dp->i_mount, filetype))) {
242 243 244 245 246 247 248 249 250
			xfs_trans_brelse(NULL, bp);
			return 0;
		}
	}

	/*
	 * Reached the end of the block.
	 * Set the offset to a non-existent block 1 and return.
	 */
251
	ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
252
								0x7fffffff;
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
	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(
273
	struct xfs_da_args	*args,
274 275 276
	size_t			bufsize,
	struct xfs_dir2_leaf_map_info *mip,
	xfs_dir2_off_t		*curoff,
277 278
	struct xfs_buf		**bpp,
	bool			trim_map)
279
{
280
	struct xfs_inode	*dp = args->dp;
281
	struct xfs_buf		*bp = NULL;
282 283 284 285 286 287
	struct xfs_bmbt_irec	*map = mip->map;
	struct blk_plug		plug;
	int			error = 0;
	int			length;
	int			i;
	int			j;
288
	struct xfs_da_geometry	*geo = args->geo;
289 290

	/*
291 292
	 * If the caller just finished processing a buffer, it will tell us
	 * we need to trim that block out of the mapping now it is done.
293
	 */
294
	if (trim_map) {
295
		mip->map_blocks -= geo->fsbcount;
296 297 298 299
		/*
		 * Loop to get rid of the extents for the
		 * directory block.
		 */
300
		for (i = geo->fsbcount; i > 0; ) {
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
			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.
	 */
319
	mip->ra_want = howmany(bufsize + geo->blksize, (1 << geo->fsblog)) - 1;
320 321 322 323 324 325 326
	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 &&
327
	    mip->map_off < xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET)) {
328 329 330 331 332 333
		/*
		 * 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,
334
				xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET) -
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
								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
355
			mip->map_off = xfs_dir2_byte_to_da(geo,
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
							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) {
381
		*curoff = xfs_dir2_da_to_byte(geo, mip->map_off);
382 383 384 385 386 387
		goto out;
	}

	/*
	 * Read the directory block starting at the first mapping.
	 */
388
	mip->curdb = xfs_dir2_da_to_db(geo, map->br_startoff);
389
	error = xfs_dir3_data_read(NULL, dp, map->br_startoff,
390
			map->br_blockcount >= geo->fsbcount ?
391 392
			    XFS_FSB_TO_DADDR(dp->i_mount, map->br_startblock) :
			    -1, &bp);
393 394 395 396 397 398 399 400 401 402 403
	/*
	 * 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)
404
		mip->ra_current -= geo->fsbcount;
405 406 407 408 409 410 411

	/*
	 * 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;
412
	     i += geo->fsbcount) {
413 414 415 416 417
		ASSERT(mip->ra_index < mip->map_valid);
		/*
		 * Read-ahead a contiguous directory block.
		 */
		if (i > mip->ra_current &&
418
		    map[mip->ra_index].br_blockcount >= geo->fsbcount) {
419
			xfs_dir3_data_readahead(dp,
420
				map[mip->ra_index].br_startoff + mip->ra_offset,
421
				XFS_FSB_TO_DADDR(dp->i_mount,
422 423 424 425 426 427 428 429 430 431
					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) {
432
			xfs_dir3_data_readahead(dp,
433 434 435 436 437 438 439 440
					map[mip->ra_index].br_startoff +
							mip->ra_offset, -1);
			mip->ra_current = i;
		}

		/*
		 * Advance offset through the mapping table.
		 */
441
		for (j = 0; j < geo->fsbcount; j += length ) {
442 443 444 445
			/*
			 * The rest of this extent but not more than a dir
			 * block.
			 */
446
			length = min_t(int, geo->fsbcount,
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472
					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(
473
	struct xfs_da_args	*args,
474 475 476
	struct dir_context	*ctx,
	size_t			bufsize)
{
477
	struct xfs_inode	*dp = args->dp;
478 479 480 481 482 483 484 485 486 487 488
	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;
489
	struct xfs_da_geometry	*geo = args->geo;
490 491 492 493 494 495 496 497 498 499 500 501 502

	/*
	 * 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.
	 */
503
	length = howmany(bufsize + geo->blksize, (1 << geo->fsblog));
504 505 506 507 508 509 510 511 512
	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.
	 */
513
	curoff = xfs_dir2_dataptr_to_byte(ctx->pos);
514 515 516 517 518

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

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

529 530 531 532
		/*
		 * If we have no buffer, or we're off the end of the
		 * current buffer, need to get another one.
		 */
533
		if (!bp || ptr >= (char *)bp->b_addr + geo->blksize) {
534
			int	lock_mode;
535 536 537 538 539 540 541
			bool	trim_map = false;

			if (bp) {
				xfs_trans_brelse(NULL, bp);
				bp = NULL;
				trim_map = true;
			}
542

543
			lock_mode = xfs_ilock_data_map_shared(dp);
544
			error = xfs_dir2_leaf_readbuf(args, bufsize, map_info,
545
						      &curoff, &bp, trim_map);
546
			xfs_iunlock(dp, lock_mode);
547 548 549 550 551 552
			if (error || !map_info->map_valid)
				break;

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

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

/*
 * Read a directory.
 */
int
xfs_readdir(
661 662 663
	struct xfs_inode	*dp,
	struct dir_context	*ctx,
	size_t			bufsize)
664
{
665
	struct xfs_da_args	args = { NULL };
666 667
	int			rval;
	int			v;
668 669 670 671

	trace_xfs_readdir(dp);

	if (XFS_FORCED_SHUTDOWN(dp->i_mount))
D
Dave Chinner 已提交
672
		return -EIO;
673

D
Dave Chinner 已提交
674
	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
675
	XFS_STATS_INC(dp->i_mount, xs_dir_getdents);
676

677 678 679
	args.dp = dp;
	args.geo = dp->i_mount->m_dir_geo;

680
	xfs_ilock(dp, XFS_IOLOCK_SHARED);
681
	if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
682 683
		rval = xfs_dir2_sf_getdents(&args, ctx);
	else if ((rval = xfs_dir2_isblock(&args, &v)))
684 685
		;
	else if (v)
686
		rval = xfs_dir2_block_getdents(&args, ctx);
687
	else
688
		rval = xfs_dir2_leaf_getdents(&args, ctx, bufsize);
689
	xfs_iunlock(dp, XFS_IOLOCK_SHARED);
690

691 692
	return rval;
}