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