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