fs/xfs/xfs_dir2.c

   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_types.h"
  21 #include "xfs_bit.h"
  22 #include "xfs_log.h"
  23 #include "xfs_inum.h"
  24 #include "xfs_trans.h"
  25 #include "xfs_sb.h"
  26 #include "xfs_ag.h"
  27 #include "xfs_dir2.h"
  28 #include "xfs_dmapi.h"
  29 #include "xfs_mount.h"
  30 #include "xfs_da_btree.h"
  31 #include "xfs_bmap_btree.h"
  32 #include "xfs_alloc_btree.h"
  33 #include "xfs_dir2_sf.h"
  34 #include "xfs_attr_sf.h"
  35 #include "xfs_dinode.h"
  36 #include "xfs_inode.h"
  37 #include "xfs_inode_item.h"
  38 #include "xfs_bmap.h"
  39 #include "xfs_dir2_data.h"
  40 #include "xfs_dir2_leaf.h"
  41 #include "xfs_dir2_block.h"
  42 #include "xfs_dir2_node.h"
  43 #include "xfs_dir2_trace.h"
  44 #include "xfs_error.h"
  45 #include "xfs_vnodeops.h"
  46
  47 struct xfs_name xfs_name_dotdot = {"..", 2};
  48
  49 void
  50 xfs_dir_mount(
  51         xfs_mount_t     *mp)
  52 {
  53         ASSERT(xfs_sb_version_hasdirv2(&mp->m_sb));
  54         ASSERT((1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog)) <=
  55                XFS_MAX_BLOCKSIZE);
  56         mp->m_dirblksize = 1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog);
  57         mp->m_dirblkfsbs = 1 << mp->m_sb.sb_dirblklog;
  58         mp->m_dirdatablk = xfs_dir2_db_to_da(mp, XFS_DIR2_DATA_FIRSTDB(mp));
  59         mp->m_dirleafblk = xfs_dir2_db_to_da(mp, XFS_DIR2_LEAF_FIRSTDB(mp));
  60         mp->m_dirfreeblk = xfs_dir2_db_to_da(mp, XFS_DIR2_FREE_FIRSTDB(mp));
  61         mp->m_attr_node_ents =
  62                 (mp->m_sb.sb_blocksize - (uint)sizeof(xfs_da_node_hdr_t)) /
  63                 (uint)sizeof(xfs_da_node_entry_t);
  64         mp->m_dir_node_ents =
  65                 (mp->m_dirblksize - (uint)sizeof(xfs_da_node_hdr_t)) /
  66                 (uint)sizeof(xfs_da_node_entry_t);
  67         mp->m_dir_magicpct = (mp->m_dirblksize * 37) / 100;
  68 }
  69
  70 /*
  71  * Return 1 if directory contains only "." and "..".
  72  */
  73 int
  74 xfs_dir_isempty(
  75         xfs_inode_t     *dp)
  76 {
  77         xfs_dir2_sf_t   *sfp;
  78
  79         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
  80         if (dp->i_d.di_size == 0)       /* might happen during shutdown. */
  81                 return 1;
  82         if (dp->i_d.di_size > XFS_IFORK_DSIZE(dp))
  83                 return 0;
  84         sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
  85         return !sfp->hdr.count;
  86 }
  87
  88 /*
  89  * Validate a given inode number.
  90  */
  91 int
  92 xfs_dir_ino_validate(
  93         xfs_mount_t     *mp,
  94         xfs_ino_t       ino)
  95 {
  96         xfs_agblock_t   agblkno;
  97         xfs_agino_t     agino;
  98         xfs_agnumber_t  agno;
  99         int             ino_ok;
 100         int             ioff;
 101
 102         agno = XFS_INO_TO_AGNO(mp, ino);
 103         agblkno = XFS_INO_TO_AGBNO(mp, ino);
 104         ioff = XFS_INO_TO_OFFSET(mp, ino);
 105         agino = XFS_OFFBNO_TO_AGINO(mp, agblkno, ioff);
 106         ino_ok =
 107                 agno < mp->m_sb.sb_agcount &&
 108                 agblkno < mp->m_sb.sb_agblocks &&
 109                 agblkno != 0 &&
 110                 ioff < (1 << mp->m_sb.sb_inopblog) &&
 111                 XFS_AGINO_TO_INO(mp, agno, agino) == ino;
 112         if (unlikely(XFS_TEST_ERROR(!ino_ok, mp, XFS_ERRTAG_DIR_INO_VALIDATE,
 113                         XFS_RANDOM_DIR_INO_VALIDATE))) {
 114                 xfs_fs_cmn_err(CE_WARN, mp, "Invalid inode number 0x%Lx",
 115                                 (unsigned long long) ino);
 116                 XFS_ERROR_REPORT("xfs_dir_ino_validate", XFS_ERRLEVEL_LOW, mp);
 117                 return XFS_ERROR(EFSCORRUPTED);
 118         }
 119         return 0;
 120 }
 121
 122 /*
 123  * Initialize a directory with its "." and ".." entries.
 124  */
 125 int
 126 xfs_dir_init(
 127         xfs_trans_t     *tp,
 128         xfs_inode_t     *dp,
 129         xfs_inode_t     *pdp)
 130 {
 131         xfs_da_args_t   args;
 132         int             error;
 133
 134         memset((char *)&args, 0, sizeof(args));
 135         args.dp = dp;
 136         args.trans = tp;
 137         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 138         if ((error = xfs_dir_ino_validate(tp->t_mountp, pdp->i_ino)))
 139                 return error;
 140         return xfs_dir2_sf_create(&args, pdp->i_ino);
 141 }
 142
 143 /*
 144   Enter a name in a directory.
 145  */
 146 int
 147 xfs_dir_createname(
 148         xfs_trans_t             *tp,
 149         xfs_inode_t             *dp,
 150         struct xfs_name         *name,
 151         xfs_ino_t               inum,           /* new entry inode number */
 152         xfs_fsblock_t           *first,         /* bmap's firstblock */
 153         xfs_bmap_free_t         *flist,         /* bmap's freeblock list */
 154         xfs_extlen_t            total)          /* bmap's total block count */
 155 {
 156         xfs_da_args_t           args;
 157         int                     rval;
 158         int                     v;              /* type-checking value */
 159
 160         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 161         if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum)))
 162                 return rval;
 163         XFS_STATS_INC(xs_dir_create);
 164
 165         args.name = name->name;
 166         args.namelen = name->len;
 167         args.hashval = xfs_da_hashname(name->name, name->len);
 168         args.inumber = inum;
 169         args.dp = dp;
 170         args.firstblock = first;
 171         args.flist = flist;
 172         args.total = total;
 173         args.whichfork = XFS_DATA_FORK;
 174         args.trans = tp;
 175         args.justcheck = 0;
 176         args.addname = args.oknoent = 1;
 177
 178         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
 179                 rval = xfs_dir2_sf_addname(&args);
 180         else if ((rval = xfs_dir2_isblock(tp, dp, &v)))
 181                 return rval;
 182         else if (v)
 183                 rval = xfs_dir2_block_addname(&args);
 184         else if ((rval = xfs_dir2_isleaf(tp, dp, &v)))
 185                 return rval;
 186         else if (v)
 187                 rval = xfs_dir2_leaf_addname(&args);
 188         else
 189                 rval = xfs_dir2_node_addname(&args);
 190         return rval;
 191 }
 192
 193 /*
 194  * Lookup a name in a directory, give back the inode number.
 195  */
 196 int
 197 xfs_dir_lookup(
 198         xfs_trans_t     *tp,
 199         xfs_inode_t     *dp,
 200         struct xfs_name *name,
 201         xfs_ino_t       *inum)          /* out: inode number */
 202 {
 203         xfs_da_args_t   args;
 204         int             rval;
 205         int             v;              /* type-checking value */
 206
 207         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 208         XFS_STATS_INC(xs_dir_lookup);
 209         memset(&args, 0, sizeof(xfs_da_args_t));
 210
 211         args.name = name->name;
 212         args.namelen = name->len;
 213         args.hashval = xfs_da_hashname(name->name, name->len);
 214         args.dp = dp;
 215         args.whichfork = XFS_DATA_FORK;
 216         args.trans = tp;
 217         args.oknoent = 1;
 218
 219         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
 220                 rval = xfs_dir2_sf_lookup(&args);
 221         else if ((rval = xfs_dir2_isblock(tp, dp, &v)))
 222                 return rval;
 223         else if (v)
 224                 rval = xfs_dir2_block_lookup(&args);
 225         else if ((rval = xfs_dir2_isleaf(tp, dp, &v)))
 226                 return rval;
 227         else if (v)
 228                 rval = xfs_dir2_leaf_lookup(&args);
 229         else
 230                 rval = xfs_dir2_node_lookup(&args);
 231         if (rval == EEXIST)
 232                 rval = 0;
 233         if (rval == 0)
 234                 *inum = args.inumber;
 235         return rval;
 236 }
 237
 238 /*
 239  * Remove an entry from a directory.
 240  */
 241 int
 242 xfs_dir_removename(
 243         xfs_trans_t     *tp,
 244         xfs_inode_t     *dp,
 245         struct xfs_name *name,
 246         xfs_ino_t       ino,
 247         xfs_fsblock_t   *first,         /* bmap's firstblock */
 248         xfs_bmap_free_t *flist,         /* bmap's freeblock list */
 249         xfs_extlen_t    total)          /* bmap's total block count */
 250 {
 251         xfs_da_args_t   args;
 252         int             rval;
 253         int             v;              /* type-checking value */
 254
 255         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 256         XFS_STATS_INC(xs_dir_remove);
 257
 258         args.name = name->name;
 259         args.namelen = name->len;
 260         args.hashval = xfs_da_hashname(name->name, name->len);
 261         args.inumber = ino;
 262         args.dp = dp;
 263         args.firstblock = first;
 264         args.flist = flist;
 265         args.total = total;
 266         args.whichfork = XFS_DATA_FORK;
 267         args.trans = tp;
 268         args.justcheck = args.addname = args.oknoent = 0;
 269
 270         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
 271                 rval = xfs_dir2_sf_removename(&args);
 272         else if ((rval = xfs_dir2_isblock(tp, dp, &v)))
 273                 return rval;
 274         else if (v)
 275                 rval = xfs_dir2_block_removename(&args);
 276         else if ((rval = xfs_dir2_isleaf(tp, dp, &v)))
 277                 return rval;
 278         else if (v)
 279                 rval = xfs_dir2_leaf_removename(&args);
 280         else
 281                 rval = xfs_dir2_node_removename(&args);
 282         return rval;
 283 }
 284
 285 /*
 286  * Read a directory.
 287  */
 288 int
 289 xfs_readdir(
 290         xfs_inode_t     *dp,
 291         void            *dirent,
 292         size_t          bufsize,
 293         xfs_off_t       *offset,
 294         filldir_t       filldir)
 295 {
 296         int             rval;           /* return value */
 297         int             v;              /* type-checking value */
 298
 299         xfs_itrace_entry(dp);
 300
 301         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
 302                 return XFS_ERROR(EIO);
 303
 304         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 305         XFS_STATS_INC(xs_dir_getdents);
 306
 307         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
 308                 rval = xfs_dir2_sf_getdents(dp, dirent, offset, filldir);
 309         else if ((rval = xfs_dir2_isblock(NULL, dp, &v)))
 310                 ;
 311         else if (v)
 312                 rval = xfs_dir2_block_getdents(dp, dirent, offset, filldir);
 313         else
 314                 rval = xfs_dir2_leaf_getdents(dp, dirent, bufsize, offset,
 315                                               filldir);
 316         return rval;
 317 }
 318
 319 /*
 320  * Replace the inode number of a directory entry.
 321  */
 322 int
 323 xfs_dir_replace(
 324         xfs_trans_t     *tp,
 325         xfs_inode_t     *dp,
 326         struct xfs_name *name,          /* name of entry to replace */
 327         xfs_ino_t       inum,           /* new inode number */
 328         xfs_fsblock_t   *first,         /* bmap's firstblock */
 329         xfs_bmap_free_t *flist,         /* bmap's freeblock list */
 330         xfs_extlen_t    total)          /* bmap's total block count */
 331 {
 332         xfs_da_args_t   args;
 333         int             rval;
 334         int             v;              /* type-checking value */
 335
 336         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 337
 338         if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum)))
 339                 return rval;
 340
 341         args.name = name->name;
 342         args.namelen = name->len;
 343         args.hashval = xfs_da_hashname(name->name, name->len);
 344         args.inumber = inum;
 345         args.dp = dp;
 346         args.firstblock = first;
 347         args.flist = flist;
 348         args.total = total;
 349         args.whichfork = XFS_DATA_FORK;
 350         args.trans = tp;
 351         args.justcheck = args.addname = args.oknoent = 0;
 352
 353         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
 354                 rval = xfs_dir2_sf_replace(&args);
 355         else if ((rval = xfs_dir2_isblock(tp, dp, &v)))
 356                 return rval;
 357         else if (v)
 358                 rval = xfs_dir2_block_replace(&args);
 359         else if ((rval = xfs_dir2_isleaf(tp, dp, &v)))
 360                 return rval;
 361         else if (v)
 362                 rval = xfs_dir2_leaf_replace(&args);
 363         else
 364                 rval = xfs_dir2_node_replace(&args);
 365         return rval;
 366 }
 367
 368 /*
 369  * See if this entry can be added to the directory without allocating space.
 370  * First checks that the caller couldn't reserve enough space (resblks = 0).
 371  */
 372 int
 373 xfs_dir_canenter(
 374         xfs_trans_t     *tp,
 375         xfs_inode_t     *dp,
 376         struct xfs_name *name,          /* name of entry to add */
 377         uint            resblks)
 378 {
 379         xfs_da_args_t   args;
 380         int             rval;
 381         int             v;              /* type-checking value */
 382
 383         if (resblks)
 384                 return 0;
 385
 386         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 387         memset(&args, 0, sizeof(xfs_da_args_t));
 388
 389         args.name = name->name;
 390         args.namelen = name->len;
 391         args.hashval = xfs_da_hashname(name->name, name->len);
 392         args.dp = dp;
 393         args.whichfork = XFS_DATA_FORK;
 394         args.trans = tp;
 395         args.justcheck = args.addname = args.oknoent = 1;
 396
 397         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
 398                 rval = xfs_dir2_sf_addname(&args);
 399         else if ((rval = xfs_dir2_isblock(tp, dp, &v)))
 400                 return rval;
 401         else if (v)
 402                 rval = xfs_dir2_block_addname(&args);
 403         else if ((rval = xfs_dir2_isleaf(tp, dp, &v)))
 404                 return rval;
 405         else if (v)
 406                 rval = xfs_dir2_leaf_addname(&args);
 407         else
 408                 rval = xfs_dir2_node_addname(&args);
 409         return rval;
 410 }
 411
 412 /*
 413  * Utility routines.
 414  */
 415
 416 /*
 417  * Add a block to the directory.
 418  * This routine is for data and free blocks, not leaf/node blocks
 419  * which are handled by xfs_da_grow_inode.
 420  */
 421 int
 422 xfs_dir2_grow_inode(
 423         xfs_da_args_t   *args,
 424         int             space,          /* v2 dir's space XFS_DIR2_xxx_SPACE */
 425         xfs_dir2_db_t   *dbp)           /* out: block number added */
 426 {
 427         xfs_fileoff_t   bno;            /* directory offset of new block */
 428         int             count;          /* count of filesystem blocks */
 429         xfs_inode_t     *dp;            /* incore directory inode */
 430         int             error;
 431         int             got;            /* blocks actually mapped */
 432         int             i;
 433         xfs_bmbt_irec_t map;            /* single structure for bmap */
 434         int             mapi;           /* mapping index */
 435         xfs_bmbt_irec_t *mapp;          /* bmap mapping structure(s) */
 436         xfs_mount_t     *mp;
 437         int             nmap;           /* number of bmap entries */
 438         xfs_trans_t     *tp;
 439
 440         xfs_dir2_trace_args_s("grow_inode", args, space);
 441         dp = args->dp;
 442         tp = args->trans;
 443         mp = dp->i_mount;
 444         /*
 445          * Set lowest possible block in the space requested.
 446          */
 447         bno = XFS_B_TO_FSBT(mp, space * XFS_DIR2_SPACE_SIZE);
 448         count = mp->m_dirblkfsbs;
 449         /*
 450          * Find the first hole for our block.
 451          */
 452         if ((error = xfs_bmap_first_unused(tp, dp, count, &bno, XFS_DATA_FORK)))
 453                 return error;
 454         nmap = 1;
 455         ASSERT(args->firstblock != NULL);
 456         /*
 457          * Try mapping the new block contiguously (one extent).
 458          */
 459         if ((error = xfs_bmapi(tp, dp, bno, count,
 460                         XFS_BMAPI_WRITE|XFS_BMAPI_METADATA|XFS_BMAPI_CONTIG,
 461                         args->firstblock, args->total, &map, &nmap,
 462                         args->flist, NULL)))
 463                 return error;
 464         ASSERT(nmap <= 1);
 465         if (nmap == 1) {
 466                 mapp = &map;
 467                 mapi = 1;
 468         }
 469         /*
 470          * Didn't work and this is a multiple-fsb directory block.
 471          * Try again with contiguous flag turned on.
 472          */
 473         else if (nmap == 0 && count > 1) {
 474                 xfs_fileoff_t   b;      /* current file offset */
 475
 476                 /*
 477                  * Space for maximum number of mappings.
 478                  */
 479                 mapp = kmem_alloc(sizeof(*mapp) * count, KM_SLEEP);
 480                 /*
 481                  * Iterate until we get to the end of our block.
 482                  */
 483                 for (b = bno, mapi = 0; b < bno + count; ) {
 484                         int     c;      /* current fsb count */
 485
 486                         /*
 487                          * Can't map more than MAX_NMAP at once.
 488                          */
 489                         nmap = MIN(XFS_BMAP_MAX_NMAP, count);
 490                         c = (int)(bno + count - b);
 491                         if ((error = xfs_bmapi(tp, dp, b, c,
 492                                         XFS_BMAPI_WRITE|XFS_BMAPI_METADATA,
 493                                         args->firstblock, args->total,
 494                                         &mapp[mapi], &nmap, args->flist,
 495                                         NULL))) {
 496                                 kmem_free(mapp, sizeof(*mapp) * count);
 497                                 return error;
 498                         }
 499                         if (nmap < 1)
 500                                 break;
 501                         /*
 502                          * Add this bunch into our table, go to the next offset.
 503                          */
 504                         mapi += nmap;
 505                         b = mapp[mapi - 1].br_startoff +
 506                             mapp[mapi - 1].br_blockcount;
 507                 }
 508         }
 509         /*
 510          * Didn't work.
 511          */
 512         else {
 513                 mapi = 0;
 514                 mapp = NULL;
 515         }
 516         /*
 517          * See how many fsb's we got.
 518          */
 519         for (i = 0, got = 0; i < mapi; i++)
 520                 got += mapp[i].br_blockcount;
 521         /*
 522          * Didn't get enough fsb's, or the first/last block's are wrong.
 523          */
 524         if (got != count || mapp[0].br_startoff != bno ||
 525             mapp[mapi - 1].br_startoff + mapp[mapi - 1].br_blockcount !=
 526             bno + count) {
 527                 if (mapp != &map)
 528                         kmem_free(mapp, sizeof(*mapp) * count);
 529                 return XFS_ERROR(ENOSPC);
 530         }
 531         /*
 532          * Done with the temporary mapping table.
 533          */
 534         if (mapp != &map)
 535                 kmem_free(mapp, sizeof(*mapp) * count);
 536         *dbp = xfs_dir2_da_to_db(mp, (xfs_dablk_t)bno);
 537         /*
 538          * Update file's size if this is the data space and it grew.
 539          */
 540         if (space == XFS_DIR2_DATA_SPACE) {
 541                 xfs_fsize_t     size;           /* directory file (data) size */
 542
 543                 size = XFS_FSB_TO_B(mp, bno + count);
 544                 if (size > dp->i_d.di_size) {
 545                         dp->i_d.di_size = size;
 546                         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
 547                 }
 548         }
 549         return 0;
 550 }
 551
 552 /*
 553  * See if the directory is a single-block form directory.
 554  */
 555 int
 556 xfs_dir2_isblock(
 557         xfs_trans_t     *tp,
 558         xfs_inode_t     *dp,
 559         int             *vp)            /* out: 1 is block, 0 is not block */
 560 {
 561         xfs_fileoff_t   last;           /* last file offset */
 562         xfs_mount_t     *mp;
 563         int             rval;
 564
 565         mp = dp->i_mount;
 566         if ((rval = xfs_bmap_last_offset(tp, dp, &last, XFS_DATA_FORK)))
 567                 return rval;
 568         rval = XFS_FSB_TO_B(mp, last) == mp->m_dirblksize;
 569         ASSERT(rval == 0 || dp->i_d.di_size == mp->m_dirblksize);
 570         *vp = rval;
 571         return 0;
 572 }
 573
 574 /*
 575  * See if the directory is a single-leaf form directory.
 576  */
 577 int
 578 xfs_dir2_isleaf(
 579         xfs_trans_t     *tp,
 580         xfs_inode_t     *dp,
 581         int             *vp)            /* out: 1 is leaf, 0 is not leaf */
 582 {
 583         xfs_fileoff_t   last;           /* last file offset */
 584         xfs_mount_t     *mp;
 585         int             rval;
 586
 587         mp = dp->i_mount;
 588         if ((rval = xfs_bmap_last_offset(tp, dp, &last, XFS_DATA_FORK)))
 589                 return rval;
 590         *vp = last == mp->m_dirleafblk + (1 << mp->m_sb.sb_dirblklog);
 591         return 0;
 592 }
 593
 594 /*
 595  * Remove the given block from the directory.
 596  * This routine is used for data and free blocks, leaf/node are done
 597  * by xfs_da_shrink_inode.
 598  */
 599 int
 600 xfs_dir2_shrink_inode(
 601         xfs_da_args_t   *args,
 602         xfs_dir2_db_t   db,
 603         xfs_dabuf_t     *bp)
 604 {
 605         xfs_fileoff_t   bno;            /* directory file offset */
 606         xfs_dablk_t     da;             /* directory file offset */
 607         int             done;           /* bunmap is finished */
 608         xfs_inode_t     *dp;
 609         int             error;
 610         xfs_mount_t     *mp;
 611         xfs_trans_t     *tp;
 612
 613         xfs_dir2_trace_args_db("shrink_inode", args, db, bp);
 614         dp = args->dp;
 615         mp = dp->i_mount;
 616         tp = args->trans;
 617         da = xfs_dir2_db_to_da(mp, db);
 618         /*
 619          * Unmap the fsblock(s).
 620          */
 621         if ((error = xfs_bunmapi(tp, dp, da, mp->m_dirblkfsbs,
 622                         XFS_BMAPI_METADATA, 0, args->firstblock, args->flist,
 623                         NULL, &done))) {
 624                 /*
 625                  * ENOSPC actually can happen if we're in a removename with
 626                  * no space reservation, and the resulting block removal
 627                  * would cause a bmap btree split or conversion from extents
 628                  * to btree.  This can only happen for un-fragmented
 629                  * directory blocks, since you need to be punching out
 630                  * the middle of an extent.
 631                  * In this case we need to leave the block in the file,
 632                  * and not binval it.
 633                  * So the block has to be in a consistent empty state
 634                  * and appropriately logged.
 635                  * We don't free up the buffer, the caller can tell it
 636                  * hasn't happened since it got an error back.
 637                  */
 638                 return error;
 639         }
 640         ASSERT(done);
 641         /*
 642          * Invalidate the buffer from the transaction.
 643          */
 644         xfs_da_binval(tp, bp);
 645         /*
 646          * If it's not a data block, we're done.
 647          */
 648         if (db >= XFS_DIR2_LEAF_FIRSTDB(mp))
 649                 return 0;
 650         /*
 651          * If the block isn't the last one in the directory, we're done.
 652          */
 653         if (dp->i_d.di_size > xfs_dir2_db_off_to_byte(mp, db + 1, 0))
 654                 return 0;
 655         bno = da;
 656         if ((error = xfs_bmap_last_before(tp, dp, &bno, XFS_DATA_FORK))) {
 657                 /*
 658                  * This can't really happen unless there's kernel corruption.
 659                  */
 660                 return error;
 661         }
 662         if (db == mp->m_dirdatablk)
 663                 ASSERT(bno == 0);
 664         else
 665                 ASSERT(bno > 0);
 666         /*
 667          * Set the size to the new last block.
 668          */
 669         dp->i_d.di_size = XFS_FSB_TO_B(mp, bno);
 670         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
 671         return 0;
 672 }