1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4 * Copyright (c) 2013 Red Hat, Inc.
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"
16 #include "xfs_dir2_priv.h"
17 #include "xfs_trace.h"
19 #include "xfs_trans.h"
20 #include "xfs_error.h"
23 * Directory file type support functions
25 static unsigned char xfs_dir3_filetype_table
[] = {
26 DT_UNKNOWN
, DT_REG
, DT_DIR
, DT_CHR
, DT_BLK
,
27 DT_FIFO
, DT_SOCK
, DT_LNK
, DT_WHT
,
35 if (!xfs_has_ftype(mp
))
38 if (filetype
>= XFS_DIR3_FT_MAX
)
41 return xfs_dir3_filetype_table
[filetype
];
46 struct xfs_da_args
*args
,
47 struct dir_context
*ctx
)
49 int i
; /* shortform entry number */
50 struct xfs_inode
*dp
= args
->dp
; /* incore directory inode */
51 struct xfs_mount
*mp
= dp
->i_mount
;
52 xfs_dir2_dataptr_t off
; /* current entry's offset */
53 xfs_dir2_sf_entry_t
*sfep
; /* shortform directory entry */
54 xfs_dir2_sf_hdr_t
*sfp
; /* shortform structure */
55 xfs_dir2_dataptr_t dot_offset
;
56 xfs_dir2_dataptr_t dotdot_offset
;
58 struct xfs_da_geometry
*geo
= args
->geo
;
60 ASSERT(dp
->i_df
.if_format
== XFS_DINODE_FMT_LOCAL
);
61 ASSERT(dp
->i_df
.if_bytes
== dp
->i_disk_size
);
62 ASSERT(dp
->i_df
.if_u1
.if_data
!= NULL
);
64 sfp
= (xfs_dir2_sf_hdr_t
*)dp
->i_df
.if_u1
.if_data
;
67 * If the block number in the offset is out of range, we're done.
69 if (xfs_dir2_dataptr_to_db(geo
, ctx
->pos
) > geo
->datablk
)
73 * Precalculate offsets for "." and ".." as we will always need them.
74 * This relies on the fact that directories always start with the
75 * entries for "." and "..".
77 dot_offset
= xfs_dir2_db_off_to_dataptr(geo
, geo
->datablk
,
78 geo
->data_entry_offset
);
79 dotdot_offset
= xfs_dir2_db_off_to_dataptr(geo
, geo
->datablk
,
80 geo
->data_entry_offset
+
81 xfs_dir2_data_entsize(mp
, sizeof(".") - 1));
84 * Put . entry unless we're starting past it.
86 if (ctx
->pos
<= dot_offset
) {
87 ctx
->pos
= dot_offset
& 0x7fffffff;
88 if (!dir_emit(ctx
, ".", 1, dp
->i_ino
, DT_DIR
))
93 * Put .. entry unless we're starting past it.
95 if (ctx
->pos
<= dotdot_offset
) {
96 ino
= xfs_dir2_sf_get_parent_ino(sfp
);
97 ctx
->pos
= dotdot_offset
& 0x7fffffff;
98 if (!dir_emit(ctx
, "..", 2, ino
, DT_DIR
))
103 * Loop while there are more entries and put'ing works.
105 sfep
= xfs_dir2_sf_firstentry(sfp
);
106 for (i
= 0; i
< sfp
->count
; i
++) {
109 off
= xfs_dir2_db_off_to_dataptr(geo
, geo
->datablk
,
110 xfs_dir2_sf_get_offset(sfep
));
112 if (ctx
->pos
> off
) {
113 sfep
= xfs_dir2_sf_nextentry(mp
, sfp
, sfep
);
117 ino
= xfs_dir2_sf_get_ino(mp
, sfp
, sfep
);
118 filetype
= xfs_dir2_sf_get_ftype(mp
, sfep
);
119 ctx
->pos
= off
& 0x7fffffff;
120 if (XFS_IS_CORRUPT(dp
->i_mount
,
121 !xfs_dir2_namecheck(sfep
->name
,
123 return -EFSCORRUPTED
;
124 if (!dir_emit(ctx
, (char *)sfep
->name
, sfep
->namelen
, ino
,
125 xfs_dir3_get_dtype(mp
, filetype
)))
127 sfep
= xfs_dir2_sf_nextentry(mp
, sfp
, sfep
);
130 ctx
->pos
= xfs_dir2_db_off_to_dataptr(geo
, geo
->datablk
+ 1, 0) &
136 * Readdir for block directories.
139 xfs_dir2_block_getdents(
140 struct xfs_da_args
*args
,
141 struct dir_context
*ctx
,
142 unsigned int *lock_mode
)
144 struct xfs_inode
*dp
= args
->dp
; /* incore directory inode */
145 struct xfs_buf
*bp
; /* buffer for block */
146 int error
; /* error return value */
147 int wantoff
; /* starting block offset */
149 struct xfs_da_geometry
*geo
= args
->geo
;
150 unsigned int offset
, next_offset
;
154 * If the block number in the offset is out of range, we're done.
156 if (xfs_dir2_dataptr_to_db(geo
, ctx
->pos
) > geo
->datablk
)
159 error
= xfs_dir3_block_read(args
->trans
, dp
, &bp
);
163 xfs_iunlock(dp
, *lock_mode
);
167 * Extract the byte offset we start at from the seek pointer.
168 * We'll skip entries before this.
170 wantoff
= xfs_dir2_dataptr_to_off(geo
, ctx
->pos
);
171 xfs_dir3_data_check(dp
, bp
);
174 * Loop over the data portion of the block.
175 * Each object is a real entry (dep) or an unused one (dup).
177 end
= xfs_dir3_data_end_offset(geo
, bp
->b_addr
);
178 for (offset
= geo
->data_entry_offset
;
180 offset
= next_offset
) {
181 struct xfs_dir2_data_unused
*dup
= bp
->b_addr
+ offset
;
182 struct xfs_dir2_data_entry
*dep
= bp
->b_addr
+ offset
;
188 if (be16_to_cpu(dup
->freetag
) == XFS_DIR2_DATA_FREE_TAG
) {
189 next_offset
= offset
+ be16_to_cpu(dup
->length
);
194 * Bump pointer for the next iteration.
196 next_offset
= offset
+
197 xfs_dir2_data_entsize(dp
->i_mount
, dep
->namelen
);
200 * The entry is before the desired starting point, skip it.
202 if (offset
< wantoff
)
205 cook
= xfs_dir2_db_off_to_dataptr(geo
, geo
->datablk
, offset
);
207 ctx
->pos
= cook
& 0x7fffffff;
208 filetype
= xfs_dir2_data_get_ftype(dp
->i_mount
, dep
);
210 * If it didn't fit, set the final offset to here & return.
212 if (XFS_IS_CORRUPT(dp
->i_mount
,
213 !xfs_dir2_namecheck(dep
->name
,
215 error
= -EFSCORRUPTED
;
218 if (!dir_emit(ctx
, (char *)dep
->name
, dep
->namelen
,
219 be64_to_cpu(dep
->inumber
),
220 xfs_dir3_get_dtype(dp
->i_mount
, filetype
)))
225 * Reached the end of the block.
226 * Set the offset to a non-existent block 1 and return.
228 ctx
->pos
= xfs_dir2_db_off_to_dataptr(geo
, geo
->datablk
+ 1, 0) &
231 xfs_trans_brelse(args
->trans
, bp
);
236 * Read a directory block and initiate readahead for blocks beyond that.
237 * We maintain a sliding readahead window of the remaining space in the
238 * buffer rounded up to the nearest block.
241 xfs_dir2_leaf_readbuf(
242 struct xfs_da_args
*args
,
244 xfs_dir2_off_t
*cur_off
,
246 struct xfs_buf
**bpp
)
248 struct xfs_inode
*dp
= args
->dp
;
249 struct xfs_buf
*bp
= NULL
;
250 struct xfs_da_geometry
*geo
= args
->geo
;
251 struct xfs_ifork
*ifp
= xfs_ifork_ptr(dp
, XFS_DATA_FORK
);
252 struct xfs_bmbt_irec map
;
253 struct blk_plug plug
;
254 xfs_dir2_off_t new_off
;
258 struct xfs_iext_cursor icur
;
262 error
= xfs_iread_extents(args
->trans
, dp
, XFS_DATA_FORK
);
267 * Look for mapped directory blocks at or above the current offset.
268 * Truncate down to the nearest directory block to start the scanning
271 last_da
= xfs_dir2_byte_to_da(geo
, XFS_DIR2_LEAF_OFFSET
);
272 map_off
= xfs_dir2_db_to_da(geo
, xfs_dir2_byte_to_db(geo
, *cur_off
));
273 if (!xfs_iext_lookup_extent(dp
, ifp
, map_off
, &icur
, &map
))
275 if (map
.br_startoff
>= last_da
)
277 xfs_trim_extent(&map
, map_off
, last_da
- map_off
);
279 /* Read the directory block of that first mapping. */
280 new_off
= xfs_dir2_da_to_byte(geo
, map
.br_startoff
);
281 if (new_off
> *cur_off
)
283 error
= xfs_dir3_data_read(args
->trans
, dp
, map
.br_startoff
, 0, &bp
);
288 * Start readahead for the next bufsize's worth of dir data blocks.
289 * We may have already issued readahead for some of that range;
290 * ra_blk tracks the last block we tried to read(ahead).
292 ra_want
= howmany(bufsize
+ geo
->blksize
, (1 << geo
->fsblog
));
293 if (*ra_blk
>= last_da
)
295 else if (*ra_blk
== 0)
296 *ra_blk
= map
.br_startoff
;
297 next_ra
= map
.br_startoff
+ geo
->fsbcount
;
298 if (next_ra
>= last_da
)
300 if (map
.br_blockcount
< geo
->fsbcount
&&
301 !xfs_iext_next_extent(ifp
, &icur
, &map
))
303 if (map
.br_startoff
>= last_da
)
305 xfs_trim_extent(&map
, next_ra
, last_da
- next_ra
);
307 /* Start ra for each dir (not fs) block that has a mapping. */
308 blk_start_plug(&plug
);
309 while (ra_want
> 0) {
310 next_ra
= roundup((xfs_dablk_t
)map
.br_startoff
, geo
->fsbcount
);
311 while (ra_want
> 0 &&
312 next_ra
< map
.br_startoff
+ map
.br_blockcount
) {
313 if (next_ra
>= last_da
) {
317 if (next_ra
> *ra_blk
) {
318 xfs_dir3_data_readahead(dp
, next_ra
,
319 XFS_DABUF_MAP_HOLE_OK
);
322 ra_want
-= geo
->fsbcount
;
323 next_ra
+= geo
->fsbcount
;
325 if (!xfs_iext_next_extent(ifp
, &icur
, &map
)) {
330 blk_finish_plug(&plug
);
341 * Getdents (readdir) for leaf and node directories.
342 * This reads the data blocks only, so is the same for both forms.
345 xfs_dir2_leaf_getdents(
346 struct xfs_da_args
*args
,
347 struct dir_context
*ctx
,
349 unsigned int *lock_mode
)
351 struct xfs_inode
*dp
= args
->dp
;
352 struct xfs_mount
*mp
= dp
->i_mount
;
353 struct xfs_buf
*bp
= NULL
; /* data block buffer */
354 xfs_dir2_data_entry_t
*dep
; /* data entry */
355 xfs_dir2_data_unused_t
*dup
; /* unused entry */
356 struct xfs_da_geometry
*geo
= args
->geo
;
357 xfs_dablk_t rablk
= 0; /* current readahead block */
358 xfs_dir2_off_t curoff
; /* current overall offset */
359 int length
; /* temporary length value */
360 int byteoff
; /* offset in current block */
361 unsigned int offset
= 0;
362 int error
= 0; /* error return value */
365 * If the offset is at or past the largest allowed value,
366 * give up right away.
368 if (ctx
->pos
>= XFS_DIR2_MAX_DATAPTR
)
372 * Inside the loop we keep the main offset value as a byte offset
373 * in the directory file.
375 curoff
= xfs_dir2_dataptr_to_byte(ctx
->pos
);
378 * Loop over directory entries until we reach the end offset.
379 * Get more blocks and readahead as necessary.
381 while (curoff
< XFS_DIR2_LEAF_OFFSET
) {
385 * If we have no buffer, or we're off the end of the
386 * current buffer, need to get another one.
388 if (!bp
|| offset
>= geo
->blksize
) {
390 xfs_trans_brelse(args
->trans
, bp
);
395 *lock_mode
= xfs_ilock_data_map_shared(dp
);
396 error
= xfs_dir2_leaf_readbuf(args
, bufsize
, &curoff
,
401 xfs_iunlock(dp
, *lock_mode
);
404 xfs_dir3_data_check(dp
, bp
);
406 * Find our position in the block.
408 offset
= geo
->data_entry_offset
;
409 byteoff
= xfs_dir2_byte_to_off(geo
, curoff
);
411 * Skip past the header.
414 curoff
+= geo
->data_entry_offset
;
416 * Skip past entries until we reach our offset.
419 while (offset
< byteoff
) {
420 dup
= bp
->b_addr
+ offset
;
422 if (be16_to_cpu(dup
->freetag
)
423 == XFS_DIR2_DATA_FREE_TAG
) {
425 length
= be16_to_cpu(dup
->length
);
429 dep
= bp
->b_addr
+ offset
;
430 length
= xfs_dir2_data_entsize(mp
,
435 * Now set our real offset.
438 xfs_dir2_db_off_to_byte(geo
,
439 xfs_dir2_byte_to_db(geo
, curoff
),
441 if (offset
>= geo
->blksize
)
447 * We have a pointer to an entry. Is it a live one?
449 dup
= bp
->b_addr
+ offset
;
452 * No, it's unused, skip over it.
454 if (be16_to_cpu(dup
->freetag
) == XFS_DIR2_DATA_FREE_TAG
) {
455 length
= be16_to_cpu(dup
->length
);
461 dep
= bp
->b_addr
+ offset
;
462 length
= xfs_dir2_data_entsize(mp
, dep
->namelen
);
463 filetype
= xfs_dir2_data_get_ftype(mp
, dep
);
465 ctx
->pos
= xfs_dir2_byte_to_dataptr(curoff
) & 0x7fffffff;
466 if (XFS_IS_CORRUPT(dp
->i_mount
,
467 !xfs_dir2_namecheck(dep
->name
,
469 error
= -EFSCORRUPTED
;
472 if (!dir_emit(ctx
, (char *)dep
->name
, dep
->namelen
,
473 be64_to_cpu(dep
->inumber
),
474 xfs_dir3_get_dtype(dp
->i_mount
, filetype
)))
478 * Advance to next entry in the block.
482 /* bufsize may have just been a guess; don't go negative */
483 bufsize
= bufsize
> length
? bufsize
- length
: 0;
487 * All done. Set output offset value to current offset.
489 if (curoff
> xfs_dir2_dataptr_to_byte(XFS_DIR2_MAX_DATAPTR
))
490 ctx
->pos
= XFS_DIR2_MAX_DATAPTR
& 0x7fffffff;
492 ctx
->pos
= xfs_dir2_byte_to_dataptr(curoff
) & 0x7fffffff;
494 xfs_trans_brelse(args
->trans
, bp
);
501 * If supplied, the transaction collects locked dir buffers to avoid
502 * nested buffer deadlocks. This function does not dirty the
503 * transaction. The caller must hold the IOLOCK (shared or exclusive)
504 * before calling this function.
508 struct xfs_trans
*tp
,
509 struct xfs_inode
*dp
,
510 struct dir_context
*ctx
,
513 struct xfs_da_args args
= { NULL
};
514 unsigned int lock_mode
;
518 trace_xfs_readdir(dp
);
520 if (xfs_is_shutdown(dp
->i_mount
))
523 ASSERT(S_ISDIR(VFS_I(dp
)->i_mode
));
524 ASSERT(xfs_isilocked(dp
, XFS_IOLOCK_SHARED
| XFS_IOLOCK_EXCL
));
525 XFS_STATS_INC(dp
->i_mount
, xs_dir_getdents
);
528 args
.geo
= dp
->i_mount
->m_dir_geo
;
531 if (dp
->i_df
.if_format
== XFS_DINODE_FMT_LOCAL
)
532 return xfs_dir2_sf_getdents(&args
, ctx
);
534 lock_mode
= xfs_ilock_data_map_shared(dp
);
535 error
= xfs_dir2_isblock(&args
, &isblock
);
540 error
= xfs_dir2_block_getdents(&args
, ctx
, &lock_mode
);
544 error
= xfs_dir2_leaf_getdents(&args
, ctx
, bufsize
, &lock_mode
);
548 xfs_iunlock(dp
, lock_mode
);