fs/xfs/libxfs/xfs_dir2.c

   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         struct xfs_trans        *tp,
 243         struct xfs_inode        *dp,
 244         struct xfs_name         *name,
 245         xfs_ino_t               inum,           /* new entry inode number */
 246         xfs_extlen_t            total)          /* bmap's total block count */
 247 {
 248         struct xfs_da_args      *args;
 249         int                     rval;
 250         int                     v;              /* type-checking value */
 251
 252         ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
 253
 254         if (inum) {
 255                 rval = xfs_dir_ino_validate(tp->t_mountp, inum);
 256                 if (rval)
 257                         return rval;
 258                 XFS_STATS_INC(dp->i_mount, xs_dir_create);
 259         }
 260
 261         args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
 262         if (!args)
 263                 return -ENOMEM;
 264
 265         args->geo = dp->i_mount->m_dir_geo;
 266         args->name = name->name;
 267         args->namelen = name->len;
 268         args->filetype = name->type;
 269         args->hashval = dp->i_mount->m_dirnameops->hashname(name);
 270         args->inumber = inum;
 271         args->dp = dp;
 272         args->total = total;
 273         args->whichfork = XFS_DATA_FORK;
 274         args->trans = tp;
 275         args->op_flags = XFS_DA_OP_ADDNAME | XFS_DA_OP_OKNOENT;
 276         if (!inum)
 277                 args->op_flags |= XFS_DA_OP_JUSTCHECK;
 278
 279         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
 280                 rval = xfs_dir2_sf_addname(args);
 281                 goto out_free;
 282         }
 283
 284         rval = xfs_dir2_isblock(args, &v);
 285         if (rval)
 286                 goto out_free;
 287         if (v) {
 288                 rval = xfs_dir2_block_addname(args);
 289                 goto out_free;
 290         }
 291
 292         rval = xfs_dir2_isleaf(args, &v);
 293         if (rval)
 294                 goto out_free;
 295         if (v)
 296                 rval = xfs_dir2_leaf_addname(args);
 297         else
 298                 rval = xfs_dir2_node_addname(args);
 299
 300 out_free:
 301         kmem_free(args);
 302         return rval;
 303 }
 304
 305 /*
 306  * If doing a CI lookup and case-insensitive match, dup actual name into
 307  * args.value. Return EEXIST for success (ie. name found) or an error.
 308  */
 309 int
 310 xfs_dir_cilookup_result(
 311         struct xfs_da_args *args,
 312         const unsigned char *name,
 313         int             len)
 314 {
 315         if (args->cmpresult == XFS_CMP_DIFFERENT)
 316                 return -ENOENT;
 317         if (args->cmpresult != XFS_CMP_CASE ||
 318                                         !(args->op_flags & XFS_DA_OP_CILOOKUP))
 319                 return -EEXIST;
 320
 321         args->value = kmem_alloc(len, KM_NOFS | KM_MAYFAIL);
 322         if (!args->value)
 323                 return -ENOMEM;
 324
 325         memcpy(args->value, name, len);
 326         args->valuelen = len;
 327         return -EEXIST;
 328 }
 329
 330 /*
 331  * Lookup a name in a directory, give back the inode number.
 332  * If ci_name is not NULL, returns the actual name in ci_name if it differs
 333  * to name, or ci_name->name is set to NULL for an exact match.
 334  */
 335
 336 int
 337 xfs_dir_lookup(
 338         xfs_trans_t     *tp,
 339         xfs_inode_t     *dp,
 340         struct xfs_name *name,
 341         xfs_ino_t       *inum,          /* out: inode number */
 342         struct xfs_name *ci_name)       /* out: actual name if CI match */
 343 {
 344         struct xfs_da_args *args;
 345         int             rval;
 346         int             v;              /* type-checking value */
 347         int             lock_mode;
 348
 349         ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
 350         XFS_STATS_INC(dp->i_mount, xs_dir_lookup);
 351
 352         /*
 353          * We need to use KM_NOFS here so that lockdep will not throw false
 354          * positive deadlock warnings on a non-transactional lookup path. It is
 355          * safe to recurse into inode recalim in that case, but lockdep can't
 356          * easily be taught about it. Hence KM_NOFS avoids having to add more
 357          * lockdep Doing this avoids having to add a bunch of lockdep class
 358          * annotations into the reclaim path for the ilock.
 359          */
 360         args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
 361         args->geo = dp->i_mount->m_dir_geo;
 362         args->name = name->name;
 363         args->namelen = name->len;
 364         args->filetype = name->type;
 365         args->hashval = dp->i_mount->m_dirnameops->hashname(name);
 366         args->dp = dp;
 367         args->whichfork = XFS_DATA_FORK;
 368         args->trans = tp;
 369         args->op_flags = XFS_DA_OP_OKNOENT;
 370         if (ci_name)
 371                 args->op_flags |= XFS_DA_OP_CILOOKUP;
 372
 373         lock_mode = xfs_ilock_data_map_shared(dp);
 374         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
 375                 rval = xfs_dir2_sf_lookup(args);
 376                 goto out_check_rval;
 377         }
 378
 379         rval = xfs_dir2_isblock(args, &v);
 380         if (rval)
 381                 goto out_free;
 382         if (v) {
 383                 rval = xfs_dir2_block_lookup(args);
 384                 goto out_check_rval;
 385         }
 386
 387         rval = xfs_dir2_isleaf(args, &v);
 388         if (rval)
 389                 goto out_free;
 390         if (v)
 391                 rval = xfs_dir2_leaf_lookup(args);
 392         else
 393                 rval = xfs_dir2_node_lookup(args);
 394
 395 out_check_rval:
 396         if (rval == -EEXIST)
 397                 rval = 0;
 398         if (!rval) {
 399                 *inum = args->inumber;
 400                 if (ci_name) {
 401                         ci_name->name = args->value;
 402                         ci_name->len = args->valuelen;
 403                 }
 404         }
 405 out_free:
 406         xfs_iunlock(dp, lock_mode);
 407         kmem_free(args);
 408         return rval;
 409 }
 410
 411 /*
 412  * Remove an entry from a directory.
 413  */
 414 int
 415 xfs_dir_removename(
 416         struct xfs_trans        *tp,
 417         struct xfs_inode        *dp,
 418         struct xfs_name         *name,
 419         xfs_ino_t               ino,
 420         xfs_extlen_t            total)          /* bmap's total block count */
 421 {
 422         struct xfs_da_args      *args;
 423         int                     rval;
 424         int                     v;              /* type-checking value */
 425
 426         ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
 427         XFS_STATS_INC(dp->i_mount, xs_dir_remove);
 428
 429         args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
 430         if (!args)
 431                 return -ENOMEM;
 432
 433         args->geo = dp->i_mount->m_dir_geo;
 434         args->name = name->name;
 435         args->namelen = name->len;
 436         args->filetype = name->type;
 437         args->hashval = dp->i_mount->m_dirnameops->hashname(name);
 438         args->inumber = ino;
 439         args->dp = dp;
 440         args->total = total;
 441         args->whichfork = XFS_DATA_FORK;
 442         args->trans = tp;
 443
 444         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
 445                 rval = xfs_dir2_sf_removename(args);
 446                 goto out_free;
 447         }
 448
 449         rval = xfs_dir2_isblock(args, &v);
 450         if (rval)
 451                 goto out_free;
 452         if (v) {
 453                 rval = xfs_dir2_block_removename(args);
 454                 goto out_free;
 455         }
 456
 457         rval = xfs_dir2_isleaf(args, &v);
 458         if (rval)
 459                 goto out_free;
 460         if (v)
 461                 rval = xfs_dir2_leaf_removename(args);
 462         else
 463                 rval = xfs_dir2_node_removename(args);
 464 out_free:
 465         kmem_free(args);
 466         return rval;
 467 }
 468
 469 /*
 470  * Replace the inode number of a directory entry.
 471  */
 472 int
 473 xfs_dir_replace(
 474         struct xfs_trans        *tp,
 475         struct xfs_inode        *dp,
 476         struct xfs_name         *name,          /* name of entry to replace */
 477         xfs_ino_t               inum,           /* new inode number */
 478         xfs_extlen_t            total)          /* bmap's total block count */
 479 {
 480         struct xfs_da_args      *args;
 481         int                     rval;
 482         int                     v;              /* type-checking value */
 483
 484         ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
 485
 486         rval = xfs_dir_ino_validate(tp->t_mountp, inum);
 487         if (rval)
 488                 return rval;
 489
 490         args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
 491         if (!args)
 492                 return -ENOMEM;
 493
 494         args->geo = dp->i_mount->m_dir_geo;
 495         args->name = name->name;
 496         args->namelen = name->len;
 497         args->filetype = name->type;
 498         args->hashval = dp->i_mount->m_dirnameops->hashname(name);
 499         args->inumber = inum;
 500         args->dp = dp;
 501         args->total = total;
 502         args->whichfork = XFS_DATA_FORK;
 503         args->trans = tp;
 504
 505         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
 506                 rval = xfs_dir2_sf_replace(args);
 507                 goto out_free;
 508         }
 509
 510         rval = xfs_dir2_isblock(args, &v);
 511         if (rval)
 512                 goto out_free;
 513         if (v) {
 514                 rval = xfs_dir2_block_replace(args);
 515                 goto out_free;
 516         }
 517
 518         rval = xfs_dir2_isleaf(args, &v);
 519         if (rval)
 520                 goto out_free;
 521         if (v)
 522                 rval = xfs_dir2_leaf_replace(args);
 523         else
 524                 rval = xfs_dir2_node_replace(args);
 525 out_free:
 526         kmem_free(args);
 527         return rval;
 528 }
 529
 530 /*
 531  * See if this entry can be added to the directory without allocating space.
 532  */
 533 int
 534 xfs_dir_canenter(
 535         xfs_trans_t     *tp,
 536         xfs_inode_t     *dp,
 537         struct xfs_name *name)          /* name of entry to add */
 538 {
 539         return xfs_dir_createname(tp, dp, name, 0, 0);
 540 }
 541
 542 /*
 543  * Utility routines.
 544  */
 545
 546 /*
 547  * Add a block to the directory.
 548  *
 549  * This routine is for data and free blocks, not leaf/node blocks which are
 550  * handled by xfs_da_grow_inode.
 551  */
 552 int
 553 xfs_dir2_grow_inode(
 554         struct xfs_da_args      *args,
 555         int                     space,  /* v2 dir's space XFS_DIR2_xxx_SPACE */
 556         xfs_dir2_db_t           *dbp)   /* out: block number added */
 557 {
 558         struct xfs_inode        *dp = args->dp;
 559         struct xfs_mount        *mp = dp->i_mount;
 560         xfs_fileoff_t           bno;    /* directory offset of new block */
 561         int                     count;  /* count of filesystem blocks */
 562         int                     error;
 563
 564         trace_xfs_dir2_grow_inode(args, space);
 565
 566         /*
 567          * Set lowest possible block in the space requested.
 568          */
 569         bno = XFS_B_TO_FSBT(mp, space * XFS_DIR2_SPACE_SIZE);
 570         count = args->geo->fsbcount;
 571
 572         error = xfs_da_grow_inode_int(args, &bno, count);
 573         if (error)
 574                 return error;
 575
 576         *dbp = xfs_dir2_da_to_db(args->geo, (xfs_dablk_t)bno);
 577
 578         /*
 579          * Update file's size if this is the data space and it grew.
 580          */
 581         if (space == XFS_DIR2_DATA_SPACE) {
 582                 xfs_fsize_t     size;           /* directory file (data) size */
 583
 584                 size = XFS_FSB_TO_B(mp, bno + count);
 585                 if (size > dp->i_d.di_size) {
 586                         dp->i_d.di_size = size;
 587                         xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE);
 588                 }
 589         }
 590         return 0;
 591 }
 592
 593 /*
 594  * See if the directory is a single-block form directory.
 595  */
 596 int
 597 xfs_dir2_isblock(
 598         struct xfs_da_args      *args,
 599         int                     *vp)    /* out: 1 is block, 0 is not block */
 600 {
 601         xfs_fileoff_t           last;   /* last file offset */
 602         int                     rval;
 603
 604         if ((rval = xfs_bmap_last_offset(args->dp, &last, XFS_DATA_FORK)))
 605                 return rval;
 606         rval = XFS_FSB_TO_B(args->dp->i_mount, last) == args->geo->blksize;
 607         if (rval != 0 && args->dp->i_d.di_size != args->geo->blksize)
 608                 return -EFSCORRUPTED;
 609         *vp = rval;
 610         return 0;
 611 }
 612
 613 /*
 614  * See if the directory is a single-leaf form directory.
 615  */
 616 int
 617 xfs_dir2_isleaf(
 618         struct xfs_da_args      *args,
 619         int                     *vp)    /* out: 1 is block, 0 is not block */
 620 {
 621         xfs_fileoff_t           last;   /* last file offset */
 622         int                     rval;
 623
 624         if ((rval = xfs_bmap_last_offset(args->dp, &last, XFS_DATA_FORK)))
 625                 return rval;
 626         *vp = last == args->geo->leafblk + args->geo->fsbcount;
 627         return 0;
 628 }
 629
 630 /*
 631  * Remove the given block from the directory.
 632  * This routine is used for data and free blocks, leaf/node are done
 633  * by xfs_da_shrink_inode.
 634  */
 635 int
 636 xfs_dir2_shrink_inode(
 637         struct xfs_da_args      *args,
 638         xfs_dir2_db_t           db,
 639         struct xfs_buf          *bp)
 640 {
 641         xfs_fileoff_t           bno;            /* directory file offset */
 642         xfs_dablk_t             da;             /* directory file offset */
 643         int                     done;           /* bunmap is finished */
 644         struct xfs_inode        *dp;
 645         int                     error;
 646         struct xfs_mount        *mp;
 647         struct xfs_trans        *tp;
 648
 649         trace_xfs_dir2_shrink_inode(args, db);
 650
 651         dp = args->dp;
 652         mp = dp->i_mount;
 653         tp = args->trans;
 654         da = xfs_dir2_db_to_da(args->geo, db);
 655
 656         /* Unmap the fsblock(s). */
 657         error = xfs_bunmapi(tp, dp, da, args->geo->fsbcount, 0, 0, &done);
 658         if (error) {
 659                 /*
 660                  * ENOSPC actually can happen if we're in a removename with no
 661                  * space reservation, and the resulting block removal would
 662                  * cause a bmap btree split or conversion from extents to btree.
 663                  * This can only happen for un-fragmented directory blocks,
 664                  * since you need to be punching out the middle of an extent.
 665                  * In this case we need to leave the block in the file, and not
 666                  * binval it.  So the block has to be in a consistent empty
 667                  * state and appropriately logged.  We don't free up the buffer,
 668                  * the caller can tell it hasn't happened since it got an error
 669                  * back.
 670                  */
 671                 return error;
 672         }
 673         ASSERT(done);
 674         /*
 675          * Invalidate the buffer from the transaction.
 676          */
 677         xfs_trans_binval(tp, bp);
 678         /*
 679          * If it's not a data block, we're done.
 680          */
 681         if (db >= xfs_dir2_byte_to_db(args->geo, XFS_DIR2_LEAF_OFFSET))
 682                 return 0;
 683         /*
 684          * If the block isn't the last one in the directory, we're done.
 685          */
 686         if (dp->i_d.di_size > xfs_dir2_db_off_to_byte(args->geo, db + 1, 0))
 687                 return 0;
 688         bno = da;
 689         if ((error = xfs_bmap_last_before(tp, dp, &bno, XFS_DATA_FORK))) {
 690                 /*
 691                  * This can't really happen unless there's kernel corruption.
 692                  */
 693                 return error;
 694         }
 695         if (db == args->geo->datablk)
 696                 ASSERT(bno == 0);
 697         else
 698                 ASSERT(bno > 0);
 699         /*
 700          * Set the size to the new last block.
 701          */
 702         dp->i_d.di_size = XFS_FSB_TO_B(mp, bno);
 703         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
 704         return 0;
 705 }