fs/xfs/xfs_dir2.c

   1 /*
   2  * Copyright (c) 2000-2001 Silicon Graphics, Inc.  All Rights Reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of version 2 of the GNU General Public License as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it would be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * Further, this software is distributed without any warranty that it is
  13  * free of the rightful claim of any third person regarding infringement
  14  * or the like.  Any license provided herein, whether implied or
  15  * otherwise, applies only to this software file.  Patent licenses, if
  16  * any, provided herein do not apply to combinations of this program with
  17  * other software, or any other product whatsoever.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write the Free Software Foundation, Inc., 59
  21  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
  22  *
  23  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
  24  * Mountain View, CA  94043, or:
  25  *
  26  * http://www.sgi.com
  27  *
  28  * For further information regarding this notice, see:
  29  *
  30  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
  31  */
  32 #include "xfs.h"
  33 #include "xfs_fs.h"
  34 #include "xfs_types.h"
  35 #include "xfs_bit.h"
  36 #include "xfs_log.h"
  37 #include "xfs_inum.h"
  38 #include "xfs_trans.h"
  39 #include "xfs_sb.h"
  40 #include "xfs_ag.h"
  41 #include "xfs_dir.h"
  42 #include "xfs_dir2.h"
  43 #include "xfs_dmapi.h"
  44 #include "xfs_mount.h"
  45 #include "xfs_da_btree.h"
  46 #include "xfs_bmap_btree.h"
  47 #include "xfs_alloc_btree.h"
  48 #include "xfs_dir_sf.h"
  49 #include "xfs_dir2_sf.h"
  50 #include "xfs_attr_sf.h"
  51 #include "xfs_dinode.h"
  52 #include "xfs_inode.h"
  53 #include "xfs_inode_item.h"
  54 #include "xfs_bmap.h"
  55 #include "xfs_dir_leaf.h"
  56 #include "xfs_dir2_data.h"
  57 #include "xfs_dir2_leaf.h"
  58 #include "xfs_dir2_block.h"
  59 #include "xfs_dir2_node.h"
  60 #include "xfs_dir2_trace.h"
  61 #include "xfs_error.h"
  62
  63 /*
  64  * Declarations for interface routines.
  65  */
  66 static void     xfs_dir2_mount(xfs_mount_t *mp);
  67 static int      xfs_dir2_isempty(xfs_inode_t *dp);
  68 static int      xfs_dir2_init(xfs_trans_t *tp, xfs_inode_t *dp,
  69                               xfs_inode_t *pdp);
  70 static int      xfs_dir2_createname(xfs_trans_t *tp, xfs_inode_t *dp,
  71                                     char *name, int namelen, xfs_ino_t inum,
  72                                     xfs_fsblock_t *first,
  73                                     xfs_bmap_free_t *flist, xfs_extlen_t total);
  74 static int      xfs_dir2_lookup(xfs_trans_t *tp, xfs_inode_t *dp, char *name,
  75                                 int namelen, xfs_ino_t *inum);
  76 static int      xfs_dir2_removename(xfs_trans_t *tp, xfs_inode_t *dp,
  77                                     char *name, int namelen, xfs_ino_t ino,
  78                                     xfs_fsblock_t *first,
  79                                     xfs_bmap_free_t *flist, xfs_extlen_t total);
  80 static int      xfs_dir2_getdents(xfs_trans_t *tp, xfs_inode_t *dp, uio_t *uio,
  81                                   int *eofp);
  82 static int      xfs_dir2_replace(xfs_trans_t *tp, xfs_inode_t *dp, char *name,
  83                                  int namelen, xfs_ino_t inum,
  84                                  xfs_fsblock_t *first, xfs_bmap_free_t *flist,
  85                                  xfs_extlen_t total);
  86 static int      xfs_dir2_canenter(xfs_trans_t *tp, xfs_inode_t *dp, char *name,
  87                                   int namelen);
  88 static int      xfs_dir2_shortform_validate_ondisk(xfs_mount_t *mp,
  89                                                    xfs_dinode_t *dip);
  90
  91 /*
  92  * Utility routine declarations.
  93  */
  94 static int      xfs_dir2_put_dirent64_direct(xfs_dir2_put_args_t *pa);
  95 static int      xfs_dir2_put_dirent64_uio(xfs_dir2_put_args_t *pa);
  96
  97 /*
  98  * Directory operations vector.
  99  */
 100 xfs_dirops_t    xfsv2_dirops = {
 101         .xd_mount                       = xfs_dir2_mount,
 102         .xd_isempty                     = xfs_dir2_isempty,
 103         .xd_init                        = xfs_dir2_init,
 104         .xd_createname                  = xfs_dir2_createname,
 105         .xd_lookup                      = xfs_dir2_lookup,
 106         .xd_removename                  = xfs_dir2_removename,
 107         .xd_getdents                    = xfs_dir2_getdents,
 108         .xd_replace                     = xfs_dir2_replace,
 109         .xd_canenter                    = xfs_dir2_canenter,
 110         .xd_shortform_validate_ondisk   = xfs_dir2_shortform_validate_ondisk,
 111         .xd_shortform_to_single         = xfs_dir2_sf_to_block,
 112 };
 113
 114 /*
 115  * Interface routines.
 116  */
 117
 118 /*
 119  * Initialize directory-related fields in the mount structure.
 120  */
 121 static void
 122 xfs_dir2_mount(
 123         xfs_mount_t     *mp)            /* filesystem mount point */
 124 {
 125         mp->m_dirversion = 2;
 126         ASSERT((1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog)) <=
 127                XFS_MAX_BLOCKSIZE);
 128         mp->m_dirblksize = 1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog);
 129         mp->m_dirblkfsbs = 1 << mp->m_sb.sb_dirblklog;
 130         mp->m_dirdatablk = XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_DATA_FIRSTDB(mp));
 131         mp->m_dirleafblk = XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_LEAF_FIRSTDB(mp));
 132         mp->m_dirfreeblk = XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_FREE_FIRSTDB(mp));
 133         mp->m_attr_node_ents =
 134                 (mp->m_sb.sb_blocksize - (uint)sizeof(xfs_da_node_hdr_t)) /
 135                 (uint)sizeof(xfs_da_node_entry_t);
 136         mp->m_dir_node_ents =
 137                 (mp->m_dirblksize - (uint)sizeof(xfs_da_node_hdr_t)) /
 138                 (uint)sizeof(xfs_da_node_entry_t);
 139         mp->m_dir_magicpct = (mp->m_dirblksize * 37) / 100;
 140 }
 141
 142 /*
 143  * Return 1 if directory contains only "." and "..".
 144  */
 145 static int                              /* return code */
 146 xfs_dir2_isempty(
 147         xfs_inode_t     *dp)            /* incore inode structure */
 148 {
 149         xfs_dir2_sf_t   *sfp;           /* shortform directory structure */
 150
 151         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 152         /*
 153          * Might happen during shutdown.
 154          */
 155         if (dp->i_d.di_size == 0) {
 156                 return 1;
 157         }
 158         if (dp->i_d.di_size > XFS_IFORK_DSIZE(dp))
 159                 return 0;
 160         sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
 161         return !sfp->hdr.count;
 162 }
 163
 164 /*
 165  * Initialize a directory with its "." and ".." entries.
 166  */
 167 static int                              /* error */
 168 xfs_dir2_init(
 169         xfs_trans_t     *tp,            /* transaction pointer */
 170         xfs_inode_t     *dp,            /* incore directory inode */
 171         xfs_inode_t     *pdp)           /* incore parent directory inode */
 172 {
 173         xfs_da_args_t   args;           /* operation arguments */
 174         int             error;          /* error return value */
 175
 176         memset((char *)&args, 0, sizeof(args));
 177         args.dp = dp;
 178         args.trans = tp;
 179         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 180         if ((error = xfs_dir_ino_validate(tp->t_mountp, pdp->i_ino))) {
 181                 return error;
 182         }
 183         return xfs_dir2_sf_create(&args, pdp->i_ino);
 184 }
 185
 186 /*
 187   Enter a name in a directory.
 188  */
 189 static int                                      /* error */
 190 xfs_dir2_createname(
 191         xfs_trans_t             *tp,            /* transaction pointer */
 192         xfs_inode_t             *dp,            /* incore directory inode */
 193         char                    *name,          /* new entry name */
 194         int                     namelen,        /* new entry name length */
 195         xfs_ino_t               inum,           /* new entry inode number */
 196         xfs_fsblock_t           *first,         /* bmap's firstblock */
 197         xfs_bmap_free_t         *flist,         /* bmap's freeblock list */
 198         xfs_extlen_t            total)          /* bmap's total block count */
 199 {
 200         xfs_da_args_t           args;           /* operation arguments */
 201         int                     rval;           /* return value */
 202         int                     v;              /* type-checking value */
 203
 204         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 205         if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum))) {
 206                 return rval;
 207         }
 208         XFS_STATS_INC(xs_dir_create);
 209         /*
 210          * Fill in the arg structure for this request.
 211          */
 212         args.name = name;
 213         args.namelen = namelen;
 214         args.hashval = xfs_da_hashname(name, namelen);
 215         args.inumber = inum;
 216         args.dp = dp;
 217         args.firstblock = first;
 218         args.flist = flist;
 219         args.total = total;
 220         args.whichfork = XFS_DATA_FORK;
 221         args.trans = tp;
 222         args.justcheck = 0;
 223         args.addname = args.oknoent = 1;
 224         /*
 225          * Decide on what work routines to call based on the inode size.
 226          */
 227         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
 228                 rval = xfs_dir2_sf_addname(&args);
 229         else if ((rval = xfs_dir2_isblock(tp, dp, &v))) {
 230                 return rval;
 231         } else if (v)
 232                 rval = xfs_dir2_block_addname(&args);
 233         else if ((rval = xfs_dir2_isleaf(tp, dp, &v))) {
 234                 return rval;
 235         } else if (v)
 236                 rval = xfs_dir2_leaf_addname(&args);
 237         else
 238                 rval = xfs_dir2_node_addname(&args);
 239         return rval;
 240 }
 241
 242 /*
 243  * Lookup a name in a directory, give back the inode number.
 244  */
 245 static int                              /* error */
 246 xfs_dir2_lookup(
 247         xfs_trans_t     *tp,            /* transaction pointer */
 248         xfs_inode_t     *dp,            /* incore directory inode */
 249         char            *name,          /* lookup name */
 250         int             namelen,        /* lookup name length */
 251         xfs_ino_t       *inum)          /* out: inode number */
 252 {
 253         xfs_da_args_t   args;           /* operation arguments */
 254         int             rval;           /* return value */
 255         int             v;              /* type-checking value */
 256
 257         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 258         XFS_STATS_INC(xs_dir_lookup);
 259
 260         /*
 261          * Fill in the arg structure for this request.
 262          */
 263         args.name = name;
 264         args.namelen = namelen;
 265         args.hashval = xfs_da_hashname(name, namelen);
 266         args.inumber = 0;
 267         args.dp = dp;
 268         args.firstblock = NULL;
 269         args.flist = NULL;
 270         args.total = 0;
 271         args.whichfork = XFS_DATA_FORK;
 272         args.trans = tp;
 273         args.justcheck = args.addname = 0;
 274         args.oknoent = 1;
 275         /*
 276          * Decide on what work routines to call based on the inode size.
 277          */
 278         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
 279                 rval = xfs_dir2_sf_lookup(&args);
 280         else if ((rval = xfs_dir2_isblock(tp, dp, &v))) {
 281                 return rval;
 282         } else if (v)
 283                 rval = xfs_dir2_block_lookup(&args);
 284         else if ((rval = xfs_dir2_isleaf(tp, dp, &v))) {
 285                 return rval;
 286         } else if (v)
 287                 rval = xfs_dir2_leaf_lookup(&args);
 288         else
 289                 rval = xfs_dir2_node_lookup(&args);
 290         if (rval == EEXIST)
 291                 rval = 0;
 292         if (rval == 0)
 293                 *inum = args.inumber;
 294         return rval;
 295 }
 296
 297 /*
 298  * Remove an entry from a directory.
 299  */
 300 static int                              /* error */
 301 xfs_dir2_removename(
 302         xfs_trans_t     *tp,            /* transaction pointer */
 303         xfs_inode_t     *dp,            /* incore directory inode */
 304         char            *name,          /* name of entry to remove */
 305         int             namelen,        /* name length of entry to remove */
 306         xfs_ino_t       ino,            /* inode number of entry to remove */
 307         xfs_fsblock_t   *first,         /* bmap's firstblock */
 308         xfs_bmap_free_t *flist,         /* bmap's freeblock list */
 309         xfs_extlen_t    total)          /* bmap's total block count */
 310 {
 311         xfs_da_args_t   args;           /* operation arguments */
 312         int             rval;           /* return value */
 313         int             v;              /* type-checking value */
 314
 315         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 316         XFS_STATS_INC(xs_dir_remove);
 317         /*
 318          * Fill in the arg structure for this request.
 319          */
 320         args.name = name;
 321         args.namelen = namelen;
 322         args.hashval = xfs_da_hashname(name, namelen);
 323         args.inumber = ino;
 324         args.dp = dp;
 325         args.firstblock = first;
 326         args.flist = flist;
 327         args.total = total;
 328         args.whichfork = XFS_DATA_FORK;
 329         args.trans = tp;
 330         args.justcheck = args.addname = args.oknoent = 0;
 331         /*
 332          * Decide on what work routines to call based on the inode size.
 333          */
 334         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
 335                 rval = xfs_dir2_sf_removename(&args);
 336         else if ((rval = xfs_dir2_isblock(tp, dp, &v))) {
 337                 return rval;
 338         } else if (v)
 339                 rval = xfs_dir2_block_removename(&args);
 340         else if ((rval = xfs_dir2_isleaf(tp, dp, &v))) {
 341                 return rval;
 342         } else if (v)
 343                 rval = xfs_dir2_leaf_removename(&args);
 344         else
 345                 rval = xfs_dir2_node_removename(&args);
 346         return rval;
 347 }
 348
 349 /*
 350  * Read a directory.
 351  */
 352 static int                              /* error */
 353 xfs_dir2_getdents(
 354         xfs_trans_t     *tp,            /* transaction pointer */
 355         xfs_inode_t     *dp,            /* incore directory inode */
 356         uio_t           *uio,           /* caller's buffer control */
 357         int             *eofp)          /* out: eof reached */
 358 {
 359         int             alignment;      /* alignment required for ABI */
 360         xfs_dirent_t    *dbp;           /* malloc'ed buffer */
 361         xfs_dir2_put_t  put;            /* entry formatting routine */
 362         int             rval;           /* return value */
 363         int             v;              /* type-checking value */
 364
 365         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 366         XFS_STATS_INC(xs_dir_getdents);
 367         /*
 368          * If our caller has given us a single contiguous aligned memory buffer,
 369          * just work directly within that buffer.  If it's in user memory,
 370          * lock it down first.
 371          */
 372         alignment = sizeof(xfs_off_t) - 1;
 373         if ((uio->uio_iovcnt == 1) &&
 374             (((__psint_t)uio->uio_iov[0].iov_base & alignment) == 0) &&
 375             ((uio->uio_iov[0].iov_len & alignment) == 0)) {
 376                 dbp = NULL;
 377                 put = xfs_dir2_put_dirent64_direct;
 378         } else {
 379                 dbp = kmem_alloc(sizeof(*dbp) + MAXNAMELEN, KM_SLEEP);
 380                 put = xfs_dir2_put_dirent64_uio;
 381         }
 382
 383         *eofp = 0;
 384         /*
 385          * Decide on what work routines to call based on the inode size.
 386          */
 387         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
 388                 rval = xfs_dir2_sf_getdents(dp, uio, eofp, dbp, put);
 389         else if ((rval = xfs_dir2_isblock(tp, dp, &v))) {
 390                 ;
 391         } else if (v)
 392                 rval = xfs_dir2_block_getdents(tp, dp, uio, eofp, dbp, put);
 393         else
 394                 rval = xfs_dir2_leaf_getdents(tp, dp, uio, eofp, dbp, put);
 395         if (dbp != NULL)
 396                 kmem_free(dbp, sizeof(*dbp) + MAXNAMELEN);
 397         return rval;
 398 }
 399
 400 /*
 401  * Replace the inode number of a directory entry.
 402  */
 403 static int                              /* error */
 404 xfs_dir2_replace(
 405         xfs_trans_t     *tp,            /* transaction pointer */
 406         xfs_inode_t     *dp,            /* incore directory inode */
 407         char            *name,          /* name of entry to replace */
 408         int             namelen,        /* name length of entry to replace */
 409         xfs_ino_t       inum,           /* new inode number */
 410         xfs_fsblock_t   *first,         /* bmap's firstblock */
 411         xfs_bmap_free_t *flist,         /* bmap's freeblock list */
 412         xfs_extlen_t    total)          /* bmap's total block count */
 413 {
 414         xfs_da_args_t   args;           /* operation arguments */
 415         int             rval;           /* return value */
 416         int             v;              /* type-checking value */
 417
 418         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 419
 420         if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum))) {
 421                 return rval;
 422         }
 423         /*
 424          * Fill in the arg structure for this request.
 425          */
 426         args.name = name;
 427         args.namelen = namelen;
 428         args.hashval = xfs_da_hashname(name, namelen);
 429         args.inumber = inum;
 430         args.dp = dp;
 431         args.firstblock = first;
 432         args.flist = flist;
 433         args.total = total;
 434         args.whichfork = XFS_DATA_FORK;
 435         args.trans = tp;
 436         args.justcheck = args.addname = args.oknoent = 0;
 437         /*
 438          * Decide on what work routines to call based on the inode size.
 439          */
 440         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
 441                 rval = xfs_dir2_sf_replace(&args);
 442         else if ((rval = xfs_dir2_isblock(tp, dp, &v))) {
 443                 return rval;
 444         } else if (v)
 445                 rval = xfs_dir2_block_replace(&args);
 446         else if ((rval = xfs_dir2_isleaf(tp, dp, &v))) {
 447                 return rval;
 448         } else if (v)
 449                 rval = xfs_dir2_leaf_replace(&args);
 450         else
 451                 rval = xfs_dir2_node_replace(&args);
 452         return rval;
 453 }
 454
 455 /*
 456  * See if this entry can be added to the directory without allocating space.
 457  */
 458 static int                              /* error */
 459 xfs_dir2_canenter(
 460         xfs_trans_t     *tp,            /* transaction pointer */
 461         xfs_inode_t     *dp,            /* incore directory inode */
 462         char            *name,          /* name of entry to add */
 463         int             namelen)        /* name length of entry to add */
 464 {
 465         xfs_da_args_t   args;           /* operation arguments */
 466         int             rval;           /* return value */
 467         int             v;              /* type-checking value */
 468
 469         ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
 470         /*
 471          * Fill in the arg structure for this request.
 472          */
 473         args.name = name;
 474         args.namelen = namelen;
 475         args.hashval = xfs_da_hashname(name, namelen);
 476         args.inumber = 0;
 477         args.dp = dp;
 478         args.firstblock = NULL;
 479         args.flist = NULL;
 480         args.total = 0;
 481         args.whichfork = XFS_DATA_FORK;
 482         args.trans = tp;
 483         args.justcheck = args.addname = args.oknoent = 1;
 484         /*
 485          * Decide on what work routines to call based on the inode size.
 486          */
 487         if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
 488                 rval = xfs_dir2_sf_addname(&args);
 489         else if ((rval = xfs_dir2_isblock(tp, dp, &v))) {
 490                 return rval;
 491         } else if (v)
 492                 rval = xfs_dir2_block_addname(&args);
 493         else if ((rval = xfs_dir2_isleaf(tp, dp, &v))) {
 494                 return rval;
 495         } else if (v)
 496                 rval = xfs_dir2_leaf_addname(&args);
 497         else
 498                 rval = xfs_dir2_node_addname(&args);
 499         return rval;
 500 }
 501
 502 /*
 503  * Dummy routine for shortform inode validation.
 504  * Can't really do this.
 505  */
 506 /* ARGSUSED */
 507 static int                              /* error */
 508 xfs_dir2_shortform_validate_ondisk(
 509         xfs_mount_t     *mp,            /* filesystem mount point */
 510         xfs_dinode_t    *dip)           /* ondisk inode */
 511 {
 512         return 0;
 513 }
 514
 515 /*
 516  * Utility routines.
 517  */
 518
 519 /*
 520  * Add a block to the directory.
 521  * This routine is for data and free blocks, not leaf/node blocks
 522  * which are handled by xfs_da_grow_inode.
 523  */
 524 int                                     /* error */
 525 xfs_dir2_grow_inode(
 526         xfs_da_args_t   *args,          /* operation arguments */
 527         int             space,          /* v2 dir's space XFS_DIR2_xxx_SPACE */
 528         xfs_dir2_db_t   *dbp)           /* out: block number added */
 529 {
 530         xfs_fileoff_t   bno;            /* directory offset of new block */
 531         int             count;          /* count of filesystem blocks */
 532         xfs_inode_t     *dp;            /* incore directory inode */
 533         int             error;          /* error return value */
 534         int             got;            /* blocks actually mapped */
 535         int             i;              /* temp mapping index */
 536         xfs_bmbt_irec_t map;            /* single structure for bmap */
 537         int             mapi;           /* mapping index */
 538         xfs_bmbt_irec_t *mapp;          /* bmap mapping structure(s) */
 539         xfs_mount_t     *mp;            /* filesystem mount point */
 540         int             nmap;           /* number of bmap entries */
 541         xfs_trans_t     *tp;            /* transaction pointer */
 542
 543         xfs_dir2_trace_args_s("grow_inode", args, space);
 544         dp = args->dp;
 545         tp = args->trans;
 546         mp = dp->i_mount;
 547         /*
 548          * Set lowest possible block in the space requested.
 549          */
 550         bno = XFS_B_TO_FSBT(mp, space * XFS_DIR2_SPACE_SIZE);
 551         count = mp->m_dirblkfsbs;
 552         /*
 553          * Find the first hole for our block.
 554          */
 555         if ((error = xfs_bmap_first_unused(tp, dp, count, &bno, XFS_DATA_FORK))) {
 556                 return error;
 557         }
 558         nmap = 1;
 559         ASSERT(args->firstblock != NULL);
 560         /*
 561          * Try mapping the new block contiguously (one extent).
 562          */
 563         if ((error = xfs_bmapi(tp, dp, bno, count,
 564                         XFS_BMAPI_WRITE|XFS_BMAPI_METADATA|XFS_BMAPI_CONTIG,
 565                         args->firstblock, args->total, &map, &nmap,
 566                         args->flist))) {
 567                 return error;
 568         }
 569         ASSERT(nmap <= 1);
 570         /*
 571          * Got it in 1.
 572          */
 573         if (nmap == 1) {
 574                 mapp = &map;
 575                 mapi = 1;
 576         }
 577         /*
 578          * Didn't work and this is a multiple-fsb directory block.
 579          * Try again with contiguous flag turned on.
 580          */
 581         else if (nmap == 0 && count > 1) {
 582                 xfs_fileoff_t   b;      /* current file offset */
 583
 584                 /*
 585                  * Space for maximum number of mappings.
 586                  */
 587                 mapp = kmem_alloc(sizeof(*mapp) * count, KM_SLEEP);
 588                 /*
 589                  * Iterate until we get to the end of our block.
 590                  */
 591                 for (b = bno, mapi = 0; b < bno + count; ) {
 592                         int     c;      /* current fsb count */
 593
 594                         /*
 595                          * Can't map more than MAX_NMAP at once.
 596                          */
 597                         nmap = MIN(XFS_BMAP_MAX_NMAP, count);
 598                         c = (int)(bno + count - b);
 599                         if ((error = xfs_bmapi(tp, dp, b, c,
 600                                         XFS_BMAPI_WRITE|XFS_BMAPI_METADATA,
 601                                         args->firstblock, args->total,
 602                                         &mapp[mapi], &nmap, args->flist))) {
 603                                 kmem_free(mapp, sizeof(*mapp) * count);
 604                                 return error;
 605                         }
 606                         if (nmap < 1)
 607                                 break;
 608                         /*
 609                          * Add this bunch into our table, go to the next offset.
 610                          */
 611                         mapi += nmap;
 612                         b = mapp[mapi - 1].br_startoff +
 613                             mapp[mapi - 1].br_blockcount;
 614                 }
 615         }
 616         /*
 617          * Didn't work.
 618          */
 619         else {
 620                 mapi = 0;
 621                 mapp = NULL;
 622         }
 623         /*
 624          * See how many fsb's we got.
 625          */
 626         for (i = 0, got = 0; i < mapi; i++)
 627                 got += mapp[i].br_blockcount;
 628         /*
 629          * Didn't get enough fsb's, or the first/last block's are wrong.
 630          */
 631         if (got != count || mapp[0].br_startoff != bno ||
 632             mapp[mapi - 1].br_startoff + mapp[mapi - 1].br_blockcount !=
 633             bno + count) {
 634                 if (mapp != &map)
 635                         kmem_free(mapp, sizeof(*mapp) * count);
 636                 return XFS_ERROR(ENOSPC);
 637         }
 638         /*
 639          * Done with the temporary mapping table.
 640          */
 641         if (mapp != &map)
 642                 kmem_free(mapp, sizeof(*mapp) * count);
 643         *dbp = XFS_DIR2_DA_TO_DB(mp, (xfs_dablk_t)bno);
 644         /*
 645          * Update file's size if this is the data space and it grew.
 646          */
 647         if (space == XFS_DIR2_DATA_SPACE) {
 648                 xfs_fsize_t     size;           /* directory file (data) size */
 649
 650                 size = XFS_FSB_TO_B(mp, bno + count);
 651                 if (size > dp->i_d.di_size) {
 652                         dp->i_d.di_size = size;
 653                         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
 654                 }
 655         }
 656         return 0;
 657 }
 658
 659 /*
 660  * See if the directory is a single-block form directory.
 661  */
 662 int                                     /* error */
 663 xfs_dir2_isblock(
 664         xfs_trans_t     *tp,            /* transaction pointer */
 665         xfs_inode_t     *dp,            /* incore directory inode */
 666         int             *vp)            /* out: 1 is block, 0 is not block */
 667 {
 668         xfs_fileoff_t   last;           /* last file offset */
 669         xfs_mount_t     *mp;            /* filesystem mount point */
 670         int             rval;           /* return value */
 671
 672         mp = dp->i_mount;
 673         if ((rval = xfs_bmap_last_offset(tp, dp, &last, XFS_DATA_FORK))) {
 674                 return rval;
 675         }
 676         rval = XFS_FSB_TO_B(mp, last) == mp->m_dirblksize;
 677         ASSERT(rval == 0 || dp->i_d.di_size == mp->m_dirblksize);
 678         *vp = rval;
 679         return 0;
 680 }
 681
 682 /*
 683  * See if the directory is a single-leaf form directory.
 684  */
 685 int                                     /* error */
 686 xfs_dir2_isleaf(
 687         xfs_trans_t     *tp,            /* transaction pointer */
 688         xfs_inode_t     *dp,            /* incore directory inode */
 689         int             *vp)            /* out: 1 is leaf, 0 is not leaf */
 690 {
 691         xfs_fileoff_t   last;           /* last file offset */
 692         xfs_mount_t     *mp;            /* filesystem mount point */
 693         int             rval;           /* return value */
 694
 695         mp = dp->i_mount;
 696         if ((rval = xfs_bmap_last_offset(tp, dp, &last, XFS_DATA_FORK))) {
 697                 return rval;
 698         }
 699         *vp = last == mp->m_dirleafblk + (1 << mp->m_sb.sb_dirblklog);
 700         return 0;
 701 }
 702
 703 /*
 704  * Getdents put routine for 64-bit ABI, direct form.
 705  */
 706 static int                                      /* error */
 707 xfs_dir2_put_dirent64_direct(
 708         xfs_dir2_put_args_t     *pa)            /* argument bundle */
 709 {
 710         xfs_dirent_t            *idbp;          /* dirent pointer */
 711         iovec_t                 *iovp;          /* io vector */
 712         int                     namelen;        /* entry name length */
 713         int                     reclen;         /* entry total length */
 714         uio_t                   *uio;           /* I/O control */
 715
 716         namelen = pa->namelen;
 717         reclen = DIRENTSIZE(namelen);
 718         uio = pa->uio;
 719         /*
 720          * Won't fit in the remaining space.
 721          */
 722         if (reclen > uio->uio_resid) {
 723                 pa->done = 0;
 724                 return 0;
 725         }
 726         iovp = uio->uio_iov;
 727         idbp = (xfs_dirent_t *)iovp->iov_base;
 728         iovp->iov_base = (char *)idbp + reclen;
 729         iovp->iov_len -= reclen;
 730         uio->uio_resid -= reclen;
 731         idbp->d_reclen = reclen;
 732         idbp->d_ino = pa->ino;
 733         idbp->d_off = pa->cook;
 734         idbp->d_name[namelen] = '\0';
 735         pa->done = 1;
 736         memcpy(idbp->d_name, pa->name, namelen);
 737         return 0;
 738 }
 739
 740 /*
 741  * Getdents put routine for 64-bit ABI, uio form.
 742  */
 743 static int                                      /* error */
 744 xfs_dir2_put_dirent64_uio(
 745         xfs_dir2_put_args_t     *pa)            /* argument bundle */
 746 {
 747         xfs_dirent_t            *idbp;          /* dirent pointer */
 748         int                     namelen;        /* entry name length */
 749         int                     reclen;         /* entry total length */
 750         int                     rval;           /* return value */
 751         uio_t                   *uio;           /* I/O control */
 752
 753         namelen = pa->namelen;
 754         reclen = DIRENTSIZE(namelen);
 755         uio = pa->uio;
 756         /*
 757          * Won't fit in the remaining space.
 758          */
 759         if (reclen > uio->uio_resid) {
 760                 pa->done = 0;
 761                 return 0;
 762         }
 763         idbp = pa->dbp;
 764         idbp->d_reclen = reclen;
 765         idbp->d_ino = pa->ino;
 766         idbp->d_off = pa->cook;
 767         idbp->d_name[namelen] = '\0';
 768         memcpy(idbp->d_name, pa->name, namelen);
 769         rval = uio_read((caddr_t)idbp, reclen, uio);
 770         pa->done = (rval == 0);
 771         return rval;
 772 }
 773
 774 /*
 775  * Remove the given block from the directory.
 776  * This routine is used for data and free blocks, leaf/node are done
 777  * by xfs_da_shrink_inode.
 778  */
 779 int
 780 xfs_dir2_shrink_inode(
 781         xfs_da_args_t   *args,          /* operation arguments */
 782         xfs_dir2_db_t   db,             /* directory block number */
 783         xfs_dabuf_t     *bp)            /* block's buffer */
 784 {
 785         xfs_fileoff_t   bno;            /* directory file offset */
 786         xfs_dablk_t     da;             /* directory file offset */
 787         int             done;           /* bunmap is finished */
 788         xfs_inode_t     *dp;            /* incore directory inode */
 789         int             error;          /* error return value */
 790         xfs_mount_t     *mp;            /* filesystem mount point */
 791         xfs_trans_t     *tp;            /* transaction pointer */
 792
 793         xfs_dir2_trace_args_db("shrink_inode", args, db, bp);
 794         dp = args->dp;
 795         mp = dp->i_mount;
 796         tp = args->trans;
 797         da = XFS_DIR2_DB_TO_DA(mp, db);
 798         /*
 799          * Unmap the fsblock(s).
 800          */
 801         if ((error = xfs_bunmapi(tp, dp, da, mp->m_dirblkfsbs,
 802                         XFS_BMAPI_METADATA, 0, args->firstblock, args->flist,
 803                         &done))) {
 804                 /*
 805                  * ENOSPC actually can happen if we're in a removename with
 806                  * no space reservation, and the resulting block removal
 807                  * would cause a bmap btree split or conversion from extents
 808                  * to btree.  This can only happen for un-fragmented
 809                  * directory blocks, since you need to be punching out
 810                  * the middle of an extent.
 811                  * In this case we need to leave the block in the file,
 812                  * and not binval it.
 813                  * So the block has to be in a consistent empty state
 814                  * and appropriately logged.
 815                  * We don't free up the buffer, the caller can tell it
 816                  * hasn't happened since it got an error back.
 817                  */
 818                 return error;
 819         }
 820         ASSERT(done);
 821         /*
 822          * Invalidate the buffer from the transaction.
 823          */
 824         xfs_da_binval(tp, bp);
 825         /*
 826          * If it's not a data block, we're done.
 827          */
 828         if (db >= XFS_DIR2_LEAF_FIRSTDB(mp))
 829                 return 0;
 830         /*
 831          * If the block isn't the last one in the directory, we're done.
 832          */
 833         if (dp->i_d.di_size > XFS_DIR2_DB_OFF_TO_BYTE(mp, db + 1, 0))
 834                 return 0;
 835         bno = da;
 836         if ((error = xfs_bmap_last_before(tp, dp, &bno, XFS_DATA_FORK))) {
 837                 /*
 838                  * This can't really happen unless there's kernel corruption.
 839                  */
 840                 return error;
 841         }
 842         if (db == mp->m_dirdatablk)
 843                 ASSERT(bno == 0);
 844         else
 845                 ASSERT(bno > 0);
 846         /*
 847          * Set the size to the new last block.
 848          */
 849         dp->i_d.di_size = XFS_FSB_TO_B(mp, bno);
 850         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
 851         return 0;
 852 }