1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc. 4 * All Rights Reserved. 5 */ 6 #include "xfs.h" 7 #include "xfs_fs.h" 8 #include "xfs_shared.h" 9 #include "xfs_format.h" 10 #include "xfs_log_format.h" 11 #include "xfs_trans_resv.h" 12 #include "xfs_mount.h" 13 #include "xfs_inode.h" 14 #include "xfs_trans.h" 15 #include "xfs_bmap.h" 16 #include "xfs_dir2.h" 17 #include "xfs_dir2_priv.h" 18 #include "xfs_errortag.h" 19 #include "xfs_error.h" 20 #include "xfs_trace.h" 21 22 const struct xfs_name xfs_name_dotdot = { 23 .name = (const unsigned char *)"..", 24 .len = 2, 25 .type = XFS_DIR3_FT_DIR, 26 }; 27 28 /* 29 * Convert inode mode to directory entry filetype 30 */ 31 unsigned char 32 xfs_mode_to_ftype( 33 int mode) 34 { 35 switch (mode & S_IFMT) { 36 case S_IFREG: 37 return XFS_DIR3_FT_REG_FILE; 38 case S_IFDIR: 39 return XFS_DIR3_FT_DIR; 40 case S_IFCHR: 41 return XFS_DIR3_FT_CHRDEV; 42 case S_IFBLK: 43 return XFS_DIR3_FT_BLKDEV; 44 case S_IFIFO: 45 return XFS_DIR3_FT_FIFO; 46 case S_IFSOCK: 47 return XFS_DIR3_FT_SOCK; 48 case S_IFLNK: 49 return XFS_DIR3_FT_SYMLINK; 50 default: 51 return XFS_DIR3_FT_UNKNOWN; 52 } 53 } 54 55 /* 56 * ASCII case-insensitive (ie. A-Z) support for directories that was 57 * used in IRIX. 58 */ 59 xfs_dahash_t 60 xfs_ascii_ci_hashname( 61 const struct xfs_name *name) 62 { 63 xfs_dahash_t hash; 64 int i; 65 66 for (i = 0, hash = 0; i < name->len; i++) 67 hash = xfs_ascii_ci_xfrm(name->name[i]) ^ rol32(hash, 7); 68 69 return hash; 70 } 71 72 enum xfs_dacmp 73 xfs_ascii_ci_compname( 74 struct xfs_da_args *args, 75 const unsigned char *name, 76 int len) 77 { 78 enum xfs_dacmp result; 79 int i; 80 81 if (args->namelen != len) 82 return XFS_CMP_DIFFERENT; 83 84 result = XFS_CMP_EXACT; 85 for (i = 0; i < len; i++) { 86 if (args->name[i] == name[i]) 87 continue; 88 if (xfs_ascii_ci_xfrm(args->name[i]) != 89 xfs_ascii_ci_xfrm(name[i])) 90 return XFS_CMP_DIFFERENT; 91 result = XFS_CMP_CASE; 92 } 93 94 return result; 95 } 96 97 int 98 xfs_da_mount( 99 struct xfs_mount *mp) 100 { 101 struct xfs_da_geometry *dageo; 102 103 104 ASSERT(mp->m_sb.sb_versionnum & XFS_SB_VERSION_DIRV2BIT); 105 ASSERT(xfs_dir2_dirblock_bytes(&mp->m_sb) <= XFS_MAX_BLOCKSIZE); 106 107 mp->m_dir_geo = kmem_zalloc(sizeof(struct xfs_da_geometry), 108 KM_MAYFAIL); 109 mp->m_attr_geo = kmem_zalloc(sizeof(struct xfs_da_geometry), 110 KM_MAYFAIL); 111 if (!mp->m_dir_geo || !mp->m_attr_geo) { 112 kmem_free(mp->m_dir_geo); 113 kmem_free(mp->m_attr_geo); 114 return -ENOMEM; 115 } 116 117 /* set up directory geometry */ 118 dageo = mp->m_dir_geo; 119 dageo->blklog = mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog; 120 dageo->fsblog = mp->m_sb.sb_blocklog; 121 dageo->blksize = xfs_dir2_dirblock_bytes(&mp->m_sb); 122 dageo->fsbcount = 1 << mp->m_sb.sb_dirblklog; 123 if (xfs_has_crc(mp)) { 124 dageo->node_hdr_size = sizeof(struct xfs_da3_node_hdr); 125 dageo->leaf_hdr_size = sizeof(struct xfs_dir3_leaf_hdr); 126 dageo->free_hdr_size = sizeof(struct xfs_dir3_free_hdr); 127 dageo->data_entry_offset = 128 sizeof(struct xfs_dir3_data_hdr); 129 } else { 130 dageo->node_hdr_size = sizeof(struct xfs_da_node_hdr); 131 dageo->leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr); 132 dageo->free_hdr_size = sizeof(struct xfs_dir2_free_hdr); 133 dageo->data_entry_offset = 134 sizeof(struct xfs_dir2_data_hdr); 135 } 136 dageo->leaf_max_ents = (dageo->blksize - dageo->leaf_hdr_size) / 137 sizeof(struct xfs_dir2_leaf_entry); 138 dageo->free_max_bests = (dageo->blksize - dageo->free_hdr_size) / 139 sizeof(xfs_dir2_data_off_t); 140 141 dageo->data_first_offset = dageo->data_entry_offset + 142 xfs_dir2_data_entsize(mp, 1) + 143 xfs_dir2_data_entsize(mp, 2); 144 145 /* 146 * Now we've set up the block conversion variables, we can calculate the 147 * segment block constants using the geometry structure. 148 */ 149 dageo->datablk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_DATA_OFFSET); 150 dageo->leafblk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_LEAF_OFFSET); 151 dageo->freeblk = xfs_dir2_byte_to_da(dageo, XFS_DIR2_FREE_OFFSET); 152 dageo->node_ents = (dageo->blksize - dageo->node_hdr_size) / 153 (uint)sizeof(xfs_da_node_entry_t); 154 dageo->max_extents = (XFS_DIR2_MAX_SPACES * XFS_DIR2_SPACE_SIZE) >> 155 mp->m_sb.sb_blocklog; 156 dageo->magicpct = (dageo->blksize * 37) / 100; 157 158 /* set up attribute geometry - single fsb only */ 159 dageo = mp->m_attr_geo; 160 dageo->blklog = mp->m_sb.sb_blocklog; 161 dageo->fsblog = mp->m_sb.sb_blocklog; 162 dageo->blksize = 1 << dageo->blklog; 163 dageo->fsbcount = 1; 164 dageo->node_hdr_size = mp->m_dir_geo->node_hdr_size; 165 dageo->node_ents = (dageo->blksize - dageo->node_hdr_size) / 166 (uint)sizeof(xfs_da_node_entry_t); 167 168 if (xfs_has_large_extent_counts(mp)) 169 dageo->max_extents = XFS_MAX_EXTCNT_ATTR_FORK_LARGE; 170 else 171 dageo->max_extents = XFS_MAX_EXTCNT_ATTR_FORK_SMALL; 172 173 dageo->magicpct = (dageo->blksize * 37) / 100; 174 return 0; 175 } 176 177 void 178 xfs_da_unmount( 179 struct xfs_mount *mp) 180 { 181 kmem_free(mp->m_dir_geo); 182 kmem_free(mp->m_attr_geo); 183 } 184 185 /* 186 * Return 1 if directory contains only "." and "..". 187 */ 188 int 189 xfs_dir_isempty( 190 xfs_inode_t *dp) 191 { 192 xfs_dir2_sf_hdr_t *sfp; 193 194 ASSERT(S_ISDIR(VFS_I(dp)->i_mode)); 195 if (dp->i_disk_size == 0) /* might happen during shutdown. */ 196 return 1; 197 if (dp->i_disk_size > xfs_inode_data_fork_size(dp)) 198 return 0; 199 sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data; 200 return !sfp->count; 201 } 202 203 /* 204 * Validate a given inode number. 205 */ 206 int 207 xfs_dir_ino_validate( 208 xfs_mount_t *mp, 209 xfs_ino_t ino) 210 { 211 bool ino_ok = xfs_verify_dir_ino(mp, ino); 212 213 if (XFS_IS_CORRUPT(mp, !ino_ok) || 214 XFS_TEST_ERROR(false, mp, XFS_ERRTAG_DIR_INO_VALIDATE)) { 215 xfs_warn(mp, "Invalid inode number 0x%Lx", 216 (unsigned long long) ino); 217 return -EFSCORRUPTED; 218 } 219 return 0; 220 } 221 222 /* 223 * Initialize a directory with its "." and ".." entries. 224 */ 225 int 226 xfs_dir_init( 227 xfs_trans_t *tp, 228 xfs_inode_t *dp, 229 xfs_inode_t *pdp) 230 { 231 struct xfs_da_args *args; 232 int error; 233 234 ASSERT(S_ISDIR(VFS_I(dp)->i_mode)); 235 error = xfs_dir_ino_validate(tp->t_mountp, pdp->i_ino); 236 if (error) 237 return error; 238 239 args = kmem_zalloc(sizeof(*args), KM_NOFS); 240 if (!args) 241 return -ENOMEM; 242 243 args->geo = dp->i_mount->m_dir_geo; 244 args->dp = dp; 245 args->trans = tp; 246 error = xfs_dir2_sf_create(args, pdp->i_ino); 247 kmem_free(args); 248 return error; 249 } 250 251 /* 252 * Enter a name in a directory, or check for available space. 253 * If inum is 0, only the available space test is performed. 254 */ 255 int 256 xfs_dir_createname( 257 struct xfs_trans *tp, 258 struct xfs_inode *dp, 259 const struct xfs_name *name, 260 xfs_ino_t inum, /* new entry inode number */ 261 xfs_extlen_t total) /* bmap's total block count */ 262 { 263 struct xfs_da_args *args; 264 int rval; 265 bool v; 266 267 ASSERT(S_ISDIR(VFS_I(dp)->i_mode)); 268 269 if (inum) { 270 rval = xfs_dir_ino_validate(tp->t_mountp, inum); 271 if (rval) 272 return rval; 273 XFS_STATS_INC(dp->i_mount, xs_dir_create); 274 } 275 276 args = kmem_zalloc(sizeof(*args), KM_NOFS); 277 if (!args) 278 return -ENOMEM; 279 280 args->geo = dp->i_mount->m_dir_geo; 281 args->name = name->name; 282 args->namelen = name->len; 283 args->filetype = name->type; 284 args->hashval = xfs_dir2_hashname(dp->i_mount, name); 285 args->inumber = inum; 286 args->dp = dp; 287 args->total = total; 288 args->whichfork = XFS_DATA_FORK; 289 args->trans = tp; 290 args->op_flags = XFS_DA_OP_ADDNAME | XFS_DA_OP_OKNOENT; 291 if (!inum) 292 args->op_flags |= XFS_DA_OP_JUSTCHECK; 293 294 if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) { 295 rval = xfs_dir2_sf_addname(args); 296 goto out_free; 297 } 298 299 rval = xfs_dir2_isblock(args, &v); 300 if (rval) 301 goto out_free; 302 if (v) { 303 rval = xfs_dir2_block_addname(args); 304 goto out_free; 305 } 306 307 rval = xfs_dir2_isleaf(args, &v); 308 if (rval) 309 goto out_free; 310 if (v) 311 rval = xfs_dir2_leaf_addname(args); 312 else 313 rval = xfs_dir2_node_addname(args); 314 315 out_free: 316 kmem_free(args); 317 return rval; 318 } 319 320 /* 321 * If doing a CI lookup and case-insensitive match, dup actual name into 322 * args.value. Return EEXIST for success (ie. name found) or an error. 323 */ 324 int 325 xfs_dir_cilookup_result( 326 struct xfs_da_args *args, 327 const unsigned char *name, 328 int len) 329 { 330 if (args->cmpresult == XFS_CMP_DIFFERENT) 331 return -ENOENT; 332 if (args->cmpresult != XFS_CMP_CASE || 333 !(args->op_flags & XFS_DA_OP_CILOOKUP)) 334 return -EEXIST; 335 336 args->value = kmem_alloc(len, KM_NOFS | KM_MAYFAIL); 337 if (!args->value) 338 return -ENOMEM; 339 340 memcpy(args->value, name, len); 341 args->valuelen = len; 342 return -EEXIST; 343 } 344 345 /* 346 * Lookup a name in a directory, give back the inode number. 347 * If ci_name is not NULL, returns the actual name in ci_name if it differs 348 * to name, or ci_name->name is set to NULL for an exact match. 349 */ 350 351 int 352 xfs_dir_lookup( 353 struct xfs_trans *tp, 354 struct xfs_inode *dp, 355 const struct xfs_name *name, 356 xfs_ino_t *inum, /* out: inode number */ 357 struct xfs_name *ci_name) /* out: actual name if CI match */ 358 { 359 struct xfs_da_args *args; 360 int rval; 361 bool v; 362 int lock_mode; 363 364 ASSERT(S_ISDIR(VFS_I(dp)->i_mode)); 365 XFS_STATS_INC(dp->i_mount, xs_dir_lookup); 366 367 /* 368 * We need to use KM_NOFS here so that lockdep will not throw false 369 * positive deadlock warnings on a non-transactional lookup path. It is 370 * safe to recurse into inode recalim in that case, but lockdep can't 371 * easily be taught about it. Hence KM_NOFS avoids having to add more 372 * lockdep Doing this avoids having to add a bunch of lockdep class 373 * annotations into the reclaim path for the ilock. 374 */ 375 args = kmem_zalloc(sizeof(*args), KM_NOFS); 376 args->geo = dp->i_mount->m_dir_geo; 377 args->name = name->name; 378 args->namelen = name->len; 379 args->filetype = name->type; 380 args->hashval = xfs_dir2_hashname(dp->i_mount, name); 381 args->dp = dp; 382 args->whichfork = XFS_DATA_FORK; 383 args->trans = tp; 384 args->op_flags = XFS_DA_OP_OKNOENT; 385 if (ci_name) 386 args->op_flags |= XFS_DA_OP_CILOOKUP; 387 388 lock_mode = xfs_ilock_data_map_shared(dp); 389 if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) { 390 rval = xfs_dir2_sf_lookup(args); 391 goto out_check_rval; 392 } 393 394 rval = xfs_dir2_isblock(args, &v); 395 if (rval) 396 goto out_free; 397 if (v) { 398 rval = xfs_dir2_block_lookup(args); 399 goto out_check_rval; 400 } 401 402 rval = xfs_dir2_isleaf(args, &v); 403 if (rval) 404 goto out_free; 405 if (v) 406 rval = xfs_dir2_leaf_lookup(args); 407 else 408 rval = xfs_dir2_node_lookup(args); 409 410 out_check_rval: 411 if (rval == -EEXIST) 412 rval = 0; 413 if (!rval) { 414 *inum = args->inumber; 415 if (ci_name) { 416 ci_name->name = args->value; 417 ci_name->len = args->valuelen; 418 } 419 } 420 out_free: 421 xfs_iunlock(dp, lock_mode); 422 kmem_free(args); 423 return rval; 424 } 425 426 /* 427 * Remove an entry from a directory. 428 */ 429 int 430 xfs_dir_removename( 431 struct xfs_trans *tp, 432 struct xfs_inode *dp, 433 struct xfs_name *name, 434 xfs_ino_t ino, 435 xfs_extlen_t total) /* bmap's total block count */ 436 { 437 struct xfs_da_args *args; 438 int rval; 439 bool v; 440 441 ASSERT(S_ISDIR(VFS_I(dp)->i_mode)); 442 XFS_STATS_INC(dp->i_mount, xs_dir_remove); 443 444 args = kmem_zalloc(sizeof(*args), KM_NOFS); 445 if (!args) 446 return -ENOMEM; 447 448 args->geo = dp->i_mount->m_dir_geo; 449 args->name = name->name; 450 args->namelen = name->len; 451 args->filetype = name->type; 452 args->hashval = xfs_dir2_hashname(dp->i_mount, name); 453 args->inumber = ino; 454 args->dp = dp; 455 args->total = total; 456 args->whichfork = XFS_DATA_FORK; 457 args->trans = tp; 458 459 if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) { 460 rval = xfs_dir2_sf_removename(args); 461 goto out_free; 462 } 463 464 rval = xfs_dir2_isblock(args, &v); 465 if (rval) 466 goto out_free; 467 if (v) { 468 rval = xfs_dir2_block_removename(args); 469 goto out_free; 470 } 471 472 rval = xfs_dir2_isleaf(args, &v); 473 if (rval) 474 goto out_free; 475 if (v) 476 rval = xfs_dir2_leaf_removename(args); 477 else 478 rval = xfs_dir2_node_removename(args); 479 out_free: 480 kmem_free(args); 481 return rval; 482 } 483 484 /* 485 * Replace the inode number of a directory entry. 486 */ 487 int 488 xfs_dir_replace( 489 struct xfs_trans *tp, 490 struct xfs_inode *dp, 491 const struct xfs_name *name, /* name of entry to replace */ 492 xfs_ino_t inum, /* new inode number */ 493 xfs_extlen_t total) /* bmap's total block count */ 494 { 495 struct xfs_da_args *args; 496 int rval; 497 bool v; 498 499 ASSERT(S_ISDIR(VFS_I(dp)->i_mode)); 500 501 rval = xfs_dir_ino_validate(tp->t_mountp, inum); 502 if (rval) 503 return rval; 504 505 args = kmem_zalloc(sizeof(*args), KM_NOFS); 506 if (!args) 507 return -ENOMEM; 508 509 args->geo = dp->i_mount->m_dir_geo; 510 args->name = name->name; 511 args->namelen = name->len; 512 args->filetype = name->type; 513 args->hashval = xfs_dir2_hashname(dp->i_mount, name); 514 args->inumber = inum; 515 args->dp = dp; 516 args->total = total; 517 args->whichfork = XFS_DATA_FORK; 518 args->trans = tp; 519 520 if (dp->i_df.if_format == XFS_DINODE_FMT_LOCAL) { 521 rval = xfs_dir2_sf_replace(args); 522 goto out_free; 523 } 524 525 rval = xfs_dir2_isblock(args, &v); 526 if (rval) 527 goto out_free; 528 if (v) { 529 rval = xfs_dir2_block_replace(args); 530 goto out_free; 531 } 532 533 rval = xfs_dir2_isleaf(args, &v); 534 if (rval) 535 goto out_free; 536 if (v) 537 rval = xfs_dir2_leaf_replace(args); 538 else 539 rval = xfs_dir2_node_replace(args); 540 out_free: 541 kmem_free(args); 542 return rval; 543 } 544 545 /* 546 * See if this entry can be added to the directory without allocating space. 547 */ 548 int 549 xfs_dir_canenter( 550 xfs_trans_t *tp, 551 xfs_inode_t *dp, 552 struct xfs_name *name) /* name of entry to add */ 553 { 554 return xfs_dir_createname(tp, dp, name, 0, 0); 555 } 556 557 /* 558 * Utility routines. 559 */ 560 561 /* 562 * Add a block to the directory. 563 * 564 * This routine is for data and free blocks, not leaf/node blocks which are 565 * handled by xfs_da_grow_inode. 566 */ 567 int 568 xfs_dir2_grow_inode( 569 struct xfs_da_args *args, 570 int space, /* v2 dir's space XFS_DIR2_xxx_SPACE */ 571 xfs_dir2_db_t *dbp) /* out: block number added */ 572 { 573 struct xfs_inode *dp = args->dp; 574 struct xfs_mount *mp = dp->i_mount; 575 xfs_fileoff_t bno; /* directory offset of new block */ 576 int count; /* count of filesystem blocks */ 577 int error; 578 579 trace_xfs_dir2_grow_inode(args, space); 580 581 /* 582 * Set lowest possible block in the space requested. 583 */ 584 bno = XFS_B_TO_FSBT(mp, space * XFS_DIR2_SPACE_SIZE); 585 count = args->geo->fsbcount; 586 587 error = xfs_da_grow_inode_int(args, &bno, count); 588 if (error) 589 return error; 590 591 *dbp = xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)bno); 592 593 /* 594 * Update file's size if this is the data space and it grew. 595 */ 596 if (space == XFS_DIR2_DATA_SPACE) { 597 xfs_fsize_t size; /* directory file (data) size */ 598 599 size = XFS_FSB_TO_B(mp, bno + count); 600 if (size > dp->i_disk_size) { 601 dp->i_disk_size = size; 602 xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE); 603 } 604 } 605 return 0; 606 } 607 608 /* 609 * See if the directory is a single-block form directory. 610 */ 611 int 612 xfs_dir2_isblock( 613 struct xfs_da_args *args, 614 bool *isblock) 615 { 616 struct xfs_mount *mp = args->dp->i_mount; 617 xfs_fileoff_t eof; 618 int error; 619 620 error = xfs_bmap_last_offset(args->dp, &eof, XFS_DATA_FORK); 621 if (error) 622 return error; 623 624 *isblock = false; 625 if (XFS_FSB_TO_B(mp, eof) != args->geo->blksize) 626 return 0; 627 628 *isblock = true; 629 if (XFS_IS_CORRUPT(mp, args->dp->i_disk_size != args->geo->blksize)) 630 return -EFSCORRUPTED; 631 return 0; 632 } 633 634 /* 635 * See if the directory is a single-leaf form directory. 636 */ 637 int 638 xfs_dir2_isleaf( 639 struct xfs_da_args *args, 640 bool *isleaf) 641 { 642 xfs_fileoff_t eof; 643 int error; 644 645 error = xfs_bmap_last_offset(args->dp, &eof, XFS_DATA_FORK); 646 if (error) 647 return error; 648 649 *isleaf = false; 650 if (eof != args->geo->leafblk + args->geo->fsbcount) 651 return 0; 652 653 *isleaf = true; 654 return 0; 655 } 656 657 /* 658 * Remove the given block from the directory. 659 * This routine is used for data and free blocks, leaf/node are done 660 * by xfs_da_shrink_inode. 661 */ 662 int 663 xfs_dir2_shrink_inode( 664 struct xfs_da_args *args, 665 xfs_dir2_db_t db, 666 struct xfs_buf *bp) 667 { 668 xfs_fileoff_t bno; /* directory file offset */ 669 xfs_dablk_t da; /* directory file offset */ 670 int done; /* bunmap is finished */ 671 struct xfs_inode *dp; 672 int error; 673 struct xfs_mount *mp; 674 struct xfs_trans *tp; 675 676 trace_xfs_dir2_shrink_inode(args, db); 677 678 dp = args->dp; 679 mp = dp->i_mount; 680 tp = args->trans; 681 da = xfs_dir2_db_to_da(args->geo, db); 682 683 /* Unmap the fsblock(s). */ 684 error = xfs_bunmapi(tp, dp, da, args->geo->fsbcount, 0, 0, &done); 685 if (error) { 686 /* 687 * ENOSPC actually can happen if we're in a removename with no 688 * space reservation, and the resulting block removal would 689 * cause a bmap btree split or conversion from extents to btree. 690 * This can only happen for un-fragmented directory blocks, 691 * since you need to be punching out the middle of an extent. 692 * In this case we need to leave the block in the file, and not 693 * binval it. So the block has to be in a consistent empty 694 * state and appropriately logged. We don't free up the buffer, 695 * the caller can tell it hasn't happened since it got an error 696 * back. 697 */ 698 return error; 699 } 700 ASSERT(done); 701 /* 702 * Invalidate the buffer from the transaction. 703 */ 704 xfs_trans_binval(tp, bp); 705 /* 706 * If it's not a data block, we're done. 707 */ 708 if (db >= xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET)) 709 return 0; 710 /* 711 * If the block isn't the last one in the directory, we're done. 712 */ 713 if (dp->i_disk_size > xfs_dir2_db_off_to_byte(args->geo, db + 1, 0)) 714 return 0; 715 bno = da; 716 if ((error = xfs_bmap_last_before(tp, dp, &bno, XFS_DATA_FORK))) { 717 /* 718 * This can't really happen unless there's kernel corruption. 719 */ 720 return error; 721 } 722 if (db == args->geo->datablk) 723 ASSERT(bno == 0); 724 else 725 ASSERT(bno > 0); 726 /* 727 * Set the size to the new last block. 728 */ 729 dp->i_disk_size = XFS_FSB_TO_B(mp, bno); 730 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE); 731 return 0; 732 } 733 734 /* Returns true if the directory entry name is valid. */ 735 bool 736 xfs_dir2_namecheck( 737 const void *name, 738 size_t length) 739 { 740 /* 741 * MAXNAMELEN includes the trailing null, but (name/length) leave it 742 * out, so use >= for the length check. 743 */ 744 if (length >= MAXNAMELEN) 745 return false; 746 747 /* There shouldn't be any slashes or nulls here */ 748 return !memchr(name, '/', length) && !memchr(name, 0, length); 749 } 750 751 xfs_dahash_t 752 xfs_dir2_hashname( 753 struct xfs_mount *mp, 754 const struct xfs_name *name) 755 { 756 if (unlikely(xfs_has_asciici(mp))) 757 return xfs_ascii_ci_hashname(name); 758 return xfs_da_hashname(name->name, name->len); 759 } 760 761 enum xfs_dacmp 762 xfs_dir2_compname( 763 struct xfs_da_args *args, 764 const unsigned char *name, 765 int len) 766 { 767 if (unlikely(xfs_has_asciici(args->dp->i_mount))) 768 return xfs_ascii_ci_compname(args, name, len); 769 return xfs_da_compname(args, name, len); 770 } 771