Linux Audio

Check our new training course

Loading...
v4.17
 
  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"
 
 21#include "xfs_format.h"
 22#include "xfs_log_format.h"
 23#include "xfs_trans_resv.h"
 24#include "xfs_bit.h"
 25#include "xfs_mount.h"
 26#include "xfs_da_format.h"
 27#include "xfs_da_btree.h"
 28#include "xfs_inode.h"
 29#include "xfs_dir2.h"
 30#include "xfs_dir2_priv.h"
 31#include "xfs_error.h"
 32#include "xfs_trace.h"
 33#include "xfs_bmap.h"
 34#include "xfs_trans.h"
 
 
 35
 36/*
 37 * Directory file type support functions
 38 */
 39static 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
 44unsigned char
 45xfs_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}
 57
 58STATIC int
 59xfs_dir2_sf_getdents(
 60	struct xfs_da_args	*args,
 61	struct dir_context	*ctx)
 62{
 63	int			i;		/* shortform entry number */
 64	struct xfs_inode	*dp = args->dp;	/* incore directory inode */
 
 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;
 71	struct xfs_da_geometry	*geo = args->geo;
 72
 73	ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
 74	ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
 75	ASSERT(dp->i_df.if_u1.if_data != NULL);
 76
 77	sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
 78
 79	/*
 80	 * If the block number in the offset is out of range, we're done.
 81	 */
 82	if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk)
 83		return 0;
 84
 85	/*
 86	 * Precalculate offsets for . and .. as we will always need them.
 87	 *
 88	 * XXX(hch): the second argument is sometimes 0 and sometimes
 89	 * geo->datablk
 90	 */
 91	dot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
 92						dp->d_ops->data_dot_offset);
 93	dotdot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
 94						dp->d_ops->data_dotdot_offset);
 
 95
 96	/*
 97	 * Put . entry unless we're starting past it.
 98	 */
 99	if (ctx->pos <= dot_offset) {
100		ctx->pos = dot_offset & 0x7fffffff;
101		if (!dir_emit(ctx, ".", 1, dp->i_ino, DT_DIR))
102			return 0;
103	}
104
105	/*
106	 * Put .. entry unless we're starting past it.
107	 */
108	if (ctx->pos <= dotdot_offset) {
109		ino = dp->d_ops->sf_get_parent_ino(sfp);
110		ctx->pos = dotdot_offset & 0x7fffffff;
111		if (!dir_emit(ctx, "..", 2, ino, DT_DIR))
112			return 0;
113	}
114
115	/*
116	 * Loop while there are more entries and put'ing works.
117	 */
118	sfep = xfs_dir2_sf_firstentry(sfp);
119	for (i = 0; i < sfp->count; i++) {
120		uint8_t filetype;
121
122		off = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
123				xfs_dir2_sf_get_offset(sfep));
124
125		if (ctx->pos > off) {
126			sfep = dp->d_ops->sf_nextentry(sfp, sfep);
127			continue;
128		}
129
130		ino = dp->d_ops->sf_get_ino(sfp, sfep);
131		filetype = dp->d_ops->sf_get_ftype(sfep);
132		ctx->pos = off & 0x7fffffff;
 
 
 
 
 
 
133		if (!dir_emit(ctx, (char *)sfep->name, sfep->namelen, ino,
134			    xfs_dir3_get_dtype(dp->i_mount, filetype)))
135			return 0;
136		sfep = dp->d_ops->sf_nextentry(sfp, sfep);
137	}
138
139	ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
140								0x7fffffff;
141	return 0;
142}
143
144/*
145 * Readdir for block directories.
146 */
147STATIC int
148xfs_dir2_block_getdents(
149	struct xfs_da_args	*args,
150	struct dir_context	*ctx)
 
151{
152	struct xfs_inode	*dp = args->dp;	/* incore directory inode */
153	xfs_dir2_data_hdr_t	*hdr;		/* block header */
154	struct xfs_buf		*bp;		/* buffer for block */
155	xfs_dir2_data_entry_t	*dep;		/* block data entry */
156	xfs_dir2_data_unused_t	*dup;		/* block unused entry */
157	char			*endptr;	/* end of the data entries */
158	int			error;		/* error return value */
159	char			*ptr;		/* current data entry */
160	int			wantoff;	/* starting block offset */
161	xfs_off_t		cook;
162	struct xfs_da_geometry	*geo = args->geo;
163	int			lock_mode;
 
164
165	/*
166	 * If the block number in the offset is out of range, we're done.
167	 */
168	if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk)
169		return 0;
170
171	lock_mode = xfs_ilock_data_map_shared(dp);
172	error = xfs_dir3_block_read(args->trans, dp, &bp);
173	xfs_iunlock(dp, lock_mode);
174	if (error)
175		return error;
176
 
 
 
177	/*
178	 * Extract the byte offset we start at from the seek pointer.
179	 * We'll skip entries before this.
180	 */
181	wantoff = xfs_dir2_dataptr_to_off(geo, ctx->pos);
182	hdr = bp->b_addr;
183	xfs_dir3_data_check(dp, bp);
184	/*
185	 * Set up values for the loop.
186	 */
187	ptr = (char *)dp->d_ops->data_entry_p(hdr);
188	endptr = xfs_dir3_data_endp(geo, hdr);
189
190	/*
191	 * Loop over the data portion of the block.
192	 * Each object is a real entry (dep) or an unused one (dup).
193	 */
194	while (ptr < endptr) {
 
 
 
 
 
195		uint8_t filetype;
196
197		dup = (xfs_dir2_data_unused_t *)ptr;
198		/*
199		 * Unused, skip it.
200		 */
201		if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
202			ptr += be16_to_cpu(dup->length);
203			continue;
204		}
205
206		dep = (xfs_dir2_data_entry_t *)ptr;
207
208		/*
209		 * Bump pointer for the next iteration.
210		 */
211		ptr += dp->d_ops->data_entsize(dep->namelen);
 
 
212		/*
213		 * The entry is before the desired starting point, skip it.
214		 */
215		if ((char *)dep - (char *)hdr < wantoff)
216			continue;
217
218		cook = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
219					    (char *)dep - (char *)hdr);
220
221		ctx->pos = cook & 0x7fffffff;
222		filetype = dp->d_ops->data_get_ftype(dep);
223		/*
224		 * If it didn't fit, set the final offset to here & return.
225		 */
 
 
 
 
 
 
 
226		if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
227			    be64_to_cpu(dep->inumber),
228			    xfs_dir3_get_dtype(dp->i_mount, filetype))) {
229			xfs_trans_brelse(args->trans, bp);
230			return 0;
231		}
232	}
233
234	/*
235	 * Reached the end of the block.
236	 * Set the offset to a non-existent block 1 and return.
237	 */
238	ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
239								0x7fffffff;
 
240	xfs_trans_brelse(args->trans, bp);
241	return 0;
242}
243
244/*
245 * Read a directory block and initiate readahead for blocks beyond that.
246 * We maintain a sliding readahead window of the remaining space in the
247 * buffer rounded up to the nearest block.
248 */
249STATIC int
250xfs_dir2_leaf_readbuf(
251	struct xfs_da_args	*args,
252	size_t			bufsize,
253	xfs_dir2_off_t		*cur_off,
254	xfs_dablk_t		*ra_blk,
255	struct xfs_buf		**bpp)
256{
257	struct xfs_inode	*dp = args->dp;
258	struct xfs_buf		*bp = NULL;
259	struct xfs_da_geometry	*geo = args->geo;
260	struct xfs_ifork	*ifp = XFS_IFORK_PTR(dp, XFS_DATA_FORK);
261	struct xfs_bmbt_irec	map;
262	struct blk_plug		plug;
263	xfs_dir2_off_t		new_off;
264	xfs_dablk_t		next_ra;
265	xfs_dablk_t		map_off;
266	xfs_dablk_t		last_da;
267	struct xfs_iext_cursor	icur;
268	int			ra_want;
269	int			error = 0;
270
271	if (!(ifp->if_flags & XFS_IFEXTENTS)) {
272		error = xfs_iread_extents(args->trans, dp, XFS_DATA_FORK);
273		if (error)
274			goto out;
275	}
276
277	/*
278	 * Look for mapped directory blocks at or above the current offset.
279	 * Truncate down to the nearest directory block to start the scanning
280	 * operation.
281	 */
282	last_da = xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET);
283	map_off = xfs_dir2_db_to_da(geo, xfs_dir2_byte_to_db(geo, *cur_off));
284	if (!xfs_iext_lookup_extent(dp, ifp, map_off, &icur, &map))
285		goto out;
286	if (map.br_startoff >= last_da)
287		goto out;
288	xfs_trim_extent(&map, map_off, last_da - map_off);
289
290	/* Read the directory block of that first mapping. */
291	new_off = xfs_dir2_da_to_byte(geo, map.br_startoff);
292	if (new_off > *cur_off)
293		*cur_off = new_off;
294	error = xfs_dir3_data_read(args->trans, dp, map.br_startoff, -1, &bp);
 
295	if (error)
296		goto out;
297
298	/*
299	 * Start readahead for the next bufsize's worth of dir data blocks.
300	 * We may have already issued readahead for some of that range;
301	 * ra_blk tracks the last block we tried to read(ahead).
302	 */
303	ra_want = howmany(bufsize + geo->blksize, (1 << geo->fsblog));
304	if (*ra_blk >= last_da)
305		goto out;
306	else if (*ra_blk == 0)
307		*ra_blk = map.br_startoff;
308	next_ra = map.br_startoff + geo->fsbcount;
309	if (next_ra >= last_da)
310		goto out_no_ra;
311	if (map.br_blockcount < geo->fsbcount &&
312	    !xfs_iext_next_extent(ifp, &icur, &map))
313		goto out_no_ra;
314	if (map.br_startoff >= last_da)
315		goto out_no_ra;
316	xfs_trim_extent(&map, next_ra, last_da - next_ra);
317
318	/* Start ra for each dir (not fs) block that has a mapping. */
319	blk_start_plug(&plug);
320	while (ra_want > 0) {
321		next_ra = roundup((xfs_dablk_t)map.br_startoff, geo->fsbcount);
322		while (ra_want > 0 &&
323		       next_ra < map.br_startoff + map.br_blockcount) {
324			if (next_ra >= last_da) {
325				*ra_blk = last_da;
326				break;
327			}
328			if (next_ra > *ra_blk) {
329				xfs_dir3_data_readahead(dp, next_ra, -2);
 
330				*ra_blk = next_ra;
331			}
332			ra_want -= geo->fsbcount;
333			next_ra += geo->fsbcount;
334		}
335		if (!xfs_iext_next_extent(ifp, &icur, &map)) {
336			*ra_blk = last_da;
337			break;
338		}
339	}
340	blk_finish_plug(&plug);
341
342out:
343	*bpp = bp;
344	return error;
345out_no_ra:
346	*ra_blk = last_da;
347	goto out;
348}
349
350/*
351 * Getdents (readdir) for leaf and node directories.
352 * This reads the data blocks only, so is the same for both forms.
353 */
354STATIC int
355xfs_dir2_leaf_getdents(
356	struct xfs_da_args	*args,
357	struct dir_context	*ctx,
358	size_t			bufsize)
 
359{
360	struct xfs_inode	*dp = args->dp;
 
361	struct xfs_buf		*bp = NULL;	/* data block buffer */
362	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
363	xfs_dir2_data_entry_t	*dep;		/* data entry */
364	xfs_dir2_data_unused_t	*dup;		/* unused entry */
365	char			*ptr = NULL;	/* pointer to current data */
366	struct xfs_da_geometry	*geo = args->geo;
367	xfs_dablk_t		rablk = 0;	/* current readahead block */
368	xfs_dir2_off_t		curoff;		/* current overall offset */
369	int			length;		/* temporary length value */
370	int			byteoff;	/* offset in current block */
371	int			lock_mode;
372	int			error = 0;	/* error return value */
373
374	/*
375	 * If the offset is at or past the largest allowed value,
376	 * give up right away.
377	 */
378	if (ctx->pos >= XFS_DIR2_MAX_DATAPTR)
379		return 0;
380
381	/*
382	 * Inside the loop we keep the main offset value as a byte offset
383	 * in the directory file.
384	 */
385	curoff = xfs_dir2_dataptr_to_byte(ctx->pos);
386
387	/*
388	 * Loop over directory entries until we reach the end offset.
389	 * Get more blocks and readahead as necessary.
390	 */
391	while (curoff < XFS_DIR2_LEAF_OFFSET) {
392		uint8_t filetype;
393
394		/*
395		 * If we have no buffer, or we're off the end of the
396		 * current buffer, need to get another one.
397		 */
398		if (!bp || ptr >= (char *)bp->b_addr + geo->blksize) {
399			if (bp) {
400				xfs_trans_brelse(args->trans, bp);
401				bp = NULL;
402			}
403
404			lock_mode = xfs_ilock_data_map_shared(dp);
 
405			error = xfs_dir2_leaf_readbuf(args, bufsize, &curoff,
406					&rablk, &bp);
407			xfs_iunlock(dp, lock_mode);
408			if (error || !bp)
409				break;
410
411			hdr = bp->b_addr;
 
 
412			xfs_dir3_data_check(dp, bp);
413			/*
414			 * Find our position in the block.
415			 */
416			ptr = (char *)dp->d_ops->data_entry_p(hdr);
417			byteoff = xfs_dir2_byte_to_off(geo, curoff);
418			/*
419			 * Skip past the header.
420			 */
421			if (byteoff == 0)
422				curoff += dp->d_ops->data_entry_offset;
423			/*
424			 * Skip past entries until we reach our offset.
425			 */
426			else {
427				while ((char *)ptr - (char *)hdr < byteoff) {
428					dup = (xfs_dir2_data_unused_t *)ptr;
429
430					if (be16_to_cpu(dup->freetag)
431						  == XFS_DIR2_DATA_FREE_TAG) {
432
433						length = be16_to_cpu(dup->length);
434						ptr += length;
435						continue;
436					}
437					dep = (xfs_dir2_data_entry_t *)ptr;
438					length =
439					   dp->d_ops->data_entsize(dep->namelen);
440					ptr += length;
441				}
442				/*
443				 * Now set our real offset.
444				 */
445				curoff =
446					xfs_dir2_db_off_to_byte(geo,
447					    xfs_dir2_byte_to_db(geo, curoff),
448					    (char *)ptr - (char *)hdr);
449				if (ptr >= (char *)hdr + geo->blksize) {
450					continue;
451				}
452			}
453		}
 
454		/*
455		 * We have a pointer to an entry.
456		 * Is it a live one?
457		 */
458		dup = (xfs_dir2_data_unused_t *)ptr;
 
459		/*
460		 * No, it's unused, skip over it.
461		 */
462		if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
463			length = be16_to_cpu(dup->length);
464			ptr += length;
465			curoff += length;
466			continue;
467		}
468
469		dep = (xfs_dir2_data_entry_t *)ptr;
470		length = dp->d_ops->data_entsize(dep->namelen);
471		filetype = dp->d_ops->data_get_ftype(dep);
472
473		ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
 
 
 
 
 
 
 
474		if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
475			    be64_to_cpu(dep->inumber),
476			    xfs_dir3_get_dtype(dp->i_mount, filetype)))
477			break;
478
479		/*
480		 * Advance to next entry in the block.
481		 */
482		ptr += length;
483		curoff += length;
484		/* bufsize may have just been a guess; don't go negative */
485		bufsize = bufsize > length ? bufsize - length : 0;
486	}
487
488	/*
489	 * All done.  Set output offset value to current offset.
490	 */
491	if (curoff > xfs_dir2_dataptr_to_byte(XFS_DIR2_MAX_DATAPTR))
492		ctx->pos = XFS_DIR2_MAX_DATAPTR & 0x7fffffff;
493	else
494		ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
495	if (bp)
496		xfs_trans_brelse(args->trans, bp);
497	return error;
498}
499
500/*
501 * Read a directory.
502 *
503 * If supplied, the transaction collects locked dir buffers to avoid
504 * nested buffer deadlocks.  This function does not dirty the
505 * transaction.  The caller should ensure that the inode is locked
506 * before calling this function.
507 */
508int
509xfs_readdir(
510	struct xfs_trans	*tp,
511	struct xfs_inode	*dp,
512	struct dir_context	*ctx,
513	size_t			bufsize)
514{
515	struct xfs_da_args	args = { NULL };
516	int			rval;
517	int			v;
518
519	trace_xfs_readdir(dp);
520
521	if (XFS_FORCED_SHUTDOWN(dp->i_mount))
 
 
522		return -EIO;
523
524	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
 
525	XFS_STATS_INC(dp->i_mount, xs_dir_getdents);
526
527	args.dp = dp;
528	args.geo = dp->i_mount->m_dir_geo;
529	args.trans = tp;
 
530
531	if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
532		rval = xfs_dir2_sf_getdents(&args, ctx);
533	else if ((rval = xfs_dir2_isblock(&args, &v)))
534		;
535	else if (v)
536		rval = xfs_dir2_block_getdents(&args, ctx);
537	else
538		rval = xfs_dir2_leaf_getdents(&args, ctx, bufsize);
539
540	return rval;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
541}
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
  4 * Copyright (c) 2013 Red Hat, Inc.
  5 * All Rights Reserved.
 
 
 
 
 
 
 
 
 
 
 
 
 
  6 */
  7#include "xfs.h"
  8#include "xfs_fs.h"
  9#include "xfs_shared.h"
 10#include "xfs_format.h"
 11#include "xfs_log_format.h"
 12#include "xfs_trans_resv.h"
 
 13#include "xfs_mount.h"
 
 
 14#include "xfs_inode.h"
 15#include "xfs_dir2.h"
 16#include "xfs_dir2_priv.h"
 
 17#include "xfs_trace.h"
 18#include "xfs_bmap.h"
 19#include "xfs_trans.h"
 20#include "xfs_error.h"
 21#include "xfs_health.h"
 22
 23/*
 24 * Directory file type support functions
 25 */
 26static unsigned char xfs_dir3_filetype_table[] = {
 27	DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK,
 28	DT_FIFO, DT_SOCK, DT_LNK, DT_WHT,
 29};
 30
 31unsigned char
 32xfs_dir3_get_dtype(
 33	struct xfs_mount	*mp,
 34	uint8_t			filetype)
 35{
 36	if (!xfs_has_ftype(mp))
 37		return DT_UNKNOWN;
 38
 39	if (filetype >= XFS_DIR3_FT_MAX)
 40		return DT_UNKNOWN;
 41
 42	return xfs_dir3_filetype_table[filetype];
 43}
 44
 45STATIC int
 46xfs_dir2_sf_getdents(
 47	struct xfs_da_args	*args,
 48	struct dir_context	*ctx)
 49{
 50	int			i;		/* shortform entry number */
 51	struct xfs_inode	*dp = args->dp;	/* incore directory inode */
 52	struct xfs_mount	*mp = dp->i_mount;
 53	xfs_dir2_dataptr_t	off;		/* current entry's offset */
 54	xfs_dir2_sf_entry_t	*sfep;		/* shortform directory entry */
 55	struct xfs_dir2_sf_hdr	*sfp = dp->i_df.if_data;
 56	xfs_dir2_dataptr_t	dot_offset;
 57	xfs_dir2_dataptr_t	dotdot_offset;
 58	xfs_ino_t		ino;
 59	struct xfs_da_geometry	*geo = args->geo;
 60
 61	ASSERT(dp->i_df.if_format == XFS_DINODE_FMT_LOCAL);
 62	ASSERT(dp->i_df.if_bytes == dp->i_disk_size);
 63	ASSERT(sfp != NULL);
 
 
 64
 65	/*
 66	 * If the block number in the offset is out of range, we're done.
 67	 */
 68	if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk)
 69		return 0;
 70
 71	/*
 72	 * Precalculate offsets for "." and ".." as we will always need them.
 73	 * This relies on the fact that directories always start with the
 74	 * entries for "." and "..".
 
 75	 */
 76	dot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
 77			geo->data_entry_offset);
 78	dotdot_offset = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
 79			geo->data_entry_offset +
 80			xfs_dir2_data_entsize(mp, sizeof(".") - 1));
 81
 82	/*
 83	 * Put . entry unless we're starting past it.
 84	 */
 85	if (ctx->pos <= dot_offset) {
 86		ctx->pos = dot_offset & 0x7fffffff;
 87		if (!dir_emit(ctx, ".", 1, dp->i_ino, DT_DIR))
 88			return 0;
 89	}
 90
 91	/*
 92	 * Put .. entry unless we're starting past it.
 93	 */
 94	if (ctx->pos <= dotdot_offset) {
 95		ino = xfs_dir2_sf_get_parent_ino(sfp);
 96		ctx->pos = dotdot_offset & 0x7fffffff;
 97		if (!dir_emit(ctx, "..", 2, ino, DT_DIR))
 98			return 0;
 99	}
100
101	/*
102	 * Loop while there are more entries and put'ing works.
103	 */
104	sfep = xfs_dir2_sf_firstentry(sfp);
105	for (i = 0; i < sfp->count; i++) {
106		uint8_t filetype;
107
108		off = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
109				xfs_dir2_sf_get_offset(sfep));
110
111		if (ctx->pos > off) {
112			sfep = xfs_dir2_sf_nextentry(mp, sfp, sfep);
113			continue;
114		}
115
116		ino = xfs_dir2_sf_get_ino(mp, sfp, sfep);
117		filetype = xfs_dir2_sf_get_ftype(mp, sfep);
118		ctx->pos = off & 0x7fffffff;
119		if (XFS_IS_CORRUPT(dp->i_mount,
120				   !xfs_dir2_namecheck(sfep->name,
121						       sfep->namelen))) {
122			xfs_dirattr_mark_sick(dp, XFS_DATA_FORK);
123			return -EFSCORRUPTED;
124		}
125		if (!dir_emit(ctx, (char *)sfep->name, sfep->namelen, ino,
126			    xfs_dir3_get_dtype(mp, filetype)))
127			return 0;
128		sfep = xfs_dir2_sf_nextentry(mp, sfp, sfep);
129	}
130
131	ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
132								0x7fffffff;
133	return 0;
134}
135
136/*
137 * Readdir for block directories.
138 */
139STATIC int
140xfs_dir2_block_getdents(
141	struct xfs_da_args	*args,
142	struct dir_context	*ctx,
143	unsigned int		*lock_mode)
144{
145	struct xfs_inode	*dp = args->dp;	/* incore directory inode */
 
146	struct xfs_buf		*bp;		/* buffer for block */
 
 
 
147	int			error;		/* error return value */
 
148	int			wantoff;	/* starting block offset */
149	xfs_off_t		cook;
150	struct xfs_da_geometry	*geo = args->geo;
151	unsigned int		offset, next_offset;
152	unsigned int		end;
153
154	/*
155	 * If the block number in the offset is out of range, we're done.
156	 */
157	if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk)
158		return 0;
159
160	error = xfs_dir3_block_read(args->trans, dp, args->owner, &bp);
 
 
161	if (error)
162		return error;
163
164	xfs_iunlock(dp, *lock_mode);
165	*lock_mode = 0;
166
167	/*
168	 * Extract the byte offset we start at from the seek pointer.
169	 * We'll skip entries before this.
170	 */
171	wantoff = xfs_dir2_dataptr_to_off(geo, ctx->pos);
 
172	xfs_dir3_data_check(dp, bp);
 
 
 
 
 
173
174	/*
175	 * Loop over the data portion of the block.
176	 * Each object is a real entry (dep) or an unused one (dup).
177	 */
178	end = xfs_dir3_data_end_offset(geo, bp->b_addr);
179	for (offset = geo->data_entry_offset;
180	     offset < end;
181	     offset = next_offset) {
182		struct xfs_dir2_data_unused	*dup = bp->b_addr + offset;
183		struct xfs_dir2_data_entry	*dep = bp->b_addr + offset;
184		uint8_t filetype;
185
 
186		/*
187		 * Unused, skip it.
188		 */
189		if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
190			next_offset = offset + be16_to_cpu(dup->length);
191			continue;
192		}
193
 
 
194		/*
195		 * Bump pointer for the next iteration.
196		 */
197		next_offset = offset +
198			xfs_dir2_data_entsize(dp->i_mount, dep->namelen);
199
200		/*
201		 * The entry is before the desired starting point, skip it.
202		 */
203		if (offset < wantoff)
204			continue;
205
206		cook = xfs_dir2_db_off_to_dataptr(geo, geo->datablk, offset);
 
207
208		ctx->pos = cook & 0x7fffffff;
209		filetype = xfs_dir2_data_get_ftype(dp->i_mount, dep);
210		/*
211		 * If it didn't fit, set the final offset to here & return.
212		 */
213		if (XFS_IS_CORRUPT(dp->i_mount,
214				   !xfs_dir2_namecheck(dep->name,
215						       dep->namelen))) {
216			xfs_dirattr_mark_sick(dp, XFS_DATA_FORK);
217			error = -EFSCORRUPTED;
218			goto out_rele;
219		}
220		if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
221			    be64_to_cpu(dep->inumber),
222			    xfs_dir3_get_dtype(dp->i_mount, filetype)))
223			goto out_rele;
 
 
224	}
225
226	/*
227	 * Reached the end of the block.
228	 * Set the offset to a non-existent block 1 and return.
229	 */
230	ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) &
231								0x7fffffff;
232out_rele:
233	xfs_trans_brelse(args->trans, bp);
234	return error;
235}
236
237/*
238 * Read a directory block and initiate readahead for blocks beyond that.
239 * We maintain a sliding readahead window of the remaining space in the
240 * buffer rounded up to the nearest block.
241 */
242STATIC int
243xfs_dir2_leaf_readbuf(
244	struct xfs_da_args	*args,
245	size_t			bufsize,
246	xfs_dir2_off_t		*cur_off,
247	xfs_dablk_t		*ra_blk,
248	struct xfs_buf		**bpp)
249{
250	struct xfs_inode	*dp = args->dp;
251	struct xfs_buf		*bp = NULL;
252	struct xfs_da_geometry	*geo = args->geo;
253	struct xfs_ifork	*ifp = xfs_ifork_ptr(dp, XFS_DATA_FORK);
254	struct xfs_bmbt_irec	map;
255	struct blk_plug		plug;
256	xfs_dir2_off_t		new_off;
257	xfs_dablk_t		next_ra;
258	xfs_dablk_t		map_off;
259	xfs_dablk_t		last_da;
260	struct xfs_iext_cursor	icur;
261	int			ra_want;
262	int			error = 0;
263
264	error = xfs_iread_extents(args->trans, dp, XFS_DATA_FORK);
265	if (error)
266		goto out;
 
 
267
268	/*
269	 * Look for mapped directory blocks at or above the current offset.
270	 * Truncate down to the nearest directory block to start the scanning
271	 * operation.
272	 */
273	last_da = xfs_dir2_byte_to_da(geo, XFS_DIR2_LEAF_OFFSET);
274	map_off = xfs_dir2_db_to_da(geo, xfs_dir2_byte_to_db(geo, *cur_off));
275	if (!xfs_iext_lookup_extent(dp, ifp, map_off, &icur, &map))
276		goto out;
277	if (map.br_startoff >= last_da)
278		goto out;
279	xfs_trim_extent(&map, map_off, last_da - map_off);
280
281	/* Read the directory block of that first mapping. */
282	new_off = xfs_dir2_da_to_byte(geo, map.br_startoff);
283	if (new_off > *cur_off)
284		*cur_off = new_off;
285	error = xfs_dir3_data_read(args->trans, dp, args->owner,
286			map.br_startoff, 0, &bp);
287	if (error)
288		goto out;
289
290	/*
291	 * Start readahead for the next bufsize's worth of dir data blocks.
292	 * We may have already issued readahead for some of that range;
293	 * ra_blk tracks the last block we tried to read(ahead).
294	 */
295	ra_want = howmany(bufsize + geo->blksize, (1 << geo->fsblog));
296	if (*ra_blk >= last_da)
297		goto out;
298	else if (*ra_blk == 0)
299		*ra_blk = map.br_startoff;
300	next_ra = map.br_startoff + geo->fsbcount;
301	if (next_ra >= last_da)
302		goto out_no_ra;
303	if (map.br_blockcount < geo->fsbcount &&
304	    !xfs_iext_next_extent(ifp, &icur, &map))
305		goto out_no_ra;
306	if (map.br_startoff >= last_da)
307		goto out_no_ra;
308	xfs_trim_extent(&map, next_ra, last_da - next_ra);
309
310	/* Start ra for each dir (not fs) block that has a mapping. */
311	blk_start_plug(&plug);
312	while (ra_want > 0) {
313		next_ra = roundup((xfs_dablk_t)map.br_startoff, geo->fsbcount);
314		while (ra_want > 0 &&
315		       next_ra < map.br_startoff + map.br_blockcount) {
316			if (next_ra >= last_da) {
317				*ra_blk = last_da;
318				break;
319			}
320			if (next_ra > *ra_blk) {
321				xfs_dir3_data_readahead(dp, next_ra,
322							XFS_DABUF_MAP_HOLE_OK);
323				*ra_blk = next_ra;
324			}
325			ra_want -= geo->fsbcount;
326			next_ra += geo->fsbcount;
327		}
328		if (!xfs_iext_next_extent(ifp, &icur, &map)) {
329			*ra_blk = last_da;
330			break;
331		}
332	}
333	blk_finish_plug(&plug);
334
335out:
336	*bpp = bp;
337	return error;
338out_no_ra:
339	*ra_blk = last_da;
340	goto out;
341}
342
343/*
344 * Getdents (readdir) for leaf and node directories.
345 * This reads the data blocks only, so is the same for both forms.
346 */
347STATIC int
348xfs_dir2_leaf_getdents(
349	struct xfs_da_args	*args,
350	struct dir_context	*ctx,
351	size_t			bufsize,
352	unsigned int		*lock_mode)
353{
354	struct xfs_inode	*dp = args->dp;
355	struct xfs_mount	*mp = dp->i_mount;
356	struct xfs_buf		*bp = NULL;	/* data block buffer */
 
357	xfs_dir2_data_entry_t	*dep;		/* data entry */
358	xfs_dir2_data_unused_t	*dup;		/* unused entry */
 
359	struct xfs_da_geometry	*geo = args->geo;
360	xfs_dablk_t		rablk = 0;	/* current readahead block */
361	xfs_dir2_off_t		curoff;		/* current overall offset */
362	int			length;		/* temporary length value */
363	int			byteoff;	/* offset in current block */
364	unsigned int		offset = 0;
365	int			error = 0;	/* error return value */
366
367	/*
368	 * If the offset is at or past the largest allowed value,
369	 * give up right away.
370	 */
371	if (ctx->pos >= XFS_DIR2_MAX_DATAPTR)
372		return 0;
373
374	/*
375	 * Inside the loop we keep the main offset value as a byte offset
376	 * in the directory file.
377	 */
378	curoff = xfs_dir2_dataptr_to_byte(ctx->pos);
379
380	/*
381	 * Loop over directory entries until we reach the end offset.
382	 * Get more blocks and readahead as necessary.
383	 */
384	while (curoff < XFS_DIR2_LEAF_OFFSET) {
385		uint8_t filetype;
386
387		/*
388		 * If we have no buffer, or we're off the end of the
389		 * current buffer, need to get another one.
390		 */
391		if (!bp || offset >= geo->blksize) {
392			if (bp) {
393				xfs_trans_brelse(args->trans, bp);
394				bp = NULL;
395			}
396
397			if (*lock_mode == 0)
398				*lock_mode = xfs_ilock_data_map_shared(dp);
399			error = xfs_dir2_leaf_readbuf(args, bufsize, &curoff,
400					&rablk, &bp);
 
401			if (error || !bp)
402				break;
403
404			xfs_iunlock(dp, *lock_mode);
405			*lock_mode = 0;
406
407			xfs_dir3_data_check(dp, bp);
408			/*
409			 * Find our position in the block.
410			 */
411			offset = geo->data_entry_offset;
412			byteoff = xfs_dir2_byte_to_off(geo, curoff);
413			/*
414			 * Skip past the header.
415			 */
416			if (byteoff == 0)
417				curoff += geo->data_entry_offset;
418			/*
419			 * Skip past entries until we reach our offset.
420			 */
421			else {
422				while (offset < byteoff) {
423					dup = bp->b_addr + offset;
424
425					if (be16_to_cpu(dup->freetag)
426						  == XFS_DIR2_DATA_FREE_TAG) {
427
428						length = be16_to_cpu(dup->length);
429						offset += length;
430						continue;
431					}
432					dep = bp->b_addr + offset;
433					length = xfs_dir2_data_entsize(mp,
434							dep->namelen);
435					offset += length;
436				}
437				/*
438				 * Now set our real offset.
439				 */
440				curoff =
441					xfs_dir2_db_off_to_byte(geo,
442					    xfs_dir2_byte_to_db(geo, curoff),
443					    offset);
444				if (offset >= geo->blksize)
445					continue;
 
446			}
447		}
448
449		/*
450		 * We have a pointer to an entry.  Is it a live one?
 
451		 */
452		dup = bp->b_addr + offset;
453
454		/*
455		 * No, it's unused, skip over it.
456		 */
457		if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
458			length = be16_to_cpu(dup->length);
459			offset += length;
460			curoff += length;
461			continue;
462		}
463
464		dep = bp->b_addr + offset;
465		length = xfs_dir2_data_entsize(mp, dep->namelen);
466		filetype = xfs_dir2_data_get_ftype(mp, dep);
467
468		ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
469		if (XFS_IS_CORRUPT(dp->i_mount,
470				   !xfs_dir2_namecheck(dep->name,
471						       dep->namelen))) {
472			xfs_dirattr_mark_sick(dp, XFS_DATA_FORK);
473			error = -EFSCORRUPTED;
474			break;
475		}
476		if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
477			    be64_to_cpu(dep->inumber),
478			    xfs_dir3_get_dtype(dp->i_mount, filetype)))
479			break;
480
481		/*
482		 * Advance to next entry in the block.
483		 */
484		offset += length;
485		curoff += length;
486		/* bufsize may have just been a guess; don't go negative */
487		bufsize = bufsize > length ? bufsize - length : 0;
488	}
489
490	/*
491	 * All done.  Set output offset value to current offset.
492	 */
493	if (curoff > xfs_dir2_dataptr_to_byte(XFS_DIR2_MAX_DATAPTR))
494		ctx->pos = XFS_DIR2_MAX_DATAPTR & 0x7fffffff;
495	else
496		ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff;
497	if (bp)
498		xfs_trans_brelse(args->trans, bp);
499	return error;
500}
501
502/*
503 * Read a directory.
504 *
505 * If supplied, the transaction collects locked dir buffers to avoid
506 * nested buffer deadlocks.  This function does not dirty the
507 * transaction.  The caller must hold the IOLOCK (shared or exclusive)
508 * before calling this function.
509 */
510int
511xfs_readdir(
512	struct xfs_trans	*tp,
513	struct xfs_inode	*dp,
514	struct dir_context	*ctx,
515	size_t			bufsize)
516{
517	struct xfs_da_args	args = { NULL };
518	unsigned int		lock_mode;
519	int			error;
520
521	trace_xfs_readdir(dp);
522
523	if (xfs_is_shutdown(dp->i_mount))
524		return -EIO;
525	if (xfs_ifork_zapped(dp, XFS_DATA_FORK))
526		return -EIO;
527
528	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
529	xfs_assert_ilocked(dp, XFS_IOLOCK_SHARED | XFS_IOLOCK_EXCL);
530	XFS_STATS_INC(dp->i_mount, xs_dir_getdents);
531
532	args.dp = dp;
533	args.geo = dp->i_mount->m_dir_geo;
534	args.trans = tp;
535	args.owner = dp->i_ino;
536
537	if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL)
538		return xfs_dir2_sf_getdents(&args, ctx);
 
 
 
 
 
 
539
540	lock_mode = xfs_ilock_data_map_shared(dp);
541	switch (xfs_dir2_format(&args, &error)) {
542	case XFS_DIR2_FMT_BLOCK:
543		error = xfs_dir2_block_getdents(&args, ctx, &lock_mode);
544		break;
545	case XFS_DIR2_FMT_LEAF:
546	case XFS_DIR2_FMT_NODE:
547		error = xfs_dir2_leaf_getdents(&args, ctx, bufsize, &lock_mode);
548		break;
549	default:
550		break;
551	}
552
553	if (lock_mode)
554		xfs_iunlock(dp, lock_mode);
555	return error;
556}