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 22 /* 23 * Directory file type support functions 24 */ 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, 28 }; 29 30 unsigned char 31 xfs_dir3_get_dtype( 32 struct xfs_mount *mp, 33 uint8_t filetype) 34 { 35 if (!xfs_has_ftype(mp)) 36 return DT_UNKNOWN; 37 38 if (filetype >= XFS_DIR3_FT_MAX) 39 return DT_UNKNOWN; 40 41 return xfs_dir3_filetype_table[filetype]; 42 } 43 44 STATIC int 45 xfs_dir2_sf_getdents( 46 struct xfs_da_args *args, 47 struct dir_context *ctx) 48 { 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; 57 xfs_ino_t ino; 58 struct xfs_da_geometry *geo = args->geo; 59 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); 63 64 sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data; 65 66 /* 67 * If the block number in the offset is out of range, we're done. 68 */ 69 if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk) 70 return 0; 71 72 /* 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 "..". 76 */ 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)); 82 83 /* 84 * Put . entry unless we're starting past it. 85 */ 86 if (ctx->pos <= dot_offset) { 87 ctx->pos = dot_offset & 0x7fffffff; 88 if (!dir_emit(ctx, ".", 1, dp->i_ino, DT_DIR)) 89 return 0; 90 } 91 92 /* 93 * Put .. entry unless we're starting past it. 94 */ 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)) 99 return 0; 100 } 101 102 /* 103 * Loop while there are more entries and put'ing works. 104 */ 105 sfep = xfs_dir2_sf_firstentry(sfp); 106 for (i = 0; i < sfp->count; i++) { 107 uint8_t filetype; 108 109 off = xfs_dir2_db_off_to_dataptr(geo, geo->datablk, 110 xfs_dir2_sf_get_offset(sfep)); 111 112 if (ctx->pos > off) { 113 sfep = xfs_dir2_sf_nextentry(mp, sfp, sfep); 114 continue; 115 } 116 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, 122 sfep->namelen))) 123 return -EFSCORRUPTED; 124 if (!dir_emit(ctx, (char *)sfep->name, sfep->namelen, ino, 125 xfs_dir3_get_dtype(mp, filetype))) 126 return 0; 127 sfep = xfs_dir2_sf_nextentry(mp, sfp, sfep); 128 } 129 130 ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) & 131 0x7fffffff; 132 return 0; 133 } 134 135 /* 136 * Readdir for block directories. 137 */ 138 STATIC int 139 xfs_dir2_block_getdents( 140 struct xfs_da_args *args, 141 struct dir_context *ctx, 142 unsigned int *lock_mode) 143 { 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 */ 148 xfs_off_t cook; 149 struct xfs_da_geometry *geo = args->geo; 150 unsigned int offset, next_offset; 151 unsigned int end; 152 153 /* 154 * If the block number in the offset is out of range, we're done. 155 */ 156 if (xfs_dir2_dataptr_to_db(geo, ctx->pos) > geo->datablk) 157 return 0; 158 159 error = xfs_dir3_block_read(args->trans, dp, &bp); 160 if (error) 161 return error; 162 163 xfs_iunlock(dp, *lock_mode); 164 *lock_mode = 0; 165 166 /* 167 * Extract the byte offset we start at from the seek pointer. 168 * We'll skip entries before this. 169 */ 170 wantoff = xfs_dir2_dataptr_to_off(geo, ctx->pos); 171 xfs_dir3_data_check(dp, bp); 172 173 /* 174 * Loop over the data portion of the block. 175 * Each object is a real entry (dep) or an unused one (dup). 176 */ 177 end = xfs_dir3_data_end_offset(geo, bp->b_addr); 178 for (offset = geo->data_entry_offset; 179 offset < end; 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; 183 uint8_t filetype; 184 185 /* 186 * Unused, skip it. 187 */ 188 if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) { 189 next_offset = offset + be16_to_cpu(dup->length); 190 continue; 191 } 192 193 /* 194 * Bump pointer for the next iteration. 195 */ 196 next_offset = offset + 197 xfs_dir2_data_entsize(dp->i_mount, dep->namelen); 198 199 /* 200 * The entry is before the desired starting point, skip it. 201 */ 202 if (offset < wantoff) 203 continue; 204 205 cook = xfs_dir2_db_off_to_dataptr(geo, geo->datablk, offset); 206 207 ctx->pos = cook & 0x7fffffff; 208 filetype = xfs_dir2_data_get_ftype(dp->i_mount, dep); 209 /* 210 * If it didn't fit, set the final offset to here & return. 211 */ 212 if (XFS_IS_CORRUPT(dp->i_mount, 213 !xfs_dir2_namecheck(dep->name, 214 dep->namelen))) { 215 error = -EFSCORRUPTED; 216 goto out_rele; 217 } 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))) 221 goto out_rele; 222 } 223 224 /* 225 * Reached the end of the block. 226 * Set the offset to a non-existent block 1 and return. 227 */ 228 ctx->pos = xfs_dir2_db_off_to_dataptr(geo, geo->datablk + 1, 0) & 229 0x7fffffff; 230 out_rele: 231 xfs_trans_brelse(args->trans, bp); 232 return error; 233 } 234 235 /* 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. 239 */ 240 STATIC int 241 xfs_dir2_leaf_readbuf( 242 struct xfs_da_args *args, 243 size_t bufsize, 244 xfs_dir2_off_t *cur_off, 245 xfs_dablk_t *ra_blk, 246 struct xfs_buf **bpp) 247 { 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; 255 xfs_dablk_t next_ra; 256 xfs_dablk_t map_off; 257 xfs_dablk_t last_da; 258 struct xfs_iext_cursor icur; 259 int ra_want; 260 int error = 0; 261 262 error = xfs_iread_extents(args->trans, dp, XFS_DATA_FORK); 263 if (error) 264 goto out; 265 266 /* 267 * Look for mapped directory blocks at or above the current offset. 268 * Truncate down to the nearest directory block to start the scanning 269 * operation. 270 */ 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)) 274 goto out; 275 if (map.br_startoff >= last_da) 276 goto out; 277 xfs_trim_extent(&map, map_off, last_da - map_off); 278 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) 282 *cur_off = new_off; 283 error = xfs_dir3_data_read(args->trans, dp, map.br_startoff, 0, &bp); 284 if (error) 285 goto out; 286 287 /* 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). 291 */ 292 ra_want = howmany(bufsize + geo->blksize, (1 << geo->fsblog)); 293 if (*ra_blk >= last_da) 294 goto out; 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) 299 goto out_no_ra; 300 if (map.br_blockcount < geo->fsbcount && 301 !xfs_iext_next_extent(ifp, &icur, &map)) 302 goto out_no_ra; 303 if (map.br_startoff >= last_da) 304 goto out_no_ra; 305 xfs_trim_extent(&map, next_ra, last_da - next_ra); 306 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) { 314 *ra_blk = last_da; 315 break; 316 } 317 if (next_ra > *ra_blk) { 318 xfs_dir3_data_readahead(dp, next_ra, 319 XFS_DABUF_MAP_HOLE_OK); 320 *ra_blk = next_ra; 321 } 322 ra_want -= geo->fsbcount; 323 next_ra += geo->fsbcount; 324 } 325 if (!xfs_iext_next_extent(ifp, &icur, &map)) { 326 *ra_blk = last_da; 327 break; 328 } 329 } 330 blk_finish_plug(&plug); 331 332 out: 333 *bpp = bp; 334 return error; 335 out_no_ra: 336 *ra_blk = last_da; 337 goto out; 338 } 339 340 /* 341 * Getdents (readdir) for leaf and node directories. 342 * This reads the data blocks only, so is the same for both forms. 343 */ 344 STATIC int 345 xfs_dir2_leaf_getdents( 346 struct xfs_da_args *args, 347 struct dir_context *ctx, 348 size_t bufsize, 349 unsigned int *lock_mode) 350 { 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 */ 363 364 /* 365 * If the offset is at or past the largest allowed value, 366 * give up right away. 367 */ 368 if (ctx->pos >= XFS_DIR2_MAX_DATAPTR) 369 return 0; 370 371 /* 372 * Inside the loop we keep the main offset value as a byte offset 373 * in the directory file. 374 */ 375 curoff = xfs_dir2_dataptr_to_byte(ctx->pos); 376 377 /* 378 * Loop over directory entries until we reach the end offset. 379 * Get more blocks and readahead as necessary. 380 */ 381 while (curoff < XFS_DIR2_LEAF_OFFSET) { 382 uint8_t filetype; 383 384 /* 385 * If we have no buffer, or we're off the end of the 386 * current buffer, need to get another one. 387 */ 388 if (!bp || offset >= geo->blksize) { 389 if (bp) { 390 xfs_trans_brelse(args->trans, bp); 391 bp = NULL; 392 } 393 394 if (*lock_mode == 0) 395 *lock_mode = xfs_ilock_data_map_shared(dp); 396 error = xfs_dir2_leaf_readbuf(args, bufsize, &curoff, 397 &rablk, &bp); 398 if (error || !bp) 399 break; 400 401 xfs_iunlock(dp, *lock_mode); 402 *lock_mode = 0; 403 404 xfs_dir3_data_check(dp, bp); 405 /* 406 * Find our position in the block. 407 */ 408 offset = geo->data_entry_offset; 409 byteoff = xfs_dir2_byte_to_off(geo, curoff); 410 /* 411 * Skip past the header. 412 */ 413 if (byteoff == 0) 414 curoff += geo->data_entry_offset; 415 /* 416 * Skip past entries until we reach our offset. 417 */ 418 else { 419 while (offset < byteoff) { 420 dup = bp->b_addr + offset; 421 422 if (be16_to_cpu(dup->freetag) 423 == XFS_DIR2_DATA_FREE_TAG) { 424 425 length = be16_to_cpu(dup->length); 426 offset += length; 427 continue; 428 } 429 dep = bp->b_addr + offset; 430 length = xfs_dir2_data_entsize(mp, 431 dep->namelen); 432 offset += length; 433 } 434 /* 435 * Now set our real offset. 436 */ 437 curoff = 438 xfs_dir2_db_off_to_byte(geo, 439 xfs_dir2_byte_to_db(geo, curoff), 440 offset); 441 if (offset >= geo->blksize) 442 continue; 443 } 444 } 445 446 /* 447 * We have a pointer to an entry. Is it a live one? 448 */ 449 dup = bp->b_addr + offset; 450 451 /* 452 * No, it's unused, skip over it. 453 */ 454 if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) { 455 length = be16_to_cpu(dup->length); 456 offset += length; 457 curoff += length; 458 continue; 459 } 460 461 dep = bp->b_addr + offset; 462 length = xfs_dir2_data_entsize(mp, dep->namelen); 463 filetype = xfs_dir2_data_get_ftype(mp, dep); 464 465 ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff; 466 if (XFS_IS_CORRUPT(dp->i_mount, 467 !xfs_dir2_namecheck(dep->name, 468 dep->namelen))) { 469 error = -EFSCORRUPTED; 470 break; 471 } 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))) 475 break; 476 477 /* 478 * Advance to next entry in the block. 479 */ 480 offset += length; 481 curoff += length; 482 /* bufsize may have just been a guess; don't go negative */ 483 bufsize = bufsize > length ? bufsize - length : 0; 484 } 485 486 /* 487 * All done. Set output offset value to current offset. 488 */ 489 if (curoff > xfs_dir2_dataptr_to_byte(XFS_DIR2_MAX_DATAPTR)) 490 ctx->pos = XFS_DIR2_MAX_DATAPTR & 0x7fffffff; 491 else 492 ctx->pos = xfs_dir2_byte_to_dataptr(curoff) & 0x7fffffff; 493 if (bp) 494 xfs_trans_brelse(args->trans, bp); 495 return error; 496 } 497 498 /* 499 * Read a directory. 500 * 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. 505 */ 506 int 507 xfs_readdir( 508 struct xfs_trans *tp, 509 struct xfs_inode *dp, 510 struct dir_context *ctx, 511 size_t bufsize) 512 { 513 struct xfs_da_args args = { NULL }; 514 unsigned int lock_mode; 515 int isblock; 516 int error; 517 518 trace_xfs_readdir(dp); 519 520 if (xfs_is_shutdown(dp->i_mount)) 521 return -EIO; 522 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); 526 527 args.dp = dp; 528 args.geo = dp->i_mount->m_dir_geo; 529 args.trans = tp; 530 531 if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) 532 return xfs_dir2_sf_getdents(&args, ctx); 533 534 lock_mode = xfs_ilock_data_map_shared(dp); 535 error = xfs_dir2_isblock(&args, &isblock); 536 if (error) 537 goto out_unlock; 538 539 if (isblock) { 540 error = xfs_dir2_block_getdents(&args, ctx, &lock_mode); 541 goto out_unlock; 542 } 543 544 error = xfs_dir2_leaf_getdents(&args, ctx, bufsize, &lock_mode); 545 546 out_unlock: 547 if (lock_mode) 548 xfs_iunlock(dp, lock_mode); 549 return error; 550 } 551