1 /* 2 * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc. 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18 #include "xfs.h" 19 #include "xfs_fs.h" 20 #include "xfs_format.h" 21 #include "xfs_log_format.h" 22 #include "xfs_trans_resv.h" 23 #include "xfs_mount.h" 24 #include "xfs_da_format.h" 25 #include "xfs_da_btree.h" 26 #include "xfs_inode.h" 27 #include "xfs_trans.h" 28 #include "xfs_inode_item.h" 29 #include "xfs_bmap.h" 30 #include "xfs_dir2.h" 31 #include "xfs_dir2_priv.h" 32 #include "xfs_error.h" 33 #include "xfs_trace.h" 34 35 struct xfs_name xfs_name_dotdot = { (unsigned char *)"..", 2, XFS_DIR3_FT_DIR }; 36 37 /* 38 * @mode, if set, indicates that the type field needs to be set up. 39 * This uses the transformation from file mode to DT_* as defined in linux/fs.h 40 * for file type specification. This will be propagated into the directory 41 * structure if appropriate for the given operation and filesystem config. 42 */ 43 const unsigned char xfs_mode_to_ftype[S_IFMT >> S_SHIFT] = { 44 [0] = XFS_DIR3_FT_UNKNOWN, 45 [S_IFREG >> S_SHIFT] = XFS_DIR3_FT_REG_FILE, 46 [S_IFDIR >> S_SHIFT] = XFS_DIR3_FT_DIR, 47 [S_IFCHR >> S_SHIFT] = XFS_DIR3_FT_CHRDEV, 48 [S_IFBLK >> S_SHIFT] = XFS_DIR3_FT_BLKDEV, 49 [S_IFIFO >> S_SHIFT] = XFS_DIR3_FT_FIFO, 50 [S_IFSOCK >> S_SHIFT] = XFS_DIR3_FT_SOCK, 51 [S_IFLNK >> S_SHIFT] = XFS_DIR3_FT_SYMLINK, 52 }; 53 54 /* 55 * ASCII case-insensitive (ie. A-Z) support for directories that was 56 * used in IRIX. 57 */ 58 STATIC xfs_dahash_t 59 xfs_ascii_ci_hashname( 60 struct xfs_name *name) 61 { 62 xfs_dahash_t hash; 63 int i; 64 65 for (i = 0, hash = 0; i < name->len; i++) 66 hash = tolower(name->name[i]) ^ rol32(hash, 7); 67 68 return hash; 69 } 70 71 STATIC enum xfs_dacmp 72 xfs_ascii_ci_compname( 73 struct xfs_da_args *args, 74 const unsigned char *name, 75 int len) 76 { 77 enum xfs_dacmp result; 78 int i; 79 80 if (args->namelen != len) 81 return XFS_CMP_DIFFERENT; 82 83 result = XFS_CMP_EXACT; 84 for (i = 0; i < len; i++) { 85 if (args->name[i] == name[i]) 86 continue; 87 if (tolower(args->name[i]) != tolower(name[i])) 88 return XFS_CMP_DIFFERENT; 89 result = XFS_CMP_CASE; 90 } 91 92 return result; 93 } 94 95 static struct xfs_nameops xfs_ascii_ci_nameops = { 96 .hashname = xfs_ascii_ci_hashname, 97 .compname = xfs_ascii_ci_compname, 98 }; 99 100 int 101 xfs_da_mount( 102 struct xfs_mount *mp) 103 { 104 struct xfs_da_geometry *dageo; 105 int nodehdr_size; 106 107 108 ASSERT(mp->m_sb.sb_versionnum & XFS_SB_VERSION_DIRV2BIT); 109 ASSERT((1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog)) <= 110 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 = 1 << dageo->blklog; 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(dp->i_d.di_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 xfs_agblock_t agblkno; 197 xfs_agino_t agino; 198 xfs_agnumber_t agno; 199 int ino_ok; 200 int ioff; 201 202 agno = XFS_INO_TO_AGNO(mp, ino); 203 agblkno = XFS_INO_TO_AGBNO(mp, ino); 204 ioff = XFS_INO_TO_OFFSET(mp, ino); 205 agino = XFS_OFFBNO_TO_AGINO(mp, agblkno, ioff); 206 ino_ok = 207 agno < mp->m_sb.sb_agcount && 208 agblkno < mp->m_sb.sb_agblocks && 209 agblkno != 0 && 210 ioff < (1 << mp->m_sb.sb_inopblog) && 211 XFS_AGINO_TO_INO(mp, agno, agino) == ino; 212 if (unlikely(XFS_TEST_ERROR(!ino_ok, mp, XFS_ERRTAG_DIR_INO_VALIDATE, 213 XFS_RANDOM_DIR_INO_VALIDATE))) { 214 xfs_warn(mp, "Invalid inode number 0x%Lx", 215 (unsigned long long) ino); 216 XFS_ERROR_REPORT("xfs_dir_ino_validate", XFS_ERRLEVEL_LOW, mp); 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(dp->i_d.di_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_SLEEP | 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 xfs_trans_t *tp, 258 xfs_inode_t *dp, 259 struct xfs_name *name, 260 xfs_ino_t inum, /* new entry inode number */ 261 xfs_fsblock_t *first, /* bmap's firstblock */ 262 xfs_bmap_free_t *flist, /* bmap's freeblock list */ 263 xfs_extlen_t total) /* bmap's total block count */ 264 { 265 struct xfs_da_args *args; 266 int rval; 267 int v; /* type-checking value */ 268 269 ASSERT(S_ISDIR(dp->i_d.di_mode)); 270 if (inum) { 271 rval = xfs_dir_ino_validate(tp->t_mountp, inum); 272 if (rval) 273 return rval; 274 XFS_STATS_INC(dp->i_mount, xs_dir_create); 275 } 276 277 args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS); 278 if (!args) 279 return -ENOMEM; 280 281 args->geo = dp->i_mount->m_dir_geo; 282 args->name = name->name; 283 args->namelen = name->len; 284 args->filetype = name->type; 285 args->hashval = dp->i_mount->m_dirnameops->hashname(name); 286 args->inumber = inum; 287 args->dp = dp; 288 args->firstblock = first; 289 args->flist = flist; 290 args->total = total; 291 args->whichfork = XFS_DATA_FORK; 292 args->trans = tp; 293 args->op_flags = XFS_DA_OP_ADDNAME | XFS_DA_OP_OKNOENT; 294 if (!inum) 295 args->op_flags |= XFS_DA_OP_JUSTCHECK; 296 297 if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) { 298 rval = xfs_dir2_sf_addname(args); 299 goto out_free; 300 } 301 302 rval = xfs_dir2_isblock(args, &v); 303 if (rval) 304 goto out_free; 305 if (v) { 306 rval = xfs_dir2_block_addname(args); 307 goto out_free; 308 } 309 310 rval = xfs_dir2_isleaf(args, &v); 311 if (rval) 312 goto out_free; 313 if (v) 314 rval = xfs_dir2_leaf_addname(args); 315 else 316 rval = xfs_dir2_node_addname(args); 317 318 out_free: 319 kmem_free(args); 320 return rval; 321 } 322 323 /* 324 * If doing a CI lookup and case-insensitive match, dup actual name into 325 * args.value. Return EEXIST for success (ie. name found) or an error. 326 */ 327 int 328 xfs_dir_cilookup_result( 329 struct xfs_da_args *args, 330 const unsigned char *name, 331 int len) 332 { 333 if (args->cmpresult == XFS_CMP_DIFFERENT) 334 return -ENOENT; 335 if (args->cmpresult != XFS_CMP_CASE || 336 !(args->op_flags & XFS_DA_OP_CILOOKUP)) 337 return -EEXIST; 338 339 args->value = kmem_alloc(len, KM_NOFS | KM_MAYFAIL); 340 if (!args->value) 341 return -ENOMEM; 342 343 memcpy(args->value, name, len); 344 args->valuelen = len; 345 return -EEXIST; 346 } 347 348 /* 349 * Lookup a name in a directory, give back the inode number. 350 * If ci_name is not NULL, returns the actual name in ci_name if it differs 351 * to name, or ci_name->name is set to NULL for an exact match. 352 */ 353 354 int 355 xfs_dir_lookup( 356 xfs_trans_t *tp, 357 xfs_inode_t *dp, 358 struct xfs_name *name, 359 xfs_ino_t *inum, /* out: inode number */ 360 struct xfs_name *ci_name) /* out: actual name if CI match */ 361 { 362 struct xfs_da_args *args; 363 int rval; 364 int v; /* type-checking value */ 365 int lock_mode; 366 367 ASSERT(S_ISDIR(dp->i_d.di_mode)); 368 XFS_STATS_INC(dp->i_mount, xs_dir_lookup); 369 370 /* 371 * We need to use KM_NOFS here so that lockdep will not throw false 372 * positive deadlock warnings on a non-transactional lookup path. It is 373 * safe to recurse into inode recalim in that case, but lockdep can't 374 * easily be taught about it. Hence KM_NOFS avoids having to add more 375 * lockdep Doing this avoids having to add a bunch of lockdep class 376 * annotations into the reclaim path for the ilock. 377 */ 378 args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS); 379 args->geo = dp->i_mount->m_dir_geo; 380 args->name = name->name; 381 args->namelen = name->len; 382 args->filetype = name->type; 383 args->hashval = dp->i_mount->m_dirnameops->hashname(name); 384 args->dp = dp; 385 args->whichfork = XFS_DATA_FORK; 386 args->trans = tp; 387 args->op_flags = XFS_DA_OP_OKNOENT; 388 if (ci_name) 389 args->op_flags |= XFS_DA_OP_CILOOKUP; 390 391 lock_mode = xfs_ilock_data_map_shared(dp); 392 if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) { 393 rval = xfs_dir2_sf_lookup(args); 394 goto out_check_rval; 395 } 396 397 rval = xfs_dir2_isblock(args, &v); 398 if (rval) 399 goto out_free; 400 if (v) { 401 rval = xfs_dir2_block_lookup(args); 402 goto out_check_rval; 403 } 404 405 rval = xfs_dir2_isleaf(args, &v); 406 if (rval) 407 goto out_free; 408 if (v) 409 rval = xfs_dir2_leaf_lookup(args); 410 else 411 rval = xfs_dir2_node_lookup(args); 412 413 out_check_rval: 414 if (rval == -EEXIST) 415 rval = 0; 416 if (!rval) { 417 *inum = args->inumber; 418 if (ci_name) { 419 ci_name->name = args->value; 420 ci_name->len = args->valuelen; 421 } 422 } 423 out_free: 424 xfs_iunlock(dp, lock_mode); 425 kmem_free(args); 426 return rval; 427 } 428 429 /* 430 * Remove an entry from a directory. 431 */ 432 int 433 xfs_dir_removename( 434 xfs_trans_t *tp, 435 xfs_inode_t *dp, 436 struct xfs_name *name, 437 xfs_ino_t ino, 438 xfs_fsblock_t *first, /* bmap's firstblock */ 439 xfs_bmap_free_t *flist, /* bmap's freeblock list */ 440 xfs_extlen_t total) /* bmap's total block count */ 441 { 442 struct xfs_da_args *args; 443 int rval; 444 int v; /* type-checking value */ 445 446 ASSERT(S_ISDIR(dp->i_d.di_mode)); 447 XFS_STATS_INC(dp->i_mount, xs_dir_remove); 448 449 args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS); 450 if (!args) 451 return -ENOMEM; 452 453 args->geo = dp->i_mount->m_dir_geo; 454 args->name = name->name; 455 args->namelen = name->len; 456 args->filetype = name->type; 457 args->hashval = dp->i_mount->m_dirnameops->hashname(name); 458 args->inumber = ino; 459 args->dp = dp; 460 args->firstblock = first; 461 args->flist = flist; 462 args->total = total; 463 args->whichfork = XFS_DATA_FORK; 464 args->trans = tp; 465 466 if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) { 467 rval = xfs_dir2_sf_removename(args); 468 goto out_free; 469 } 470 471 rval = xfs_dir2_isblock(args, &v); 472 if (rval) 473 goto out_free; 474 if (v) { 475 rval = xfs_dir2_block_removename(args); 476 goto out_free; 477 } 478 479 rval = xfs_dir2_isleaf(args, &v); 480 if (rval) 481 goto out_free; 482 if (v) 483 rval = xfs_dir2_leaf_removename(args); 484 else 485 rval = xfs_dir2_node_removename(args); 486 out_free: 487 kmem_free(args); 488 return rval; 489 } 490 491 /* 492 * Replace the inode number of a directory entry. 493 */ 494 int 495 xfs_dir_replace( 496 xfs_trans_t *tp, 497 xfs_inode_t *dp, 498 struct xfs_name *name, /* name of entry to replace */ 499 xfs_ino_t inum, /* new inode number */ 500 xfs_fsblock_t *first, /* bmap's firstblock */ 501 xfs_bmap_free_t *flist, /* bmap's freeblock list */ 502 xfs_extlen_t total) /* bmap's total block count */ 503 { 504 struct xfs_da_args *args; 505 int rval; 506 int v; /* type-checking value */ 507 508 ASSERT(S_ISDIR(dp->i_d.di_mode)); 509 510 rval = xfs_dir_ino_validate(tp->t_mountp, inum); 511 if (rval) 512 return rval; 513 514 args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS); 515 if (!args) 516 return -ENOMEM; 517 518 args->geo = dp->i_mount->m_dir_geo; 519 args->name = name->name; 520 args->namelen = name->len; 521 args->filetype = name->type; 522 args->hashval = dp->i_mount->m_dirnameops->hashname(name); 523 args->inumber = inum; 524 args->dp = dp; 525 args->firstblock = first; 526 args->flist = flist; 527 args->total = total; 528 args->whichfork = XFS_DATA_FORK; 529 args->trans = tp; 530 531 if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) { 532 rval = xfs_dir2_sf_replace(args); 533 goto out_free; 534 } 535 536 rval = xfs_dir2_isblock(args, &v); 537 if (rval) 538 goto out_free; 539 if (v) { 540 rval = xfs_dir2_block_replace(args); 541 goto out_free; 542 } 543 544 rval = xfs_dir2_isleaf(args, &v); 545 if (rval) 546 goto out_free; 547 if (v) 548 rval = xfs_dir2_leaf_replace(args); 549 else 550 rval = xfs_dir2_node_replace(args); 551 out_free: 552 kmem_free(args); 553 return rval; 554 } 555 556 /* 557 * See if this entry can be added to the directory without allocating space. 558 */ 559 int 560 xfs_dir_canenter( 561 xfs_trans_t *tp, 562 xfs_inode_t *dp, 563 struct xfs_name *name) /* name of entry to add */ 564 { 565 return xfs_dir_createname(tp, dp, name, 0, NULL, NULL, 0); 566 } 567 568 /* 569 * Utility routines. 570 */ 571 572 /* 573 * Add a block to the directory. 574 * 575 * This routine is for data and free blocks, not leaf/node blocks which are 576 * handled by xfs_da_grow_inode. 577 */ 578 int 579 xfs_dir2_grow_inode( 580 struct xfs_da_args *args, 581 int space, /* v2 dir's space XFS_DIR2_xxx_SPACE */ 582 xfs_dir2_db_t *dbp) /* out: block number added */ 583 { 584 struct xfs_inode *dp = args->dp; 585 struct xfs_mount *mp = dp->i_mount; 586 xfs_fileoff_t bno; /* directory offset of new block */ 587 int count; /* count of filesystem blocks */ 588 int error; 589 590 trace_xfs_dir2_grow_inode(args, space); 591 592 /* 593 * Set lowest possible block in the space requested. 594 */ 595 bno = XFS_B_TO_FSBT(mp, space * XFS_DIR2_SPACE_SIZE); 596 count = args->geo->fsbcount; 597 598 error = xfs_da_grow_inode_int(args, &bno, count); 599 if (error) 600 return error; 601 602 *dbp = xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)bno); 603 604 /* 605 * Update file's size if this is the data space and it grew. 606 */ 607 if (space == XFS_DIR2_DATA_SPACE) { 608 xfs_fsize_t size; /* directory file (data) size */ 609 610 size = XFS_FSB_TO_B(mp, bno + count); 611 if (size > dp->i_d.di_size) { 612 dp->i_d.di_size = size; 613 xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE); 614 } 615 } 616 return 0; 617 } 618 619 /* 620 * See if the directory is a single-block form directory. 621 */ 622 int 623 xfs_dir2_isblock( 624 struct xfs_da_args *args, 625 int *vp) /* out: 1 is block, 0 is not block */ 626 { 627 xfs_fileoff_t last; /* last file offset */ 628 int rval; 629 630 if ((rval = xfs_bmap_last_offset(args->dp, &last, XFS_DATA_FORK))) 631 return rval; 632 rval = XFS_FSB_TO_B(args->dp->i_mount, last) == args->geo->blksize; 633 ASSERT(rval == 0 || args->dp->i_d.di_size == args->geo->blksize); 634 *vp = rval; 635 return 0; 636 } 637 638 /* 639 * See if the directory is a single-leaf form directory. 640 */ 641 int 642 xfs_dir2_isleaf( 643 struct xfs_da_args *args, 644 int *vp) /* out: 1 is block, 0 is not block */ 645 { 646 xfs_fileoff_t last; /* last file offset */ 647 int rval; 648 649 if ((rval = xfs_bmap_last_offset(args->dp, &last, XFS_DATA_FORK))) 650 return rval; 651 *vp = last == args->geo->leafblk + args->geo->fsbcount; 652 return 0; 653 } 654 655 /* 656 * Remove the given block from the directory. 657 * This routine is used for data and free blocks, leaf/node are done 658 * by xfs_da_shrink_inode. 659 */ 660 int 661 xfs_dir2_shrink_inode( 662 xfs_da_args_t *args, 663 xfs_dir2_db_t db, 664 struct xfs_buf *bp) 665 { 666 xfs_fileoff_t bno; /* directory file offset */ 667 xfs_dablk_t da; /* directory file offset */ 668 int done; /* bunmap is finished */ 669 xfs_inode_t *dp; 670 int error; 671 xfs_mount_t *mp; 672 xfs_trans_t *tp; 673 674 trace_xfs_dir2_shrink_inode(args, db); 675 676 dp = args->dp; 677 mp = dp->i_mount; 678 tp = args->trans; 679 da = xfs_dir2_db_to_da(args->geo, db); 680 681 /* Unmap the fsblock(s). */ 682 error = xfs_bunmapi(tp, dp, da, args->geo->fsbcount, 0, 0, 683 args->firstblock, args->flist, &done); 684 if (error) { 685 /* 686 * ENOSPC actually can happen if we're in a removename with no 687 * space reservation, and the resulting block removal would 688 * cause a bmap btree split or conversion from extents to btree. 689 * This can only happen for un-fragmented directory blocks, 690 * since you need to be punching out the middle of an extent. 691 * In this case we need to leave the block in the file, and not 692 * binval it. So the block has to be in a consistent empty 693 * state and appropriately logged. We don't free up the buffer, 694 * the caller can tell it hasn't happened since it got an error 695 * back. 696 */ 697 return error; 698 } 699 ASSERT(done); 700 /* 701 * Invalidate the buffer from the transaction. 702 */ 703 xfs_trans_binval(tp, bp); 704 /* 705 * If it's not a data block, we're done. 706 */ 707 if (db >= xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET)) 708 return 0; 709 /* 710 * If the block isn't the last one in the directory, we're done. 711 */ 712 if (dp->i_d.di_size > xfs_dir2_db_off_to_byte(args->geo, db + 1, 0)) 713 return 0; 714 bno = da; 715 if ((error = xfs_bmap_last_before(tp, dp, &bno, XFS_DATA_FORK))) { 716 /* 717 * This can't really happen unless there's kernel corruption. 718 */ 719 return error; 720 } 721 if (db == args->geo->datablk) 722 ASSERT(bno == 0); 723 else 724 ASSERT(bno > 0); 725 /* 726 * Set the size to the new last block. 727 */ 728 dp->i_d.di_size = XFS_FSB_TO_B(mp, bno); 729 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE); 730 return 0; 731 } 732