linux/fs/xfs/xfs_attr_leaf.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2000-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_trans.h"
  24#include "xfs_sb.h"
  25#include "xfs_ag.h"
  26#include "xfs_mount.h"
  27#include "xfs_da_btree.h"
  28#include "xfs_bmap_btree.h"
  29#include "xfs_alloc_btree.h"
  30#include "xfs_ialloc_btree.h"
  31#include "xfs_alloc.h"
  32#include "xfs_btree.h"
  33#include "xfs_attr_sf.h"
  34#include "xfs_dinode.h"
  35#include "xfs_inode.h"
  36#include "xfs_inode_item.h"
  37#include "xfs_bmap.h"
  38#include "xfs_attr.h"
  39#include "xfs_attr_leaf.h"
  40#include "xfs_error.h"
  41#include "xfs_trace.h"
  42
  43/*
  44 * xfs_attr_leaf.c
  45 *
  46 * Routines to implement leaf blocks of attributes as Btrees of hashed names.
  47 */
  48
  49/*========================================================================
  50 * Function prototypes for the kernel.
  51 *========================================================================*/
  52
  53/*
  54 * Routines used for growing the Btree.
  55 */
  56STATIC int xfs_attr_leaf_create(xfs_da_args_t *args, xfs_dablk_t which_block,
  57                                struct xfs_buf **bpp);
  58STATIC int xfs_attr_leaf_add_work(struct xfs_buf *leaf_buffer,
  59                                  xfs_da_args_t *args, int freemap_index);
  60STATIC void xfs_attr_leaf_compact(xfs_trans_t *tp, struct xfs_buf *leaf_buffer);
  61STATIC void xfs_attr_leaf_rebalance(xfs_da_state_t *state,
  62                                                   xfs_da_state_blk_t *blk1,
  63                                                   xfs_da_state_blk_t *blk2);
  64STATIC int xfs_attr_leaf_figure_balance(xfs_da_state_t *state,
  65                                           xfs_da_state_blk_t *leaf_blk_1,
  66                                           xfs_da_state_blk_t *leaf_blk_2,
  67                                           int *number_entries_in_blk1,
  68                                           int *number_usedbytes_in_blk1);
  69
  70/*
  71 * Routines used for shrinking the Btree.
  72 */
  73STATIC int xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp,
  74                                  struct xfs_buf *bp, int level);
  75STATIC int xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp,
  76                                  struct xfs_buf *bp);
  77STATIC int xfs_attr_leaf_freextent(xfs_trans_t **trans, xfs_inode_t *dp,
  78                                   xfs_dablk_t blkno, int blkcnt);
  79
  80/*
  81 * Utility routines.
  82 */
  83STATIC void xfs_attr_leaf_moveents(xfs_attr_leafblock_t *src_leaf,
  84                                         int src_start,
  85                                         xfs_attr_leafblock_t *dst_leaf,
  86                                         int dst_start, int move_count,
  87                                         xfs_mount_t *mp);
  88STATIC int xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index);
  89
  90/*========================================================================
  91 * Namespace helper routines
  92 *========================================================================*/
  93
  94/*
  95 * If namespace bits don't match return 0.
  96 * If all match then return 1.
  97 */
  98STATIC int
  99xfs_attr_namesp_match(int arg_flags, int ondisk_flags)
 100{
 101        return XFS_ATTR_NSP_ONDISK(ondisk_flags) == XFS_ATTR_NSP_ARGS_TO_ONDISK(arg_flags);
 102}
 103
 104
 105/*========================================================================
 106 * External routines when attribute fork size < XFS_LITINO(mp).
 107 *========================================================================*/
 108
 109/*
 110 * Query whether the requested number of additional bytes of extended
 111 * attribute space will be able to fit inline.
 112 *
 113 * Returns zero if not, else the di_forkoff fork offset to be used in the
 114 * literal area for attribute data once the new bytes have been added.
 115 *
 116 * di_forkoff must be 8 byte aligned, hence is stored as a >>3 value;
 117 * special case for dev/uuid inodes, they have fixed size data forks.
 118 */
 119int
 120xfs_attr_shortform_bytesfit(xfs_inode_t *dp, int bytes)
 121{
 122        int offset;
 123        int minforkoff; /* lower limit on valid forkoff locations */
 124        int maxforkoff; /* upper limit on valid forkoff locations */
 125        int dsize;
 126        xfs_mount_t *mp = dp->i_mount;
 127
 128        offset = (XFS_LITINO(mp) - bytes) >> 3; /* rounded down */
 129
 130        switch (dp->i_d.di_format) {
 131        case XFS_DINODE_FMT_DEV:
 132                minforkoff = roundup(sizeof(xfs_dev_t), 8) >> 3;
 133                return (offset >= minforkoff) ? minforkoff : 0;
 134        case XFS_DINODE_FMT_UUID:
 135                minforkoff = roundup(sizeof(uuid_t), 8) >> 3;
 136                return (offset >= minforkoff) ? minforkoff : 0;
 137        }
 138
 139        /*
 140         * If the requested numbers of bytes is smaller or equal to the
 141         * current attribute fork size we can always proceed.
 142         *
 143         * Note that if_bytes in the data fork might actually be larger than
 144         * the current data fork size is due to delalloc extents. In that
 145         * case either the extent count will go down when they are converted
 146         * to real extents, or the delalloc conversion will take care of the
 147         * literal area rebalancing.
 148         */
 149        if (bytes <= XFS_IFORK_ASIZE(dp))
 150                return dp->i_d.di_forkoff;
 151
 152        /*
 153         * For attr2 we can try to move the forkoff if there is space in the
 154         * literal area, but for the old format we are done if there is no
 155         * space in the fixed attribute fork.
 156         */
 157        if (!(mp->m_flags & XFS_MOUNT_ATTR2))
 158                return 0;
 159
 160        dsize = dp->i_df.if_bytes;
 161
 162        switch (dp->i_d.di_format) {
 163        case XFS_DINODE_FMT_EXTENTS:
 164                /*
 165                 * If there is no attr fork and the data fork is extents, 
 166                 * determine if creating the default attr fork will result
 167                 * in the extents form migrating to btree. If so, the
 168                 * minimum offset only needs to be the space required for
 169                 * the btree root.
 170                 */
 171                if (!dp->i_d.di_forkoff && dp->i_df.if_bytes >
 172                    xfs_default_attroffset(dp))
 173                        dsize = XFS_BMDR_SPACE_CALC(MINDBTPTRS);
 174                break;
 175        case XFS_DINODE_FMT_BTREE:
 176                /*
 177                 * If we have a data btree then keep forkoff if we have one,
 178                 * otherwise we are adding a new attr, so then we set
 179                 * minforkoff to where the btree root can finish so we have
 180                 * plenty of room for attrs
 181                 */
 182                if (dp->i_d.di_forkoff) {
 183                        if (offset < dp->i_d.di_forkoff)
 184                                return 0;
 185                        return dp->i_d.di_forkoff;
 186                }
 187                dsize = XFS_BMAP_BROOT_SPACE(dp->i_df.if_broot);
 188                break;
 189        }
 190
 191        /*
 192         * A data fork btree root must have space for at least
 193         * MINDBTPTRS key/ptr pairs if the data fork is small or empty.
 194         */
 195        minforkoff = MAX(dsize, XFS_BMDR_SPACE_CALC(MINDBTPTRS));
 196        minforkoff = roundup(minforkoff, 8) >> 3;
 197
 198        /* attr fork btree root can have at least this many key/ptr pairs */
 199        maxforkoff = XFS_LITINO(mp) - XFS_BMDR_SPACE_CALC(MINABTPTRS);
 200        maxforkoff = maxforkoff >> 3;   /* rounded down */
 201
 202        if (offset >= maxforkoff)
 203                return maxforkoff;
 204        if (offset >= minforkoff)
 205                return offset;
 206        return 0;
 207}
 208
 209/*
 210 * Switch on the ATTR2 superblock bit (implies also FEATURES2)
 211 */
 212STATIC void
 213xfs_sbversion_add_attr2(xfs_mount_t *mp, xfs_trans_t *tp)
 214{
 215        if ((mp->m_flags & XFS_MOUNT_ATTR2) &&
 216            !(xfs_sb_version_hasattr2(&mp->m_sb))) {
 217                spin_lock(&mp->m_sb_lock);
 218                if (!xfs_sb_version_hasattr2(&mp->m_sb)) {
 219                        xfs_sb_version_addattr2(&mp->m_sb);
 220                        spin_unlock(&mp->m_sb_lock);
 221                        xfs_mod_sb(tp, XFS_SB_VERSIONNUM | XFS_SB_FEATURES2);
 222                } else
 223                        spin_unlock(&mp->m_sb_lock);
 224        }
 225}
 226
 227/*
 228 * Create the initial contents of a shortform attribute list.
 229 */
 230void
 231xfs_attr_shortform_create(xfs_da_args_t *args)
 232{
 233        xfs_attr_sf_hdr_t *hdr;
 234        xfs_inode_t *dp;
 235        xfs_ifork_t *ifp;
 236
 237        trace_xfs_attr_sf_create(args);
 238
 239        dp = args->dp;
 240        ASSERT(dp != NULL);
 241        ifp = dp->i_afp;
 242        ASSERT(ifp != NULL);
 243        ASSERT(ifp->if_bytes == 0);
 244        if (dp->i_d.di_aformat == XFS_DINODE_FMT_EXTENTS) {
 245                ifp->if_flags &= ~XFS_IFEXTENTS;        /* just in case */
 246                dp->i_d.di_aformat = XFS_DINODE_FMT_LOCAL;
 247                ifp->if_flags |= XFS_IFINLINE;
 248        } else {
 249                ASSERT(ifp->if_flags & XFS_IFINLINE);
 250        }
 251        xfs_idata_realloc(dp, sizeof(*hdr), XFS_ATTR_FORK);
 252        hdr = (xfs_attr_sf_hdr_t *)ifp->if_u1.if_data;
 253        hdr->count = 0;
 254        hdr->totsize = cpu_to_be16(sizeof(*hdr));
 255        xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
 256}
 257
 258/*
 259 * Add a name/value pair to the shortform attribute list.
 260 * Overflow from the inode has already been checked for.
 261 */
 262void
 263xfs_attr_shortform_add(xfs_da_args_t *args, int forkoff)
 264{
 265        xfs_attr_shortform_t *sf;
 266        xfs_attr_sf_entry_t *sfe;
 267        int i, offset, size;
 268        xfs_mount_t *mp;
 269        xfs_inode_t *dp;
 270        xfs_ifork_t *ifp;
 271
 272        trace_xfs_attr_sf_add(args);
 273
 274        dp = args->dp;
 275        mp = dp->i_mount;
 276        dp->i_d.di_forkoff = forkoff;
 277
 278        ifp = dp->i_afp;
 279        ASSERT(ifp->if_flags & XFS_IFINLINE);
 280        sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
 281        sfe = &sf->list[0];
 282        for (i = 0; i < sf->hdr.count; sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
 283#ifdef DEBUG
 284                if (sfe->namelen != args->namelen)
 285                        continue;
 286                if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
 287                        continue;
 288                if (!xfs_attr_namesp_match(args->flags, sfe->flags))
 289                        continue;
 290                ASSERT(0);
 291#endif
 292        }
 293
 294        offset = (char *)sfe - (char *)sf;
 295        size = XFS_ATTR_SF_ENTSIZE_BYNAME(args->namelen, args->valuelen);
 296        xfs_idata_realloc(dp, size, XFS_ATTR_FORK);
 297        sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
 298        sfe = (xfs_attr_sf_entry_t *)((char *)sf + offset);
 299
 300        sfe->namelen = args->namelen;
 301        sfe->valuelen = args->valuelen;
 302        sfe->flags = XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
 303        memcpy(sfe->nameval, args->name, args->namelen);
 304        memcpy(&sfe->nameval[args->namelen], args->value, args->valuelen);
 305        sf->hdr.count++;
 306        be16_add_cpu(&sf->hdr.totsize, size);
 307        xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
 308
 309        xfs_sbversion_add_attr2(mp, args->trans);
 310}
 311
 312/*
 313 * After the last attribute is removed revert to original inode format,
 314 * making all literal area available to the data fork once more.
 315 */
 316STATIC void
 317xfs_attr_fork_reset(
 318        struct xfs_inode        *ip,
 319        struct xfs_trans        *tp)
 320{
 321        xfs_idestroy_fork(ip, XFS_ATTR_FORK);
 322        ip->i_d.di_forkoff = 0;
 323        ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
 324
 325        ASSERT(ip->i_d.di_anextents == 0);
 326        ASSERT(ip->i_afp == NULL);
 327
 328        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 329}
 330
 331/*
 332 * Remove an attribute from the shortform attribute list structure.
 333 */
 334int
 335xfs_attr_shortform_remove(xfs_da_args_t *args)
 336{
 337        xfs_attr_shortform_t *sf;
 338        xfs_attr_sf_entry_t *sfe;
 339        int base, size=0, end, totsize, i;
 340        xfs_mount_t *mp;
 341        xfs_inode_t *dp;
 342
 343        trace_xfs_attr_sf_remove(args);
 344
 345        dp = args->dp;
 346        mp = dp->i_mount;
 347        base = sizeof(xfs_attr_sf_hdr_t);
 348        sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
 349        sfe = &sf->list[0];
 350        end = sf->hdr.count;
 351        for (i = 0; i < end; sfe = XFS_ATTR_SF_NEXTENTRY(sfe),
 352                                        base += size, i++) {
 353                size = XFS_ATTR_SF_ENTSIZE(sfe);
 354                if (sfe->namelen != args->namelen)
 355                        continue;
 356                if (memcmp(sfe->nameval, args->name, args->namelen) != 0)
 357                        continue;
 358                if (!xfs_attr_namesp_match(args->flags, sfe->flags))
 359                        continue;
 360                break;
 361        }
 362        if (i == end)
 363                return(XFS_ERROR(ENOATTR));
 364
 365        /*
 366         * Fix up the attribute fork data, covering the hole
 367         */
 368        end = base + size;
 369        totsize = be16_to_cpu(sf->hdr.totsize);
 370        if (end != totsize)
 371                memmove(&((char *)sf)[base], &((char *)sf)[end], totsize - end);
 372        sf->hdr.count--;
 373        be16_add_cpu(&sf->hdr.totsize, -size);
 374
 375        /*
 376         * Fix up the start offset of the attribute fork
 377         */
 378        totsize -= size;
 379        if (totsize == sizeof(xfs_attr_sf_hdr_t) &&
 380            (mp->m_flags & XFS_MOUNT_ATTR2) &&
 381            (dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
 382            !(args->op_flags & XFS_DA_OP_ADDNAME)) {
 383                xfs_attr_fork_reset(dp, args->trans);
 384        } else {
 385                xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
 386                dp->i_d.di_forkoff = xfs_attr_shortform_bytesfit(dp, totsize);
 387                ASSERT(dp->i_d.di_forkoff);
 388                ASSERT(totsize > sizeof(xfs_attr_sf_hdr_t) ||
 389                                (args->op_flags & XFS_DA_OP_ADDNAME) ||
 390                                !(mp->m_flags & XFS_MOUNT_ATTR2) ||
 391                                dp->i_d.di_format == XFS_DINODE_FMT_BTREE);
 392                xfs_trans_log_inode(args->trans, dp,
 393                                        XFS_ILOG_CORE | XFS_ILOG_ADATA);
 394        }
 395
 396        xfs_sbversion_add_attr2(mp, args->trans);
 397
 398        return(0);
 399}
 400
 401/*
 402 * Look up a name in a shortform attribute list structure.
 403 */
 404/*ARGSUSED*/
 405int
 406xfs_attr_shortform_lookup(xfs_da_args_t *args)
 407{
 408        xfs_attr_shortform_t *sf;
 409        xfs_attr_sf_entry_t *sfe;
 410        int i;
 411        xfs_ifork_t *ifp;
 412
 413        trace_xfs_attr_sf_lookup(args);
 414
 415        ifp = args->dp->i_afp;
 416        ASSERT(ifp->if_flags & XFS_IFINLINE);
 417        sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
 418        sfe = &sf->list[0];
 419        for (i = 0; i < sf->hdr.count;
 420                                sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
 421                if (sfe->namelen != args->namelen)
 422                        continue;
 423                if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
 424                        continue;
 425                if (!xfs_attr_namesp_match(args->flags, sfe->flags))
 426                        continue;
 427                return(XFS_ERROR(EEXIST));
 428        }
 429        return(XFS_ERROR(ENOATTR));
 430}
 431
 432/*
 433 * Look up a name in a shortform attribute list structure.
 434 */
 435/*ARGSUSED*/
 436int
 437xfs_attr_shortform_getvalue(xfs_da_args_t *args)
 438{
 439        xfs_attr_shortform_t *sf;
 440        xfs_attr_sf_entry_t *sfe;
 441        int i;
 442
 443        ASSERT(args->dp->i_d.di_aformat == XFS_IFINLINE);
 444        sf = (xfs_attr_shortform_t *)args->dp->i_afp->if_u1.if_data;
 445        sfe = &sf->list[0];
 446        for (i = 0; i < sf->hdr.count;
 447                                sfe = XFS_ATTR_SF_NEXTENTRY(sfe), i++) {
 448                if (sfe->namelen != args->namelen)
 449                        continue;
 450                if (memcmp(args->name, sfe->nameval, args->namelen) != 0)
 451                        continue;
 452                if (!xfs_attr_namesp_match(args->flags, sfe->flags))
 453                        continue;
 454                if (args->flags & ATTR_KERNOVAL) {
 455                        args->valuelen = sfe->valuelen;
 456                        return(XFS_ERROR(EEXIST));
 457                }
 458                if (args->valuelen < sfe->valuelen) {
 459                        args->valuelen = sfe->valuelen;
 460                        return(XFS_ERROR(ERANGE));
 461                }
 462                args->valuelen = sfe->valuelen;
 463                memcpy(args->value, &sfe->nameval[args->namelen],
 464                                                    args->valuelen);
 465                return(XFS_ERROR(EEXIST));
 466        }
 467        return(XFS_ERROR(ENOATTR));
 468}
 469
 470/*
 471 * Convert from using the shortform to the leaf.
 472 */
 473int
 474xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
 475{
 476        xfs_inode_t *dp;
 477        xfs_attr_shortform_t *sf;
 478        xfs_attr_sf_entry_t *sfe;
 479        xfs_da_args_t nargs;
 480        char *tmpbuffer;
 481        int error, i, size;
 482        xfs_dablk_t blkno;
 483        struct xfs_buf *bp;
 484        xfs_ifork_t *ifp;
 485
 486        trace_xfs_attr_sf_to_leaf(args);
 487
 488        dp = args->dp;
 489        ifp = dp->i_afp;
 490        sf = (xfs_attr_shortform_t *)ifp->if_u1.if_data;
 491        size = be16_to_cpu(sf->hdr.totsize);
 492        tmpbuffer = kmem_alloc(size, KM_SLEEP);
 493        ASSERT(tmpbuffer != NULL);
 494        memcpy(tmpbuffer, ifp->if_u1.if_data, size);
 495        sf = (xfs_attr_shortform_t *)tmpbuffer;
 496
 497        xfs_idata_realloc(dp, -size, XFS_ATTR_FORK);
 498        bp = NULL;
 499        error = xfs_da_grow_inode(args, &blkno);
 500        if (error) {
 501                /*
 502                 * If we hit an IO error middle of the transaction inside
 503                 * grow_inode(), we may have inconsistent data. Bail out.
 504                 */
 505                if (error == EIO)
 506                        goto out;
 507                xfs_idata_realloc(dp, size, XFS_ATTR_FORK);     /* try to put */
 508                memcpy(ifp->if_u1.if_data, tmpbuffer, size);    /* it back */
 509                goto out;
 510        }
 511
 512        ASSERT(blkno == 0);
 513        error = xfs_attr_leaf_create(args, blkno, &bp);
 514        if (error) {
 515                error = xfs_da_shrink_inode(args, 0, bp);
 516                bp = NULL;
 517                if (error)
 518                        goto out;
 519                xfs_idata_realloc(dp, size, XFS_ATTR_FORK);     /* try to put */
 520                memcpy(ifp->if_u1.if_data, tmpbuffer, size);    /* it back */
 521                goto out;
 522        }
 523
 524        memset((char *)&nargs, 0, sizeof(nargs));
 525        nargs.dp = dp;
 526        nargs.firstblock = args->firstblock;
 527        nargs.flist = args->flist;
 528        nargs.total = args->total;
 529        nargs.whichfork = XFS_ATTR_FORK;
 530        nargs.trans = args->trans;
 531        nargs.op_flags = XFS_DA_OP_OKNOENT;
 532
 533        sfe = &sf->list[0];
 534        for (i = 0; i < sf->hdr.count; i++) {
 535                nargs.name = sfe->nameval;
 536                nargs.namelen = sfe->namelen;
 537                nargs.value = &sfe->nameval[nargs.namelen];
 538                nargs.valuelen = sfe->valuelen;
 539                nargs.hashval = xfs_da_hashname(sfe->nameval,
 540                                                sfe->namelen);
 541                nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(sfe->flags);
 542                error = xfs_attr_leaf_lookup_int(bp, &nargs); /* set a->index */
 543                ASSERT(error == ENOATTR);
 544                error = xfs_attr_leaf_add(bp, &nargs);
 545                ASSERT(error != ENOSPC);
 546                if (error)
 547                        goto out;
 548                sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
 549        }
 550        error = 0;
 551
 552out:
 553        kmem_free(tmpbuffer);
 554        return(error);
 555}
 556
 557STATIC int
 558xfs_attr_shortform_compare(const void *a, const void *b)
 559{
 560        xfs_attr_sf_sort_t *sa, *sb;
 561
 562        sa = (xfs_attr_sf_sort_t *)a;
 563        sb = (xfs_attr_sf_sort_t *)b;
 564        if (sa->hash < sb->hash) {
 565                return(-1);
 566        } else if (sa->hash > sb->hash) {
 567                return(1);
 568        } else {
 569                return(sa->entno - sb->entno);
 570        }
 571}
 572
 573
 574#define XFS_ISRESET_CURSOR(cursor) \
 575        (!((cursor)->initted) && !((cursor)->hashval) && \
 576         !((cursor)->blkno) && !((cursor)->offset))
 577/*
 578 * Copy out entries of shortform attribute lists for attr_list().
 579 * Shortform attribute lists are not stored in hashval sorted order.
 580 * If the output buffer is not large enough to hold them all, then we
 581 * we have to calculate each entries' hashvalue and sort them before
 582 * we can begin returning them to the user.
 583 */
 584/*ARGSUSED*/
 585int
 586xfs_attr_shortform_list(xfs_attr_list_context_t *context)
 587{
 588        attrlist_cursor_kern_t *cursor;
 589        xfs_attr_sf_sort_t *sbuf, *sbp;
 590        xfs_attr_shortform_t *sf;
 591        xfs_attr_sf_entry_t *sfe;
 592        xfs_inode_t *dp;
 593        int sbsize, nsbuf, count, i;
 594        int error;
 595
 596        ASSERT(context != NULL);
 597        dp = context->dp;
 598        ASSERT(dp != NULL);
 599        ASSERT(dp->i_afp != NULL);
 600        sf = (xfs_attr_shortform_t *)dp->i_afp->if_u1.if_data;
 601        ASSERT(sf != NULL);
 602        if (!sf->hdr.count)
 603                return(0);
 604        cursor = context->cursor;
 605        ASSERT(cursor != NULL);
 606
 607        trace_xfs_attr_list_sf(context);
 608
 609        /*
 610         * If the buffer is large enough and the cursor is at the start,
 611         * do not bother with sorting since we will return everything in
 612         * one buffer and another call using the cursor won't need to be
 613         * made.
 614         * Note the generous fudge factor of 16 overhead bytes per entry.
 615         * If bufsize is zero then put_listent must be a search function
 616         * and can just scan through what we have.
 617         */
 618        if (context->bufsize == 0 ||
 619            (XFS_ISRESET_CURSOR(cursor) &&
 620             (dp->i_afp->if_bytes + sf->hdr.count * 16) < context->bufsize)) {
 621                for (i = 0, sfe = &sf->list[0]; i < sf->hdr.count; i++) {
 622                        error = context->put_listent(context,
 623                                           sfe->flags,
 624                                           sfe->nameval,
 625                                           (int)sfe->namelen,
 626                                           (int)sfe->valuelen,
 627                                           &sfe->nameval[sfe->namelen]);
 628
 629                        /*
 630                         * Either search callback finished early or
 631                         * didn't fit it all in the buffer after all.
 632                         */
 633                        if (context->seen_enough)
 634                                break;
 635
 636                        if (error)
 637                                return error;
 638                        sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
 639                }
 640                trace_xfs_attr_list_sf_all(context);
 641                return(0);
 642        }
 643
 644        /* do no more for a search callback */
 645        if (context->bufsize == 0)
 646                return 0;
 647
 648        /*
 649         * It didn't all fit, so we have to sort everything on hashval.
 650         */
 651        sbsize = sf->hdr.count * sizeof(*sbuf);
 652        sbp = sbuf = kmem_alloc(sbsize, KM_SLEEP | KM_NOFS);
 653
 654        /*
 655         * Scan the attribute list for the rest of the entries, storing
 656         * the relevant info from only those that match into a buffer.
 657         */
 658        nsbuf = 0;
 659        for (i = 0, sfe = &sf->list[0]; i < sf->hdr.count; i++) {
 660                if (unlikely(
 661                    ((char *)sfe < (char *)sf) ||
 662                    ((char *)sfe >= ((char *)sf + dp->i_afp->if_bytes)))) {
 663                        XFS_CORRUPTION_ERROR("xfs_attr_shortform_list",
 664                                             XFS_ERRLEVEL_LOW,
 665                                             context->dp->i_mount, sfe);
 666                        kmem_free(sbuf);
 667                        return XFS_ERROR(EFSCORRUPTED);
 668                }
 669
 670                sbp->entno = i;
 671                sbp->hash = xfs_da_hashname(sfe->nameval, sfe->namelen);
 672                sbp->name = sfe->nameval;
 673                sbp->namelen = sfe->namelen;
 674                /* These are bytes, and both on-disk, don't endian-flip */
 675                sbp->valuelen = sfe->valuelen;
 676                sbp->flags = sfe->flags;
 677                sfe = XFS_ATTR_SF_NEXTENTRY(sfe);
 678                sbp++;
 679                nsbuf++;
 680        }
 681
 682        /*
 683         * Sort the entries on hash then entno.
 684         */
 685        xfs_sort(sbuf, nsbuf, sizeof(*sbuf), xfs_attr_shortform_compare);
 686
 687        /*
 688         * Re-find our place IN THE SORTED LIST.
 689         */
 690        count = 0;
 691        cursor->initted = 1;
 692        cursor->blkno = 0;
 693        for (sbp = sbuf, i = 0; i < nsbuf; i++, sbp++) {
 694                if (sbp->hash == cursor->hashval) {
 695                        if (cursor->offset == count) {
 696                                break;
 697                        }
 698                        count++;
 699                } else if (sbp->hash > cursor->hashval) {
 700                        break;
 701                }
 702        }
 703        if (i == nsbuf) {
 704                kmem_free(sbuf);
 705                return(0);
 706        }
 707
 708        /*
 709         * Loop putting entries into the user buffer.
 710         */
 711        for ( ; i < nsbuf; i++, sbp++) {
 712                if (cursor->hashval != sbp->hash) {
 713                        cursor->hashval = sbp->hash;
 714                        cursor->offset = 0;
 715                }
 716                error = context->put_listent(context,
 717                                        sbp->flags,
 718                                        sbp->name,
 719                                        sbp->namelen,
 720                                        sbp->valuelen,
 721                                        &sbp->name[sbp->namelen]);
 722                if (error)
 723                        return error;
 724                if (context->seen_enough)
 725                        break;
 726                cursor->offset++;
 727        }
 728
 729        kmem_free(sbuf);
 730        return(0);
 731}
 732
 733/*
 734 * Check a leaf attribute block to see if all the entries would fit into
 735 * a shortform attribute list.
 736 */
 737int
 738xfs_attr_shortform_allfit(
 739        struct xfs_buf  *bp,
 740        struct xfs_inode *dp)
 741{
 742        xfs_attr_leafblock_t *leaf;
 743        xfs_attr_leaf_entry_t *entry;
 744        xfs_attr_leaf_name_local_t *name_loc;
 745        int bytes, i;
 746
 747        leaf = bp->b_addr;
 748        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 749
 750        entry = &leaf->entries[0];
 751        bytes = sizeof(struct xfs_attr_sf_hdr);
 752        for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
 753                if (entry->flags & XFS_ATTR_INCOMPLETE)
 754                        continue;               /* don't copy partial entries */
 755                if (!(entry->flags & XFS_ATTR_LOCAL))
 756                        return(0);
 757                name_loc = xfs_attr_leaf_name_local(leaf, i);
 758                if (name_loc->namelen >= XFS_ATTR_SF_ENTSIZE_MAX)
 759                        return(0);
 760                if (be16_to_cpu(name_loc->valuelen) >= XFS_ATTR_SF_ENTSIZE_MAX)
 761                        return(0);
 762                bytes += sizeof(struct xfs_attr_sf_entry)-1
 763                                + name_loc->namelen
 764                                + be16_to_cpu(name_loc->valuelen);
 765        }
 766        if ((dp->i_mount->m_flags & XFS_MOUNT_ATTR2) &&
 767            (dp->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
 768            (bytes == sizeof(struct xfs_attr_sf_hdr)))
 769                return(-1);
 770        return(xfs_attr_shortform_bytesfit(dp, bytes));
 771}
 772
 773/*
 774 * Convert a leaf attribute list to shortform attribute list
 775 */
 776int
 777xfs_attr_leaf_to_shortform(
 778        struct xfs_buf  *bp,
 779        xfs_da_args_t   *args,
 780        int             forkoff)
 781{
 782        xfs_attr_leafblock_t *leaf;
 783        xfs_attr_leaf_entry_t *entry;
 784        xfs_attr_leaf_name_local_t *name_loc;
 785        xfs_da_args_t nargs;
 786        xfs_inode_t *dp;
 787        char *tmpbuffer;
 788        int error, i;
 789
 790        trace_xfs_attr_leaf_to_sf(args);
 791
 792        dp = args->dp;
 793        tmpbuffer = kmem_alloc(XFS_LBSIZE(dp->i_mount), KM_SLEEP);
 794        ASSERT(tmpbuffer != NULL);
 795
 796        ASSERT(bp != NULL);
 797        memcpy(tmpbuffer, bp->b_addr, XFS_LBSIZE(dp->i_mount));
 798        leaf = (xfs_attr_leafblock_t *)tmpbuffer;
 799        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 800        memset(bp->b_addr, 0, XFS_LBSIZE(dp->i_mount));
 801
 802        /*
 803         * Clean out the prior contents of the attribute list.
 804         */
 805        error = xfs_da_shrink_inode(args, 0, bp);
 806        if (error)
 807                goto out;
 808
 809        if (forkoff == -1) {
 810                ASSERT(dp->i_mount->m_flags & XFS_MOUNT_ATTR2);
 811                ASSERT(dp->i_d.di_format != XFS_DINODE_FMT_BTREE);
 812                xfs_attr_fork_reset(dp, args->trans);
 813                goto out;
 814        }
 815
 816        xfs_attr_shortform_create(args);
 817
 818        /*
 819         * Copy the attributes
 820         */
 821        memset((char *)&nargs, 0, sizeof(nargs));
 822        nargs.dp = dp;
 823        nargs.firstblock = args->firstblock;
 824        nargs.flist = args->flist;
 825        nargs.total = args->total;
 826        nargs.whichfork = XFS_ATTR_FORK;
 827        nargs.trans = args->trans;
 828        nargs.op_flags = XFS_DA_OP_OKNOENT;
 829        entry = &leaf->entries[0];
 830        for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
 831                if (entry->flags & XFS_ATTR_INCOMPLETE)
 832                        continue;       /* don't copy partial entries */
 833                if (!entry->nameidx)
 834                        continue;
 835                ASSERT(entry->flags & XFS_ATTR_LOCAL);
 836                name_loc = xfs_attr_leaf_name_local(leaf, i);
 837                nargs.name = name_loc->nameval;
 838                nargs.namelen = name_loc->namelen;
 839                nargs.value = &name_loc->nameval[nargs.namelen];
 840                nargs.valuelen = be16_to_cpu(name_loc->valuelen);
 841                nargs.hashval = be32_to_cpu(entry->hashval);
 842                nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(entry->flags);
 843                xfs_attr_shortform_add(&nargs, forkoff);
 844        }
 845        error = 0;
 846
 847out:
 848        kmem_free(tmpbuffer);
 849        return(error);
 850}
 851
 852/*
 853 * Convert from using a single leaf to a root node and a leaf.
 854 */
 855int
 856xfs_attr_leaf_to_node(xfs_da_args_t *args)
 857{
 858        xfs_attr_leafblock_t *leaf;
 859        xfs_da_intnode_t *node;
 860        xfs_inode_t *dp;
 861        struct xfs_buf *bp1, *bp2;
 862        xfs_dablk_t blkno;
 863        int error;
 864
 865        trace_xfs_attr_leaf_to_node(args);
 866
 867        dp = args->dp;
 868        bp1 = bp2 = NULL;
 869        error = xfs_da_grow_inode(args, &blkno);
 870        if (error)
 871                goto out;
 872        error = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp1,
 873                                             XFS_ATTR_FORK);
 874        if (error)
 875                goto out;
 876        ASSERT(bp1 != NULL);
 877        bp2 = NULL;
 878        error = xfs_da_get_buf(args->trans, args->dp, blkno, -1, &bp2,
 879                                            XFS_ATTR_FORK);
 880        if (error)
 881                goto out;
 882        ASSERT(bp2 != NULL);
 883        memcpy(bp2->b_addr, bp1->b_addr, XFS_LBSIZE(dp->i_mount));
 884        bp1 = NULL;
 885        xfs_trans_log_buf(args->trans, bp2, 0, XFS_LBSIZE(dp->i_mount) - 1);
 886
 887        /*
 888         * Set up the new root node.
 889         */
 890        error = xfs_da_node_create(args, 0, 1, &bp1, XFS_ATTR_FORK);
 891        if (error)
 892                goto out;
 893        node = bp1->b_addr;
 894        leaf = bp2->b_addr;
 895        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
 896        /* both on-disk, don't endian-flip twice */
 897        node->btree[0].hashval =
 898                leaf->entries[be16_to_cpu(leaf->hdr.count)-1 ].hashval;
 899        node->btree[0].before = cpu_to_be32(blkno);
 900        node->hdr.count = cpu_to_be16(1);
 901        xfs_trans_log_buf(args->trans, bp1, 0, XFS_LBSIZE(dp->i_mount) - 1);
 902        error = 0;
 903out:
 904        return(error);
 905}
 906
 907
 908/*========================================================================
 909 * Routines used for growing the Btree.
 910 *========================================================================*/
 911
 912/*
 913 * Create the initial contents of a leaf attribute list
 914 * or a leaf in a node attribute list.
 915 */
 916STATIC int
 917xfs_attr_leaf_create(
 918        xfs_da_args_t   *args,
 919        xfs_dablk_t     blkno,
 920        struct xfs_buf  **bpp)
 921{
 922        xfs_attr_leafblock_t *leaf;
 923        xfs_attr_leaf_hdr_t *hdr;
 924        xfs_inode_t *dp;
 925        struct xfs_buf *bp;
 926        int error;
 927
 928        trace_xfs_attr_leaf_create(args);
 929
 930        dp = args->dp;
 931        ASSERT(dp != NULL);
 932        error = xfs_da_get_buf(args->trans, args->dp, blkno, -1, &bp,
 933                                            XFS_ATTR_FORK);
 934        if (error)
 935                return(error);
 936        ASSERT(bp != NULL);
 937        leaf = bp->b_addr;
 938        memset((char *)leaf, 0, XFS_LBSIZE(dp->i_mount));
 939        hdr = &leaf->hdr;
 940        hdr->info.magic = cpu_to_be16(XFS_ATTR_LEAF_MAGIC);
 941        hdr->firstused = cpu_to_be16(XFS_LBSIZE(dp->i_mount));
 942        if (!hdr->firstused) {
 943                hdr->firstused = cpu_to_be16(
 944                        XFS_LBSIZE(dp->i_mount) - XFS_ATTR_LEAF_NAME_ALIGN);
 945        }
 946
 947        hdr->freemap[0].base = cpu_to_be16(sizeof(xfs_attr_leaf_hdr_t));
 948        hdr->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr->firstused) -
 949                                           sizeof(xfs_attr_leaf_hdr_t));
 950
 951        xfs_trans_log_buf(args->trans, bp, 0, XFS_LBSIZE(dp->i_mount) - 1);
 952
 953        *bpp = bp;
 954        return(0);
 955}
 956
 957/*
 958 * Split the leaf node, rebalance, then add the new entry.
 959 */
 960int
 961xfs_attr_leaf_split(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
 962                                   xfs_da_state_blk_t *newblk)
 963{
 964        xfs_dablk_t blkno;
 965        int error;
 966
 967        trace_xfs_attr_leaf_split(state->args);
 968
 969        /*
 970         * Allocate space for a new leaf node.
 971         */
 972        ASSERT(oldblk->magic == XFS_ATTR_LEAF_MAGIC);
 973        error = xfs_da_grow_inode(state->args, &blkno);
 974        if (error)
 975                return(error);
 976        error = xfs_attr_leaf_create(state->args, blkno, &newblk->bp);
 977        if (error)
 978                return(error);
 979        newblk->blkno = blkno;
 980        newblk->magic = XFS_ATTR_LEAF_MAGIC;
 981
 982        /*
 983         * Rebalance the entries across the two leaves.
 984         * NOTE: rebalance() currently depends on the 2nd block being empty.
 985         */
 986        xfs_attr_leaf_rebalance(state, oldblk, newblk);
 987        error = xfs_da_blk_link(state, oldblk, newblk);
 988        if (error)
 989                return(error);
 990
 991        /*
 992         * Save info on "old" attribute for "atomic rename" ops, leaf_add()
 993         * modifies the index/blkno/rmtblk/rmtblkcnt fields to show the
 994         * "new" attrs info.  Will need the "old" info to remove it later.
 995         *
 996         * Insert the "new" entry in the correct block.
 997         */
 998        if (state->inleaf) {
 999                trace_xfs_attr_leaf_add_old(state->args);
1000                error = xfs_attr_leaf_add(oldblk->bp, state->args);
1001        } else {
1002                trace_xfs_attr_leaf_add_new(state->args);
1003                error = xfs_attr_leaf_add(newblk->bp, state->args);
1004        }
1005
1006        /*
1007         * Update last hashval in each block since we added the name.
1008         */
1009        oldblk->hashval = xfs_attr_leaf_lasthash(oldblk->bp, NULL);
1010        newblk->hashval = xfs_attr_leaf_lasthash(newblk->bp, NULL);
1011        return(error);
1012}
1013
1014/*
1015 * Add a name to the leaf attribute list structure.
1016 */
1017int
1018xfs_attr_leaf_add(
1019        struct xfs_buf          *bp,
1020        struct xfs_da_args      *args)
1021{
1022        xfs_attr_leafblock_t *leaf;
1023        xfs_attr_leaf_hdr_t *hdr;
1024        xfs_attr_leaf_map_t *map;
1025        int tablesize, entsize, sum, tmp, i;
1026
1027        trace_xfs_attr_leaf_add(args);
1028
1029        leaf = bp->b_addr;
1030        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1031        ASSERT((args->index >= 0)
1032                && (args->index <= be16_to_cpu(leaf->hdr.count)));
1033        hdr = &leaf->hdr;
1034        entsize = xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
1035                           args->trans->t_mountp->m_sb.sb_blocksize, NULL);
1036
1037        /*
1038         * Search through freemap for first-fit on new name length.
1039         * (may need to figure in size of entry struct too)
1040         */
1041        tablesize = (be16_to_cpu(hdr->count) + 1)
1042                                        * sizeof(xfs_attr_leaf_entry_t)
1043                                        + sizeof(xfs_attr_leaf_hdr_t);
1044        map = &hdr->freemap[XFS_ATTR_LEAF_MAPSIZE-1];
1045        for (sum = 0, i = XFS_ATTR_LEAF_MAPSIZE-1; i >= 0; map--, i--) {
1046                if (tablesize > be16_to_cpu(hdr->firstused)) {
1047                        sum += be16_to_cpu(map->size);
1048                        continue;
1049                }
1050                if (!map->size)
1051                        continue;       /* no space in this map */
1052                tmp = entsize;
1053                if (be16_to_cpu(map->base) < be16_to_cpu(hdr->firstused))
1054                        tmp += sizeof(xfs_attr_leaf_entry_t);
1055                if (be16_to_cpu(map->size) >= tmp) {
1056                        tmp = xfs_attr_leaf_add_work(bp, args, i);
1057                        return(tmp);
1058                }
1059                sum += be16_to_cpu(map->size);
1060        }
1061
1062        /*
1063         * If there are no holes in the address space of the block,
1064         * and we don't have enough freespace, then compaction will do us
1065         * no good and we should just give up.
1066         */
1067        if (!hdr->holes && (sum < entsize))
1068                return(XFS_ERROR(ENOSPC));
1069
1070        /*
1071         * Compact the entries to coalesce free space.
1072         * This may change the hdr->count via dropping INCOMPLETE entries.
1073         */
1074        xfs_attr_leaf_compact(args->trans, bp);
1075
1076        /*
1077         * After compaction, the block is guaranteed to have only one
1078         * free region, in freemap[0].  If it is not big enough, give up.
1079         */
1080        if (be16_to_cpu(hdr->freemap[0].size)
1081                                < (entsize + sizeof(xfs_attr_leaf_entry_t)))
1082                return(XFS_ERROR(ENOSPC));
1083
1084        return(xfs_attr_leaf_add_work(bp, args, 0));
1085}
1086
1087/*
1088 * Add a name to a leaf attribute list structure.
1089 */
1090STATIC int
1091xfs_attr_leaf_add_work(
1092        struct xfs_buf  *bp,
1093        xfs_da_args_t   *args,
1094        int             mapindex)
1095{
1096        xfs_attr_leafblock_t *leaf;
1097        xfs_attr_leaf_hdr_t *hdr;
1098        xfs_attr_leaf_entry_t *entry;
1099        xfs_attr_leaf_name_local_t *name_loc;
1100        xfs_attr_leaf_name_remote_t *name_rmt;
1101        xfs_attr_leaf_map_t *map;
1102        xfs_mount_t *mp;
1103        int tmp, i;
1104
1105        leaf = bp->b_addr;
1106        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1107        hdr = &leaf->hdr;
1108        ASSERT((mapindex >= 0) && (mapindex < XFS_ATTR_LEAF_MAPSIZE));
1109        ASSERT((args->index >= 0) && (args->index <= be16_to_cpu(hdr->count)));
1110
1111        /*
1112         * Force open some space in the entry array and fill it in.
1113         */
1114        entry = &leaf->entries[args->index];
1115        if (args->index < be16_to_cpu(hdr->count)) {
1116                tmp  = be16_to_cpu(hdr->count) - args->index;
1117                tmp *= sizeof(xfs_attr_leaf_entry_t);
1118                memmove((char *)(entry+1), (char *)entry, tmp);
1119                xfs_trans_log_buf(args->trans, bp,
1120                    XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
1121        }
1122        be16_add_cpu(&hdr->count, 1);
1123
1124        /*
1125         * Allocate space for the new string (at the end of the run).
1126         */
1127        map = &hdr->freemap[mapindex];
1128        mp = args->trans->t_mountp;
1129        ASSERT(be16_to_cpu(map->base) < XFS_LBSIZE(mp));
1130        ASSERT((be16_to_cpu(map->base) & 0x3) == 0);
1131        ASSERT(be16_to_cpu(map->size) >=
1132                xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
1133                                         mp->m_sb.sb_blocksize, NULL));
1134        ASSERT(be16_to_cpu(map->size) < XFS_LBSIZE(mp));
1135        ASSERT((be16_to_cpu(map->size) & 0x3) == 0);
1136        be16_add_cpu(&map->size,
1137                -xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
1138                                          mp->m_sb.sb_blocksize, &tmp));
1139        entry->nameidx = cpu_to_be16(be16_to_cpu(map->base) +
1140                                     be16_to_cpu(map->size));
1141        entry->hashval = cpu_to_be32(args->hashval);
1142        entry->flags = tmp ? XFS_ATTR_LOCAL : 0;
1143        entry->flags |= XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
1144        if (args->op_flags & XFS_DA_OP_RENAME) {
1145                entry->flags |= XFS_ATTR_INCOMPLETE;
1146                if ((args->blkno2 == args->blkno) &&
1147                    (args->index2 <= args->index)) {
1148                        args->index2++;
1149                }
1150        }
1151        xfs_trans_log_buf(args->trans, bp,
1152                          XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
1153        ASSERT((args->index == 0) ||
1154               (be32_to_cpu(entry->hashval) >= be32_to_cpu((entry-1)->hashval)));
1155        ASSERT((args->index == be16_to_cpu(hdr->count)-1) ||
1156               (be32_to_cpu(entry->hashval) <= be32_to_cpu((entry+1)->hashval)));
1157
1158        /*
1159         * For "remote" attribute values, simply note that we need to
1160         * allocate space for the "remote" value.  We can't actually
1161         * allocate the extents in this transaction, and we can't decide
1162         * which blocks they should be as we might allocate more blocks
1163         * as part of this transaction (a split operation for example).
1164         */
1165        if (entry->flags & XFS_ATTR_LOCAL) {
1166                name_loc = xfs_attr_leaf_name_local(leaf, args->index);
1167                name_loc->namelen = args->namelen;
1168                name_loc->valuelen = cpu_to_be16(args->valuelen);
1169                memcpy((char *)name_loc->nameval, args->name, args->namelen);
1170                memcpy((char *)&name_loc->nameval[args->namelen], args->value,
1171                                   be16_to_cpu(name_loc->valuelen));
1172        } else {
1173                name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
1174                name_rmt->namelen = args->namelen;
1175                memcpy((char *)name_rmt->name, args->name, args->namelen);
1176                entry->flags |= XFS_ATTR_INCOMPLETE;
1177                /* just in case */
1178                name_rmt->valuelen = 0;
1179                name_rmt->valueblk = 0;
1180                args->rmtblkno = 1;
1181                args->rmtblkcnt = XFS_B_TO_FSB(mp, args->valuelen);
1182        }
1183        xfs_trans_log_buf(args->trans, bp,
1184             XFS_DA_LOGRANGE(leaf, xfs_attr_leaf_name(leaf, args->index),
1185                                   xfs_attr_leaf_entsize(leaf, args->index)));
1186
1187        /*
1188         * Update the control info for this leaf node
1189         */
1190        if (be16_to_cpu(entry->nameidx) < be16_to_cpu(hdr->firstused)) {
1191                /* both on-disk, don't endian-flip twice */
1192                hdr->firstused = entry->nameidx;
1193        }
1194        ASSERT(be16_to_cpu(hdr->firstused) >=
1195               ((be16_to_cpu(hdr->count) * sizeof(*entry)) + sizeof(*hdr)));
1196        tmp = (be16_to_cpu(hdr->count)-1) * sizeof(xfs_attr_leaf_entry_t)
1197                                        + sizeof(xfs_attr_leaf_hdr_t);
1198        map = &hdr->freemap[0];
1199        for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; map++, i++) {
1200                if (be16_to_cpu(map->base) == tmp) {
1201                        be16_add_cpu(&map->base, sizeof(xfs_attr_leaf_entry_t));
1202                        be16_add_cpu(&map->size,
1203                                 -((int)sizeof(xfs_attr_leaf_entry_t)));
1204                }
1205        }
1206        be16_add_cpu(&hdr->usedbytes, xfs_attr_leaf_entsize(leaf, args->index));
1207        xfs_trans_log_buf(args->trans, bp,
1208                XFS_DA_LOGRANGE(leaf, hdr, sizeof(*hdr)));
1209        return(0);
1210}
1211
1212/*
1213 * Garbage collect a leaf attribute list block by copying it to a new buffer.
1214 */
1215STATIC void
1216xfs_attr_leaf_compact(
1217        struct xfs_trans *trans,
1218        struct xfs_buf  *bp)
1219{
1220        xfs_attr_leafblock_t *leaf_s, *leaf_d;
1221        xfs_attr_leaf_hdr_t *hdr_s, *hdr_d;
1222        xfs_mount_t *mp;
1223        char *tmpbuffer;
1224
1225        mp = trans->t_mountp;
1226        tmpbuffer = kmem_alloc(XFS_LBSIZE(mp), KM_SLEEP);
1227        ASSERT(tmpbuffer != NULL);
1228        memcpy(tmpbuffer, bp->b_addr, XFS_LBSIZE(mp));
1229        memset(bp->b_addr, 0, XFS_LBSIZE(mp));
1230
1231        /*
1232         * Copy basic information
1233         */
1234        leaf_s = (xfs_attr_leafblock_t *)tmpbuffer;
1235        leaf_d = bp->b_addr;
1236        hdr_s = &leaf_s->hdr;
1237        hdr_d = &leaf_d->hdr;
1238        hdr_d->info = hdr_s->info;      /* struct copy */
1239        hdr_d->firstused = cpu_to_be16(XFS_LBSIZE(mp));
1240        /* handle truncation gracefully */
1241        if (!hdr_d->firstused) {
1242                hdr_d->firstused = cpu_to_be16(
1243                                XFS_LBSIZE(mp) - XFS_ATTR_LEAF_NAME_ALIGN);
1244        }
1245        hdr_d->usedbytes = 0;
1246        hdr_d->count = 0;
1247        hdr_d->holes = 0;
1248        hdr_d->freemap[0].base = cpu_to_be16(sizeof(xfs_attr_leaf_hdr_t));
1249        hdr_d->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr_d->firstused) -
1250                                             sizeof(xfs_attr_leaf_hdr_t));
1251
1252        /*
1253         * Copy all entry's in the same (sorted) order,
1254         * but allocate name/value pairs packed and in sequence.
1255         */
1256        xfs_attr_leaf_moveents(leaf_s, 0, leaf_d, 0,
1257                                be16_to_cpu(hdr_s->count), mp);
1258        xfs_trans_log_buf(trans, bp, 0, XFS_LBSIZE(mp) - 1);
1259
1260        kmem_free(tmpbuffer);
1261}
1262
1263/*
1264 * Redistribute the attribute list entries between two leaf nodes,
1265 * taking into account the size of the new entry.
1266 *
1267 * NOTE: if new block is empty, then it will get the upper half of the
1268 * old block.  At present, all (one) callers pass in an empty second block.
1269 *
1270 * This code adjusts the args->index/blkno and args->index2/blkno2 fields
1271 * to match what it is doing in splitting the attribute leaf block.  Those
1272 * values are used in "atomic rename" operations on attributes.  Note that
1273 * the "new" and "old" values can end up in different blocks.
1274 */
1275STATIC void
1276xfs_attr_leaf_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
1277                                       xfs_da_state_blk_t *blk2)
1278{
1279        xfs_da_args_t *args;
1280        xfs_da_state_blk_t *tmp_blk;
1281        xfs_attr_leafblock_t *leaf1, *leaf2;
1282        xfs_attr_leaf_hdr_t *hdr1, *hdr2;
1283        int count, totallen, max, space, swap;
1284
1285        /*
1286         * Set up environment.
1287         */
1288        ASSERT(blk1->magic == XFS_ATTR_LEAF_MAGIC);
1289        ASSERT(blk2->magic == XFS_ATTR_LEAF_MAGIC);
1290        leaf1 = blk1->bp->b_addr;
1291        leaf2 = blk2->bp->b_addr;
1292        ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1293        ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1294        args = state->args;
1295
1296        trace_xfs_attr_leaf_rebalance(args);
1297
1298        /*
1299         * Check ordering of blocks, reverse if it makes things simpler.
1300         *
1301         * NOTE: Given that all (current) callers pass in an empty
1302         * second block, this code should never set "swap".
1303         */
1304        swap = 0;
1305        if (xfs_attr_leaf_order(blk1->bp, blk2->bp)) {
1306                tmp_blk = blk1;
1307                blk1 = blk2;
1308                blk2 = tmp_blk;
1309                leaf1 = blk1->bp->b_addr;
1310                leaf2 = blk2->bp->b_addr;
1311                swap = 1;
1312        }
1313        hdr1 = &leaf1->hdr;
1314        hdr2 = &leaf2->hdr;
1315
1316        /*
1317         * Examine entries until we reduce the absolute difference in
1318         * byte usage between the two blocks to a minimum.  Then get
1319         * the direction to copy and the number of elements to move.
1320         *
1321         * "inleaf" is true if the new entry should be inserted into blk1.
1322         * If "swap" is also true, then reverse the sense of "inleaf".
1323         */
1324        state->inleaf = xfs_attr_leaf_figure_balance(state, blk1, blk2,
1325                                                            &count, &totallen);
1326        if (swap)
1327                state->inleaf = !state->inleaf;
1328
1329        /*
1330         * Move any entries required from leaf to leaf:
1331         */
1332        if (count < be16_to_cpu(hdr1->count)) {
1333                /*
1334                 * Figure the total bytes to be added to the destination leaf.
1335                 */
1336                /* number entries being moved */
1337                count = be16_to_cpu(hdr1->count) - count;
1338                space  = be16_to_cpu(hdr1->usedbytes) - totallen;
1339                space += count * sizeof(xfs_attr_leaf_entry_t);
1340
1341                /*
1342                 * leaf2 is the destination, compact it if it looks tight.
1343                 */
1344                max  = be16_to_cpu(hdr2->firstused)
1345                                                - sizeof(xfs_attr_leaf_hdr_t);
1346                max -= be16_to_cpu(hdr2->count) * sizeof(xfs_attr_leaf_entry_t);
1347                if (space > max) {
1348                        xfs_attr_leaf_compact(args->trans, blk2->bp);
1349                }
1350
1351                /*
1352                 * Move high entries from leaf1 to low end of leaf2.
1353                 */
1354                xfs_attr_leaf_moveents(leaf1, be16_to_cpu(hdr1->count) - count,
1355                                leaf2, 0, count, state->mp);
1356
1357                xfs_trans_log_buf(args->trans, blk1->bp, 0, state->blocksize-1);
1358                xfs_trans_log_buf(args->trans, blk2->bp, 0, state->blocksize-1);
1359        } else if (count > be16_to_cpu(hdr1->count)) {
1360                /*
1361                 * I assert that since all callers pass in an empty
1362                 * second buffer, this code should never execute.
1363                 */
1364
1365                /*
1366                 * Figure the total bytes to be added to the destination leaf.
1367                 */
1368                /* number entries being moved */
1369                count -= be16_to_cpu(hdr1->count);
1370                space  = totallen - be16_to_cpu(hdr1->usedbytes);
1371                space += count * sizeof(xfs_attr_leaf_entry_t);
1372
1373                /*
1374                 * leaf1 is the destination, compact it if it looks tight.
1375                 */
1376                max  = be16_to_cpu(hdr1->firstused)
1377                                                - sizeof(xfs_attr_leaf_hdr_t);
1378                max -= be16_to_cpu(hdr1->count) * sizeof(xfs_attr_leaf_entry_t);
1379                if (space > max) {
1380                        xfs_attr_leaf_compact(args->trans, blk1->bp);
1381                }
1382
1383                /*
1384                 * Move low entries from leaf2 to high end of leaf1.
1385                 */
1386                xfs_attr_leaf_moveents(leaf2, 0, leaf1,
1387                                be16_to_cpu(hdr1->count), count, state->mp);
1388
1389                xfs_trans_log_buf(args->trans, blk1->bp, 0, state->blocksize-1);
1390                xfs_trans_log_buf(args->trans, blk2->bp, 0, state->blocksize-1);
1391        }
1392
1393        /*
1394         * Copy out last hashval in each block for B-tree code.
1395         */
1396        blk1->hashval = be32_to_cpu(
1397                leaf1->entries[be16_to_cpu(leaf1->hdr.count)-1].hashval);
1398        blk2->hashval = be32_to_cpu(
1399                leaf2->entries[be16_to_cpu(leaf2->hdr.count)-1].hashval);
1400
1401        /*
1402         * Adjust the expected index for insertion.
1403         * NOTE: this code depends on the (current) situation that the
1404         * second block was originally empty.
1405         *
1406         * If the insertion point moved to the 2nd block, we must adjust
1407         * the index.  We must also track the entry just following the
1408         * new entry for use in an "atomic rename" operation, that entry
1409         * is always the "old" entry and the "new" entry is what we are
1410         * inserting.  The index/blkno fields refer to the "old" entry,
1411         * while the index2/blkno2 fields refer to the "new" entry.
1412         */
1413        if (blk1->index > be16_to_cpu(leaf1->hdr.count)) {
1414                ASSERT(state->inleaf == 0);
1415                blk2->index = blk1->index - be16_to_cpu(leaf1->hdr.count);
1416                args->index = args->index2 = blk2->index;
1417                args->blkno = args->blkno2 = blk2->blkno;
1418        } else if (blk1->index == be16_to_cpu(leaf1->hdr.count)) {
1419                if (state->inleaf) {
1420                        args->index = blk1->index;
1421                        args->blkno = blk1->blkno;
1422                        args->index2 = 0;
1423                        args->blkno2 = blk2->blkno;
1424                } else {
1425                        blk2->index = blk1->index
1426                                    - be16_to_cpu(leaf1->hdr.count);
1427                        args->index = args->index2 = blk2->index;
1428                        args->blkno = args->blkno2 = blk2->blkno;
1429                }
1430        } else {
1431                ASSERT(state->inleaf == 1);
1432                args->index = args->index2 = blk1->index;
1433                args->blkno = args->blkno2 = blk1->blkno;
1434        }
1435}
1436
1437/*
1438 * Examine entries until we reduce the absolute difference in
1439 * byte usage between the two blocks to a minimum.
1440 * GROT: Is this really necessary?  With other than a 512 byte blocksize,
1441 * GROT: there will always be enough room in either block for a new entry.
1442 * GROT: Do a double-split for this case?
1443 */
1444STATIC int
1445xfs_attr_leaf_figure_balance(xfs_da_state_t *state,
1446                                    xfs_da_state_blk_t *blk1,
1447                                    xfs_da_state_blk_t *blk2,
1448                                    int *countarg, int *usedbytesarg)
1449{
1450        xfs_attr_leafblock_t *leaf1, *leaf2;
1451        xfs_attr_leaf_hdr_t *hdr1, *hdr2;
1452        xfs_attr_leaf_entry_t *entry;
1453        int count, max, index, totallen, half;
1454        int lastdelta, foundit, tmp;
1455
1456        /*
1457         * Set up environment.
1458         */
1459        leaf1 = blk1->bp->b_addr;
1460        leaf2 = blk2->bp->b_addr;
1461        hdr1 = &leaf1->hdr;
1462        hdr2 = &leaf2->hdr;
1463        foundit = 0;
1464        totallen = 0;
1465
1466        /*
1467         * Examine entries until we reduce the absolute difference in
1468         * byte usage between the two blocks to a minimum.
1469         */
1470        max = be16_to_cpu(hdr1->count) + be16_to_cpu(hdr2->count);
1471        half  = (max+1) * sizeof(*entry);
1472        half += be16_to_cpu(hdr1->usedbytes) +
1473                be16_to_cpu(hdr2->usedbytes) +
1474                xfs_attr_leaf_newentsize(
1475                                state->args->namelen,
1476                                state->args->valuelen,
1477                                state->blocksize, NULL);
1478        half /= 2;
1479        lastdelta = state->blocksize;
1480        entry = &leaf1->entries[0];
1481        for (count = index = 0; count < max; entry++, index++, count++) {
1482
1483#define XFS_ATTR_ABS(A) (((A) < 0) ? -(A) : (A))
1484                /*
1485                 * The new entry is in the first block, account for it.
1486                 */
1487                if (count == blk1->index) {
1488                        tmp = totallen + sizeof(*entry) +
1489                                xfs_attr_leaf_newentsize(
1490                                                state->args->namelen,
1491                                                state->args->valuelen,
1492                                                state->blocksize, NULL);
1493                        if (XFS_ATTR_ABS(half - tmp) > lastdelta)
1494                                break;
1495                        lastdelta = XFS_ATTR_ABS(half - tmp);
1496                        totallen = tmp;
1497                        foundit = 1;
1498                }
1499
1500                /*
1501                 * Wrap around into the second block if necessary.
1502                 */
1503                if (count == be16_to_cpu(hdr1->count)) {
1504                        leaf1 = leaf2;
1505                        entry = &leaf1->entries[0];
1506                        index = 0;
1507                }
1508
1509                /*
1510                 * Figure out if next leaf entry would be too much.
1511                 */
1512                tmp = totallen + sizeof(*entry) + xfs_attr_leaf_entsize(leaf1,
1513                                                                        index);
1514                if (XFS_ATTR_ABS(half - tmp) > lastdelta)
1515                        break;
1516                lastdelta = XFS_ATTR_ABS(half - tmp);
1517                totallen = tmp;
1518#undef XFS_ATTR_ABS
1519        }
1520
1521        /*
1522         * Calculate the number of usedbytes that will end up in lower block.
1523         * If new entry not in lower block, fix up the count.
1524         */
1525        totallen -= count * sizeof(*entry);
1526        if (foundit) {
1527                totallen -= sizeof(*entry) +
1528                                xfs_attr_leaf_newentsize(
1529                                                state->args->namelen,
1530                                                state->args->valuelen,
1531                                                state->blocksize, NULL);
1532        }
1533
1534        *countarg = count;
1535        *usedbytesarg = totallen;
1536        return(foundit);
1537}
1538
1539/*========================================================================
1540 * Routines used for shrinking the Btree.
1541 *========================================================================*/
1542
1543/*
1544 * Check a leaf block and its neighbors to see if the block should be
1545 * collapsed into one or the other neighbor.  Always keep the block
1546 * with the smaller block number.
1547 * If the current block is over 50% full, don't try to join it, return 0.
1548 * If the block is empty, fill in the state structure and return 2.
1549 * If it can be collapsed, fill in the state structure and return 1.
1550 * If nothing can be done, return 0.
1551 *
1552 * GROT: allow for INCOMPLETE entries in calculation.
1553 */
1554int
1555xfs_attr_leaf_toosmall(xfs_da_state_t *state, int *action)
1556{
1557        xfs_attr_leafblock_t *leaf;
1558        xfs_da_state_blk_t *blk;
1559        xfs_da_blkinfo_t *info;
1560        int count, bytes, forward, error, retval, i;
1561        xfs_dablk_t blkno;
1562        struct xfs_buf *bp;
1563
1564        /*
1565         * Check for the degenerate case of the block being over 50% full.
1566         * If so, it's not worth even looking to see if we might be able
1567         * to coalesce with a sibling.
1568         */
1569        blk = &state->path.blk[ state->path.active-1 ];
1570        info = blk->bp->b_addr;
1571        ASSERT(info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1572        leaf = (xfs_attr_leafblock_t *)info;
1573        count = be16_to_cpu(leaf->hdr.count);
1574        bytes = sizeof(xfs_attr_leaf_hdr_t) +
1575                count * sizeof(xfs_attr_leaf_entry_t) +
1576                be16_to_cpu(leaf->hdr.usedbytes);
1577        if (bytes > (state->blocksize >> 1)) {
1578                *action = 0;    /* blk over 50%, don't try to join */
1579                return(0);
1580        }
1581
1582        /*
1583         * Check for the degenerate case of the block being empty.
1584         * If the block is empty, we'll simply delete it, no need to
1585         * coalesce it with a sibling block.  We choose (arbitrarily)
1586         * to merge with the forward block unless it is NULL.
1587         */
1588        if (count == 0) {
1589                /*
1590                 * Make altpath point to the block we want to keep and
1591                 * path point to the block we want to drop (this one).
1592                 */
1593                forward = (info->forw != 0);
1594                memcpy(&state->altpath, &state->path, sizeof(state->path));
1595                error = xfs_da_path_shift(state, &state->altpath, forward,
1596                                                 0, &retval);
1597                if (error)
1598                        return(error);
1599                if (retval) {
1600                        *action = 0;
1601                } else {
1602                        *action = 2;
1603                }
1604                return(0);
1605        }
1606
1607        /*
1608         * Examine each sibling block to see if we can coalesce with
1609         * at least 25% free space to spare.  We need to figure out
1610         * whether to merge with the forward or the backward block.
1611         * We prefer coalescing with the lower numbered sibling so as
1612         * to shrink an attribute list over time.
1613         */
1614        /* start with smaller blk num */
1615        forward = (be32_to_cpu(info->forw) < be32_to_cpu(info->back));
1616        for (i = 0; i < 2; forward = !forward, i++) {
1617                if (forward)
1618                        blkno = be32_to_cpu(info->forw);
1619                else
1620                        blkno = be32_to_cpu(info->back);
1621                if (blkno == 0)
1622                        continue;
1623                error = xfs_da_read_buf(state->args->trans, state->args->dp,
1624                                        blkno, -1, &bp, XFS_ATTR_FORK);
1625                if (error)
1626                        return(error);
1627                ASSERT(bp != NULL);
1628
1629                leaf = (xfs_attr_leafblock_t *)info;
1630                count  = be16_to_cpu(leaf->hdr.count);
1631                bytes  = state->blocksize - (state->blocksize>>2);
1632                bytes -= be16_to_cpu(leaf->hdr.usedbytes);
1633                leaf = bp->b_addr;
1634                ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1635                count += be16_to_cpu(leaf->hdr.count);
1636                bytes -= be16_to_cpu(leaf->hdr.usedbytes);
1637                bytes -= count * sizeof(xfs_attr_leaf_entry_t);
1638                bytes -= sizeof(xfs_attr_leaf_hdr_t);
1639                xfs_trans_brelse(state->args->trans, bp);
1640                if (bytes >= 0)
1641                        break;  /* fits with at least 25% to spare */
1642        }
1643        if (i >= 2) {
1644                *action = 0;
1645                return(0);
1646        }
1647
1648        /*
1649         * Make altpath point to the block we want to keep (the lower
1650         * numbered block) and path point to the block we want to drop.
1651         */
1652        memcpy(&state->altpath, &state->path, sizeof(state->path));
1653        if (blkno < blk->blkno) {
1654                error = xfs_da_path_shift(state, &state->altpath, forward,
1655                                                 0, &retval);
1656        } else {
1657                error = xfs_da_path_shift(state, &state->path, forward,
1658                                                 0, &retval);
1659        }
1660        if (error)
1661                return(error);
1662        if (retval) {
1663                *action = 0;
1664        } else {
1665                *action = 1;
1666        }
1667        return(0);
1668}
1669
1670/*
1671 * Remove a name from the leaf attribute list structure.
1672 *
1673 * Return 1 if leaf is less than 37% full, 0 if >= 37% full.
1674 * If two leaves are 37% full, when combined they will leave 25% free.
1675 */
1676int
1677xfs_attr_leaf_remove(
1678        struct xfs_buf  *bp,
1679        xfs_da_args_t   *args)
1680{
1681        xfs_attr_leafblock_t *leaf;
1682        xfs_attr_leaf_hdr_t *hdr;
1683        xfs_attr_leaf_map_t *map;
1684        xfs_attr_leaf_entry_t *entry;
1685        int before, after, smallest, entsize;
1686        int tablesize, tmp, i;
1687        xfs_mount_t *mp;
1688
1689        leaf = bp->b_addr;
1690        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1691        hdr = &leaf->hdr;
1692        mp = args->trans->t_mountp;
1693        ASSERT((be16_to_cpu(hdr->count) > 0)
1694                && (be16_to_cpu(hdr->count) < (XFS_LBSIZE(mp)/8)));
1695        ASSERT((args->index >= 0)
1696                && (args->index < be16_to_cpu(hdr->count)));
1697        ASSERT(be16_to_cpu(hdr->firstused) >=
1698               ((be16_to_cpu(hdr->count) * sizeof(*entry)) + sizeof(*hdr)));
1699        entry = &leaf->entries[args->index];
1700        ASSERT(be16_to_cpu(entry->nameidx) >= be16_to_cpu(hdr->firstused));
1701        ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
1702
1703        /*
1704         * Scan through free region table:
1705         *    check for adjacency of free'd entry with an existing one,
1706         *    find smallest free region in case we need to replace it,
1707         *    adjust any map that borders the entry table,
1708         */
1709        tablesize = be16_to_cpu(hdr->count) * sizeof(xfs_attr_leaf_entry_t)
1710                                        + sizeof(xfs_attr_leaf_hdr_t);
1711        map = &hdr->freemap[0];
1712        tmp = be16_to_cpu(map->size);
1713        before = after = -1;
1714        smallest = XFS_ATTR_LEAF_MAPSIZE - 1;
1715        entsize = xfs_attr_leaf_entsize(leaf, args->index);
1716        for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; map++, i++) {
1717                ASSERT(be16_to_cpu(map->base) < XFS_LBSIZE(mp));
1718                ASSERT(be16_to_cpu(map->size) < XFS_LBSIZE(mp));
1719                if (be16_to_cpu(map->base) == tablesize) {
1720                        be16_add_cpu(&map->base,
1721                                 -((int)sizeof(xfs_attr_leaf_entry_t)));
1722                        be16_add_cpu(&map->size, sizeof(xfs_attr_leaf_entry_t));
1723                }
1724
1725                if ((be16_to_cpu(map->base) + be16_to_cpu(map->size))
1726                                == be16_to_cpu(entry->nameidx)) {
1727                        before = i;
1728                } else if (be16_to_cpu(map->base)
1729                        == (be16_to_cpu(entry->nameidx) + entsize)) {
1730                        after = i;
1731                } else if (be16_to_cpu(map->size) < tmp) {
1732                        tmp = be16_to_cpu(map->size);
1733                        smallest = i;
1734                }
1735        }
1736
1737        /*
1738         * Coalesce adjacent freemap regions,
1739         * or replace the smallest region.
1740         */
1741        if ((before >= 0) || (after >= 0)) {
1742                if ((before >= 0) && (after >= 0)) {
1743                        map = &hdr->freemap[before];
1744                        be16_add_cpu(&map->size, entsize);
1745                        be16_add_cpu(&map->size,
1746                                 be16_to_cpu(hdr->freemap[after].size));
1747                        hdr->freemap[after].base = 0;
1748                        hdr->freemap[after].size = 0;
1749                } else if (before >= 0) {
1750                        map = &hdr->freemap[before];
1751                        be16_add_cpu(&map->size, entsize);
1752                } else {
1753                        map = &hdr->freemap[after];
1754                        /* both on-disk, don't endian flip twice */
1755                        map->base = entry->nameidx;
1756                        be16_add_cpu(&map->size, entsize);
1757                }
1758        } else {
1759                /*
1760                 * Replace smallest region (if it is smaller than free'd entry)
1761                 */
1762                map = &hdr->freemap[smallest];
1763                if (be16_to_cpu(map->size) < entsize) {
1764                        map->base = cpu_to_be16(be16_to_cpu(entry->nameidx));
1765                        map->size = cpu_to_be16(entsize);
1766                }
1767        }
1768
1769        /*
1770         * Did we remove the first entry?
1771         */
1772        if (be16_to_cpu(entry->nameidx) == be16_to_cpu(hdr->firstused))
1773                smallest = 1;
1774        else
1775                smallest = 0;
1776
1777        /*
1778         * Compress the remaining entries and zero out the removed stuff.
1779         */
1780        memset(xfs_attr_leaf_name(leaf, args->index), 0, entsize);
1781        be16_add_cpu(&hdr->usedbytes, -entsize);
1782        xfs_trans_log_buf(args->trans, bp,
1783             XFS_DA_LOGRANGE(leaf, xfs_attr_leaf_name(leaf, args->index),
1784                                   entsize));
1785
1786        tmp = (be16_to_cpu(hdr->count) - args->index)
1787                                        * sizeof(xfs_attr_leaf_entry_t);
1788        memmove((char *)entry, (char *)(entry+1), tmp);
1789        be16_add_cpu(&hdr->count, -1);
1790        xfs_trans_log_buf(args->trans, bp,
1791            XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
1792        entry = &leaf->entries[be16_to_cpu(hdr->count)];
1793        memset((char *)entry, 0, sizeof(xfs_attr_leaf_entry_t));
1794
1795        /*
1796         * If we removed the first entry, re-find the first used byte
1797         * in the name area.  Note that if the entry was the "firstused",
1798         * then we don't have a "hole" in our block resulting from
1799         * removing the name.
1800         */
1801        if (smallest) {
1802                tmp = XFS_LBSIZE(mp);
1803                entry = &leaf->entries[0];
1804                for (i = be16_to_cpu(hdr->count)-1; i >= 0; entry++, i--) {
1805                        ASSERT(be16_to_cpu(entry->nameidx) >=
1806                               be16_to_cpu(hdr->firstused));
1807                        ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
1808
1809                        if (be16_to_cpu(entry->nameidx) < tmp)
1810                                tmp = be16_to_cpu(entry->nameidx);
1811                }
1812                hdr->firstused = cpu_to_be16(tmp);
1813                if (!hdr->firstused) {
1814                        hdr->firstused = cpu_to_be16(
1815                                        tmp - XFS_ATTR_LEAF_NAME_ALIGN);
1816                }
1817        } else {
1818                hdr->holes = 1;         /* mark as needing compaction */
1819        }
1820        xfs_trans_log_buf(args->trans, bp,
1821                          XFS_DA_LOGRANGE(leaf, hdr, sizeof(*hdr)));
1822
1823        /*
1824         * Check if leaf is less than 50% full, caller may want to
1825         * "join" the leaf with a sibling if so.
1826         */
1827        tmp  = sizeof(xfs_attr_leaf_hdr_t);
1828        tmp += be16_to_cpu(leaf->hdr.count) * sizeof(xfs_attr_leaf_entry_t);
1829        tmp += be16_to_cpu(leaf->hdr.usedbytes);
1830        return(tmp < mp->m_attr_magicpct); /* leaf is < 37% full */
1831}
1832
1833/*
1834 * Move all the attribute list entries from drop_leaf into save_leaf.
1835 */
1836void
1837xfs_attr_leaf_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
1838                                       xfs_da_state_blk_t *save_blk)
1839{
1840        xfs_attr_leafblock_t *drop_leaf, *save_leaf, *tmp_leaf;
1841        xfs_attr_leaf_hdr_t *drop_hdr, *save_hdr, *tmp_hdr;
1842        xfs_mount_t *mp;
1843        char *tmpbuffer;
1844
1845        trace_xfs_attr_leaf_unbalance(state->args);
1846
1847        /*
1848         * Set up environment.
1849         */
1850        mp = state->mp;
1851        ASSERT(drop_blk->magic == XFS_ATTR_LEAF_MAGIC);
1852        ASSERT(save_blk->magic == XFS_ATTR_LEAF_MAGIC);
1853        drop_leaf = drop_blk->bp->b_addr;
1854        save_leaf = save_blk->bp->b_addr;
1855        ASSERT(drop_leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1856        ASSERT(save_leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1857        drop_hdr = &drop_leaf->hdr;
1858        save_hdr = &save_leaf->hdr;
1859
1860        /*
1861         * Save last hashval from dying block for later Btree fixup.
1862         */
1863        drop_blk->hashval = be32_to_cpu(
1864                drop_leaf->entries[be16_to_cpu(drop_leaf->hdr.count)-1].hashval);
1865
1866        /*
1867         * Check if we need a temp buffer, or can we do it in place.
1868         * Note that we don't check "leaf" for holes because we will
1869         * always be dropping it, toosmall() decided that for us already.
1870         */
1871        if (save_hdr->holes == 0) {
1872                /*
1873                 * dest leaf has no holes, so we add there.  May need
1874                 * to make some room in the entry array.
1875                 */
1876                if (xfs_attr_leaf_order(save_blk->bp, drop_blk->bp)) {
1877                        xfs_attr_leaf_moveents(drop_leaf, 0, save_leaf, 0,
1878                             be16_to_cpu(drop_hdr->count), mp);
1879                } else {
1880                        xfs_attr_leaf_moveents(drop_leaf, 0, save_leaf,
1881                                  be16_to_cpu(save_hdr->count),
1882                                  be16_to_cpu(drop_hdr->count), mp);
1883                }
1884        } else {
1885                /*
1886                 * Destination has holes, so we make a temporary copy
1887                 * of the leaf and add them both to that.
1888                 */
1889                tmpbuffer = kmem_alloc(state->blocksize, KM_SLEEP);
1890                ASSERT(tmpbuffer != NULL);
1891                memset(tmpbuffer, 0, state->blocksize);
1892                tmp_leaf = (xfs_attr_leafblock_t *)tmpbuffer;
1893                tmp_hdr = &tmp_leaf->hdr;
1894                tmp_hdr->info = save_hdr->info; /* struct copy */
1895                tmp_hdr->count = 0;
1896                tmp_hdr->firstused = cpu_to_be16(state->blocksize);
1897                if (!tmp_hdr->firstused) {
1898                        tmp_hdr->firstused = cpu_to_be16(
1899                                state->blocksize - XFS_ATTR_LEAF_NAME_ALIGN);
1900                }
1901                tmp_hdr->usedbytes = 0;
1902                if (xfs_attr_leaf_order(save_blk->bp, drop_blk->bp)) {
1903                        xfs_attr_leaf_moveents(drop_leaf, 0, tmp_leaf, 0,
1904                                be16_to_cpu(drop_hdr->count), mp);
1905                        xfs_attr_leaf_moveents(save_leaf, 0, tmp_leaf,
1906                                  be16_to_cpu(tmp_leaf->hdr.count),
1907                                  be16_to_cpu(save_hdr->count), mp);
1908                } else {
1909                        xfs_attr_leaf_moveents(save_leaf, 0, tmp_leaf, 0,
1910                                be16_to_cpu(save_hdr->count), mp);
1911                        xfs_attr_leaf_moveents(drop_leaf, 0, tmp_leaf,
1912                                be16_to_cpu(tmp_leaf->hdr.count),
1913                                be16_to_cpu(drop_hdr->count), mp);
1914                }
1915                memcpy((char *)save_leaf, (char *)tmp_leaf, state->blocksize);
1916                kmem_free(tmpbuffer);
1917        }
1918
1919        xfs_trans_log_buf(state->args->trans, save_blk->bp, 0,
1920                                           state->blocksize - 1);
1921
1922        /*
1923         * Copy out last hashval in each block for B-tree code.
1924         */
1925        save_blk->hashval = be32_to_cpu(
1926                save_leaf->entries[be16_to_cpu(save_leaf->hdr.count)-1].hashval);
1927}
1928
1929/*========================================================================
1930 * Routines used for finding things in the Btree.
1931 *========================================================================*/
1932
1933/*
1934 * Look up a name in a leaf attribute list structure.
1935 * This is the internal routine, it uses the caller's buffer.
1936 *
1937 * Note that duplicate keys are allowed, but only check within the
1938 * current leaf node.  The Btree code must check in adjacent leaf nodes.
1939 *
1940 * Return in args->index the index into the entry[] array of either
1941 * the found entry, or where the entry should have been (insert before
1942 * that entry).
1943 *
1944 * Don't change the args->value unless we find the attribute.
1945 */
1946int
1947xfs_attr_leaf_lookup_int(
1948        struct xfs_buf  *bp,
1949        xfs_da_args_t   *args)
1950{
1951        xfs_attr_leafblock_t *leaf;
1952        xfs_attr_leaf_entry_t *entry;
1953        xfs_attr_leaf_name_local_t *name_loc;
1954        xfs_attr_leaf_name_remote_t *name_rmt;
1955        int probe, span;
1956        xfs_dahash_t hashval;
1957
1958        trace_xfs_attr_leaf_lookup(args);
1959
1960        leaf = bp->b_addr;
1961        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
1962        ASSERT(be16_to_cpu(leaf->hdr.count)
1963                                        < (XFS_LBSIZE(args->dp->i_mount)/8));
1964
1965        /*
1966         * Binary search.  (note: small blocks will skip this loop)
1967         */
1968        hashval = args->hashval;
1969        probe = span = be16_to_cpu(leaf->hdr.count) / 2;
1970        for (entry = &leaf->entries[probe]; span > 4;
1971                   entry = &leaf->entries[probe]) {
1972                span /= 2;
1973                if (be32_to_cpu(entry->hashval) < hashval)
1974                        probe += span;
1975                else if (be32_to_cpu(entry->hashval) > hashval)
1976                        probe -= span;
1977                else
1978                        break;
1979        }
1980        ASSERT((probe >= 0) &&
1981               (!leaf->hdr.count
1982               || (probe < be16_to_cpu(leaf->hdr.count))));
1983        ASSERT((span <= 4) || (be32_to_cpu(entry->hashval) == hashval));
1984
1985        /*
1986         * Since we may have duplicate hashval's, find the first matching
1987         * hashval in the leaf.
1988         */
1989        while ((probe > 0) && (be32_to_cpu(entry->hashval) >= hashval)) {
1990                entry--;
1991                probe--;
1992        }
1993        while ((probe < be16_to_cpu(leaf->hdr.count)) &&
1994               (be32_to_cpu(entry->hashval) < hashval)) {
1995                entry++;
1996                probe++;
1997        }
1998        if ((probe == be16_to_cpu(leaf->hdr.count)) ||
1999            (be32_to_cpu(entry->hashval) != hashval)) {
2000                args->index = probe;
2001                return(XFS_ERROR(ENOATTR));
2002        }
2003
2004        /*
2005         * Duplicate keys may be present, so search all of them for a match.
2006         */
2007        for (  ; (probe < be16_to_cpu(leaf->hdr.count)) &&
2008                        (be32_to_cpu(entry->hashval) == hashval);
2009                        entry++, probe++) {
2010/*
2011 * GROT: Add code to remove incomplete entries.
2012 */
2013                /*
2014                 * If we are looking for INCOMPLETE entries, show only those.
2015                 * If we are looking for complete entries, show only those.
2016                 */
2017                if ((args->flags & XFS_ATTR_INCOMPLETE) !=
2018                    (entry->flags & XFS_ATTR_INCOMPLETE)) {
2019                        continue;
2020                }
2021                if (entry->flags & XFS_ATTR_LOCAL) {
2022                        name_loc = xfs_attr_leaf_name_local(leaf, probe);
2023                        if (name_loc->namelen != args->namelen)
2024                                continue;
2025                        if (memcmp(args->name, (char *)name_loc->nameval, args->namelen) != 0)
2026                                continue;
2027                        if (!xfs_attr_namesp_match(args->flags, entry->flags))
2028                                continue;
2029                        args->index = probe;
2030                        return(XFS_ERROR(EEXIST));
2031                } else {
2032                        name_rmt = xfs_attr_leaf_name_remote(leaf, probe);
2033                        if (name_rmt->namelen != args->namelen)
2034                                continue;
2035                        if (memcmp(args->name, (char *)name_rmt->name,
2036                                             args->namelen) != 0)
2037                                continue;
2038                        if (!xfs_attr_namesp_match(args->flags, entry->flags))
2039                                continue;
2040                        args->index = probe;
2041                        args->rmtblkno = be32_to_cpu(name_rmt->valueblk);
2042                        args->rmtblkcnt = XFS_B_TO_FSB(args->dp->i_mount,
2043                                                   be32_to_cpu(name_rmt->valuelen));
2044                        return(XFS_ERROR(EEXIST));
2045                }
2046        }
2047        args->index = probe;
2048        return(XFS_ERROR(ENOATTR));
2049}
2050
2051/*
2052 * Get the value associated with an attribute name from a leaf attribute
2053 * list structure.
2054 */
2055int
2056xfs_attr_leaf_getvalue(
2057        struct xfs_buf  *bp,
2058        xfs_da_args_t   *args)
2059{
2060        int valuelen;
2061        xfs_attr_leafblock_t *leaf;
2062        xfs_attr_leaf_entry_t *entry;
2063        xfs_attr_leaf_name_local_t *name_loc;
2064        xfs_attr_leaf_name_remote_t *name_rmt;
2065
2066        leaf = bp->b_addr;
2067        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2068        ASSERT(be16_to_cpu(leaf->hdr.count)
2069                                        < (XFS_LBSIZE(args->dp->i_mount)/8));
2070        ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
2071
2072        entry = &leaf->entries[args->index];
2073        if (entry->flags & XFS_ATTR_LOCAL) {
2074                name_loc = xfs_attr_leaf_name_local(leaf, args->index);
2075                ASSERT(name_loc->namelen == args->namelen);
2076                ASSERT(memcmp(args->name, name_loc->nameval, args->namelen) == 0);
2077                valuelen = be16_to_cpu(name_loc->valuelen);
2078                if (args->flags & ATTR_KERNOVAL) {
2079                        args->valuelen = valuelen;
2080                        return(0);
2081                }
2082                if (args->valuelen < valuelen) {
2083                        args->valuelen = valuelen;
2084                        return(XFS_ERROR(ERANGE));
2085                }
2086                args->valuelen = valuelen;
2087                memcpy(args->value, &name_loc->nameval[args->namelen], valuelen);
2088        } else {
2089                name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
2090                ASSERT(name_rmt->namelen == args->namelen);
2091                ASSERT(memcmp(args->name, name_rmt->name, args->namelen) == 0);
2092                valuelen = be32_to_cpu(name_rmt->valuelen);
2093                args->rmtblkno = be32_to_cpu(name_rmt->valueblk);
2094                args->rmtblkcnt = XFS_B_TO_FSB(args->dp->i_mount, valuelen);
2095                if (args->flags & ATTR_KERNOVAL) {
2096                        args->valuelen = valuelen;
2097                        return(0);
2098                }
2099                if (args->valuelen < valuelen) {
2100                        args->valuelen = valuelen;
2101                        return(XFS_ERROR(ERANGE));
2102                }
2103                args->valuelen = valuelen;
2104        }
2105        return(0);
2106}
2107
2108/*========================================================================
2109 * Utility routines.
2110 *========================================================================*/
2111
2112/*
2113 * Move the indicated entries from one leaf to another.
2114 * NOTE: this routine modifies both source and destination leaves.
2115 */
2116/*ARGSUSED*/
2117STATIC void
2118xfs_attr_leaf_moveents(xfs_attr_leafblock_t *leaf_s, int start_s,
2119                        xfs_attr_leafblock_t *leaf_d, int start_d,
2120                        int count, xfs_mount_t *mp)
2121{
2122        xfs_attr_leaf_hdr_t *hdr_s, *hdr_d;
2123        xfs_attr_leaf_entry_t *entry_s, *entry_d;
2124        int desti, tmp, i;
2125
2126        /*
2127         * Check for nothing to do.
2128         */
2129        if (count == 0)
2130                return;
2131
2132        /*
2133         * Set up environment.
2134         */
2135        ASSERT(leaf_s->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2136        ASSERT(leaf_d->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2137        hdr_s = &leaf_s->hdr;
2138        hdr_d = &leaf_d->hdr;
2139        ASSERT((be16_to_cpu(hdr_s->count) > 0) &&
2140               (be16_to_cpu(hdr_s->count) < (XFS_LBSIZE(mp)/8)));
2141        ASSERT(be16_to_cpu(hdr_s->firstused) >=
2142                ((be16_to_cpu(hdr_s->count)
2143                                        * sizeof(*entry_s))+sizeof(*hdr_s)));
2144        ASSERT(be16_to_cpu(hdr_d->count) < (XFS_LBSIZE(mp)/8));
2145        ASSERT(be16_to_cpu(hdr_d->firstused) >=
2146                ((be16_to_cpu(hdr_d->count)
2147                                        * sizeof(*entry_d))+sizeof(*hdr_d)));
2148
2149        ASSERT(start_s < be16_to_cpu(hdr_s->count));
2150        ASSERT(start_d <= be16_to_cpu(hdr_d->count));
2151        ASSERT(count <= be16_to_cpu(hdr_s->count));
2152
2153        /*
2154         * Move the entries in the destination leaf up to make a hole?
2155         */
2156        if (start_d < be16_to_cpu(hdr_d->count)) {
2157                tmp  = be16_to_cpu(hdr_d->count) - start_d;
2158                tmp *= sizeof(xfs_attr_leaf_entry_t);
2159                entry_s = &leaf_d->entries[start_d];
2160                entry_d = &leaf_d->entries[start_d + count];
2161                memmove((char *)entry_d, (char *)entry_s, tmp);
2162        }
2163
2164        /*
2165         * Copy all entry's in the same (sorted) order,
2166         * but allocate attribute info packed and in sequence.
2167         */
2168        entry_s = &leaf_s->entries[start_s];
2169        entry_d = &leaf_d->entries[start_d];
2170        desti = start_d;
2171        for (i = 0; i < count; entry_s++, entry_d++, desti++, i++) {
2172                ASSERT(be16_to_cpu(entry_s->nameidx)
2173                                >= be16_to_cpu(hdr_s->firstused));
2174                tmp = xfs_attr_leaf_entsize(leaf_s, start_s + i);
2175#ifdef GROT
2176                /*
2177                 * Code to drop INCOMPLETE entries.  Difficult to use as we
2178                 * may also need to change the insertion index.  Code turned
2179                 * off for 6.2, should be revisited later.
2180                 */
2181                if (entry_s->flags & XFS_ATTR_INCOMPLETE) { /* skip partials? */
2182                        memset(xfs_attr_leaf_name(leaf_s, start_s + i), 0, tmp);
2183                        be16_add_cpu(&hdr_s->usedbytes, -tmp);
2184                        be16_add_cpu(&hdr_s->count, -1);
2185                        entry_d--;      /* to compensate for ++ in loop hdr */
2186                        desti--;
2187                        if ((start_s + i) < offset)
2188                                result++;       /* insertion index adjustment */
2189                } else {
2190#endif /* GROT */
2191                        be16_add_cpu(&hdr_d->firstused, -tmp);
2192                        /* both on-disk, don't endian flip twice */
2193                        entry_d->hashval = entry_s->hashval;
2194                        /* both on-disk, don't endian flip twice */
2195                        entry_d->nameidx = hdr_d->firstused;
2196                        entry_d->flags = entry_s->flags;
2197                        ASSERT(be16_to_cpu(entry_d->nameidx) + tmp
2198                                                        <= XFS_LBSIZE(mp));
2199                        memmove(xfs_attr_leaf_name(leaf_d, desti),
2200                                xfs_attr_leaf_name(leaf_s, start_s + i), tmp);
2201                        ASSERT(be16_to_cpu(entry_s->nameidx) + tmp
2202                                                        <= XFS_LBSIZE(mp));
2203                        memset(xfs_attr_leaf_name(leaf_s, start_s + i), 0, tmp);
2204                        be16_add_cpu(&hdr_s->usedbytes, -tmp);
2205                        be16_add_cpu(&hdr_d->usedbytes, tmp);
2206                        be16_add_cpu(&hdr_s->count, -1);
2207                        be16_add_cpu(&hdr_d->count, 1);
2208                        tmp = be16_to_cpu(hdr_d->count)
2209                                                * sizeof(xfs_attr_leaf_entry_t)
2210                                                + sizeof(xfs_attr_leaf_hdr_t);
2211                        ASSERT(be16_to_cpu(hdr_d->firstused) >= tmp);
2212#ifdef GROT
2213                }
2214#endif /* GROT */
2215        }
2216
2217        /*
2218         * Zero out the entries we just copied.
2219         */
2220        if (start_s == be16_to_cpu(hdr_s->count)) {
2221                tmp = count * sizeof(xfs_attr_leaf_entry_t);
2222                entry_s = &leaf_s->entries[start_s];
2223                ASSERT(((char *)entry_s + tmp) <=
2224                       ((char *)leaf_s + XFS_LBSIZE(mp)));
2225                memset((char *)entry_s, 0, tmp);
2226        } else {
2227                /*
2228                 * Move the remaining entries down to fill the hole,
2229                 * then zero the entries at the top.
2230                 */
2231                tmp  = be16_to_cpu(hdr_s->count) - count;
2232                tmp *= sizeof(xfs_attr_leaf_entry_t);
2233                entry_s = &leaf_s->entries[start_s + count];
2234                entry_d = &leaf_s->entries[start_s];
2235                memmove((char *)entry_d, (char *)entry_s, tmp);
2236
2237                tmp = count * sizeof(xfs_attr_leaf_entry_t);
2238                entry_s = &leaf_s->entries[be16_to_cpu(hdr_s->count)];
2239                ASSERT(((char *)entry_s + tmp) <=
2240                       ((char *)leaf_s + XFS_LBSIZE(mp)));
2241                memset((char *)entry_s, 0, tmp);
2242        }
2243
2244        /*
2245         * Fill in the freemap information
2246         */
2247        hdr_d->freemap[0].base = cpu_to_be16(sizeof(xfs_attr_leaf_hdr_t));
2248        be16_add_cpu(&hdr_d->freemap[0].base, be16_to_cpu(hdr_d->count) *
2249                        sizeof(xfs_attr_leaf_entry_t));
2250        hdr_d->freemap[0].size = cpu_to_be16(be16_to_cpu(hdr_d->firstused)
2251                              - be16_to_cpu(hdr_d->freemap[0].base));
2252        hdr_d->freemap[1].base = 0;
2253        hdr_d->freemap[2].base = 0;
2254        hdr_d->freemap[1].size = 0;
2255        hdr_d->freemap[2].size = 0;
2256        hdr_s->holes = 1;       /* leaf may not be compact */
2257}
2258
2259/*
2260 * Compare two leaf blocks "order".
2261 * Return 0 unless leaf2 should go before leaf1.
2262 */
2263int
2264xfs_attr_leaf_order(
2265        struct xfs_buf  *leaf1_bp,
2266        struct xfs_buf  *leaf2_bp)
2267{
2268        xfs_attr_leafblock_t *leaf1, *leaf2;
2269
2270        leaf1 = leaf1_bp->b_addr;
2271        leaf2 = leaf2_bp->b_addr;
2272        ASSERT((leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) &&
2273               (leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)));
2274        if ((be16_to_cpu(leaf1->hdr.count) > 0) &&
2275            (be16_to_cpu(leaf2->hdr.count) > 0) &&
2276            ((be32_to_cpu(leaf2->entries[0].hashval) <
2277              be32_to_cpu(leaf1->entries[0].hashval)) ||
2278             (be32_to_cpu(leaf2->entries[
2279                        be16_to_cpu(leaf2->hdr.count)-1].hashval) <
2280              be32_to_cpu(leaf1->entries[
2281                        be16_to_cpu(leaf1->hdr.count)-1].hashval)))) {
2282                return(1);
2283        }
2284        return(0);
2285}
2286
2287/*
2288 * Pick up the last hashvalue from a leaf block.
2289 */
2290xfs_dahash_t
2291xfs_attr_leaf_lasthash(
2292        struct xfs_buf  *bp,
2293        int             *count)
2294{
2295        xfs_attr_leafblock_t *leaf;
2296
2297        leaf = bp->b_addr;
2298        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2299        if (count)
2300                *count = be16_to_cpu(leaf->hdr.count);
2301        if (!leaf->hdr.count)
2302                return(0);
2303        return be32_to_cpu(leaf->entries[be16_to_cpu(leaf->hdr.count)-1].hashval);
2304}
2305
2306/*
2307 * Calculate the number of bytes used to store the indicated attribute
2308 * (whether local or remote only calculate bytes in this block).
2309 */
2310STATIC int
2311xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index)
2312{
2313        xfs_attr_leaf_name_local_t *name_loc;
2314        xfs_attr_leaf_name_remote_t *name_rmt;
2315        int size;
2316
2317        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2318        if (leaf->entries[index].flags & XFS_ATTR_LOCAL) {
2319                name_loc = xfs_attr_leaf_name_local(leaf, index);
2320                size = xfs_attr_leaf_entsize_local(name_loc->namelen,
2321                                                   be16_to_cpu(name_loc->valuelen));
2322        } else {
2323                name_rmt = xfs_attr_leaf_name_remote(leaf, index);
2324                size = xfs_attr_leaf_entsize_remote(name_rmt->namelen);
2325        }
2326        return(size);
2327}
2328
2329/*
2330 * Calculate the number of bytes that would be required to store the new
2331 * attribute (whether local or remote only calculate bytes in this block).
2332 * This routine decides as a side effect whether the attribute will be
2333 * a "local" or a "remote" attribute.
2334 */
2335int
2336xfs_attr_leaf_newentsize(int namelen, int valuelen, int blocksize, int *local)
2337{
2338        int size;
2339
2340        size = xfs_attr_leaf_entsize_local(namelen, valuelen);
2341        if (size < xfs_attr_leaf_entsize_local_max(blocksize)) {
2342                if (local) {
2343                        *local = 1;
2344                }
2345        } else {
2346                size = xfs_attr_leaf_entsize_remote(namelen);
2347                if (local) {
2348                        *local = 0;
2349                }
2350        }
2351        return(size);
2352}
2353
2354/*
2355 * Copy out attribute list entries for attr_list(), for leaf attribute lists.
2356 */
2357int
2358xfs_attr_leaf_list_int(
2359        struct xfs_buf          *bp,
2360        xfs_attr_list_context_t *context)
2361{
2362        attrlist_cursor_kern_t *cursor;
2363        xfs_attr_leafblock_t *leaf;
2364        xfs_attr_leaf_entry_t *entry;
2365        int retval, i;
2366
2367        ASSERT(bp != NULL);
2368        leaf = bp->b_addr;
2369        cursor = context->cursor;
2370        cursor->initted = 1;
2371
2372        trace_xfs_attr_list_leaf(context);
2373
2374        /*
2375         * Re-find our place in the leaf block if this is a new syscall.
2376         */
2377        if (context->resynch) {
2378                entry = &leaf->entries[0];
2379                for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
2380                        if (be32_to_cpu(entry->hashval) == cursor->hashval) {
2381                                if (cursor->offset == context->dupcnt) {
2382                                        context->dupcnt = 0;
2383                                        break;
2384                                }
2385                                context->dupcnt++;
2386                        } else if (be32_to_cpu(entry->hashval) >
2387                                        cursor->hashval) {
2388                                context->dupcnt = 0;
2389                                break;
2390                        }
2391                }
2392                if (i == be16_to_cpu(leaf->hdr.count)) {
2393                        trace_xfs_attr_list_notfound(context);
2394                        return(0);
2395                }
2396        } else {
2397                entry = &leaf->entries[0];
2398                i = 0;
2399        }
2400        context->resynch = 0;
2401
2402        /*
2403         * We have found our place, start copying out the new attributes.
2404         */
2405        retval = 0;
2406        for (  ; (i < be16_to_cpu(leaf->hdr.count)); entry++, i++) {
2407                if (be32_to_cpu(entry->hashval) != cursor->hashval) {
2408                        cursor->hashval = be32_to_cpu(entry->hashval);
2409                        cursor->offset = 0;
2410                }
2411
2412                if (entry->flags & XFS_ATTR_INCOMPLETE)
2413                        continue;               /* skip incomplete entries */
2414
2415                if (entry->flags & XFS_ATTR_LOCAL) {
2416                        xfs_attr_leaf_name_local_t *name_loc =
2417                                xfs_attr_leaf_name_local(leaf, i);
2418
2419                        retval = context->put_listent(context,
2420                                                entry->flags,
2421                                                name_loc->nameval,
2422                                                (int)name_loc->namelen,
2423                                                be16_to_cpu(name_loc->valuelen),
2424                                                &name_loc->nameval[name_loc->namelen]);
2425                        if (retval)
2426                                return retval;
2427                } else {
2428                        xfs_attr_leaf_name_remote_t *name_rmt =
2429                                xfs_attr_leaf_name_remote(leaf, i);
2430
2431                        int valuelen = be32_to_cpu(name_rmt->valuelen);
2432
2433                        if (context->put_value) {
2434                                xfs_da_args_t args;
2435
2436                                memset((char *)&args, 0, sizeof(args));
2437                                args.dp = context->dp;
2438                                args.whichfork = XFS_ATTR_FORK;
2439                                args.valuelen = valuelen;
2440                                args.value = kmem_alloc(valuelen, KM_SLEEP | KM_NOFS);
2441                                args.rmtblkno = be32_to_cpu(name_rmt->valueblk);
2442                                args.rmtblkcnt = XFS_B_TO_FSB(args.dp->i_mount, valuelen);
2443                                retval = xfs_attr_rmtval_get(&args);
2444                                if (retval)
2445                                        return retval;
2446                                retval = context->put_listent(context,
2447                                                entry->flags,
2448                                                name_rmt->name,
2449                                                (int)name_rmt->namelen,
2450                                                valuelen,
2451                                                args.value);
2452                                kmem_free(args.value);
2453                        } else {
2454                                retval = context->put_listent(context,
2455                                                entry->flags,
2456                                                name_rmt->name,
2457                                                (int)name_rmt->namelen,
2458                                                valuelen,
2459                                                NULL);
2460                        }
2461                        if (retval)
2462                                return retval;
2463                }
2464                if (context->seen_enough)
2465                        break;
2466                cursor->offset++;
2467        }
2468        trace_xfs_attr_list_leaf_end(context);
2469        return(retval);
2470}
2471
2472
2473/*========================================================================
2474 * Manage the INCOMPLETE flag in a leaf entry
2475 *========================================================================*/
2476
2477/*
2478 * Clear the INCOMPLETE flag on an entry in a leaf block.
2479 */
2480int
2481xfs_attr_leaf_clearflag(xfs_da_args_t *args)
2482{
2483        xfs_attr_leafblock_t *leaf;
2484        xfs_attr_leaf_entry_t *entry;
2485        xfs_attr_leaf_name_remote_t *name_rmt;
2486        struct xfs_buf *bp;
2487        int error;
2488#ifdef DEBUG
2489        xfs_attr_leaf_name_local_t *name_loc;
2490        int namelen;
2491        char *name;
2492#endif /* DEBUG */
2493
2494        trace_xfs_attr_leaf_clearflag(args);
2495        /*
2496         * Set up the operation.
2497         */
2498        error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp,
2499                                             XFS_ATTR_FORK);
2500        if (error) {
2501                return(error);
2502        }
2503        ASSERT(bp != NULL);
2504
2505        leaf = bp->b_addr;
2506        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2507        ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
2508        ASSERT(args->index >= 0);
2509        entry = &leaf->entries[ args->index ];
2510        ASSERT(entry->flags & XFS_ATTR_INCOMPLETE);
2511
2512#ifdef DEBUG
2513        if (entry->flags & XFS_ATTR_LOCAL) {
2514                name_loc = xfs_attr_leaf_name_local(leaf, args->index);
2515                namelen = name_loc->namelen;
2516                name = (char *)name_loc->nameval;
2517        } else {
2518                name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
2519                namelen = name_rmt->namelen;
2520                name = (char *)name_rmt->name;
2521        }
2522        ASSERT(be32_to_cpu(entry->hashval) == args->hashval);
2523        ASSERT(namelen == args->namelen);
2524        ASSERT(memcmp(name, args->name, namelen) == 0);
2525#endif /* DEBUG */
2526
2527        entry->flags &= ~XFS_ATTR_INCOMPLETE;
2528        xfs_trans_log_buf(args->trans, bp,
2529                         XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
2530
2531        if (args->rmtblkno) {
2532                ASSERT((entry->flags & XFS_ATTR_LOCAL) == 0);
2533                name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
2534                name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
2535                name_rmt->valuelen = cpu_to_be32(args->valuelen);
2536                xfs_trans_log_buf(args->trans, bp,
2537                         XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
2538        }
2539
2540        /*
2541         * Commit the flag value change and start the next trans in series.
2542         */
2543        return xfs_trans_roll(&args->trans, args->dp);
2544}
2545
2546/*
2547 * Set the INCOMPLETE flag on an entry in a leaf block.
2548 */
2549int
2550xfs_attr_leaf_setflag(xfs_da_args_t *args)
2551{
2552        xfs_attr_leafblock_t *leaf;
2553        xfs_attr_leaf_entry_t *entry;
2554        xfs_attr_leaf_name_remote_t *name_rmt;
2555        struct xfs_buf *bp;
2556        int error;
2557
2558        trace_xfs_attr_leaf_setflag(args);
2559
2560        /*
2561         * Set up the operation.
2562         */
2563        error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp,
2564                                             XFS_ATTR_FORK);
2565        if (error) {
2566                return(error);
2567        }
2568        ASSERT(bp != NULL);
2569
2570        leaf = bp->b_addr;
2571        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2572        ASSERT(args->index < be16_to_cpu(leaf->hdr.count));
2573        ASSERT(args->index >= 0);
2574        entry = &leaf->entries[ args->index ];
2575
2576        ASSERT((entry->flags & XFS_ATTR_INCOMPLETE) == 0);
2577        entry->flags |= XFS_ATTR_INCOMPLETE;
2578        xfs_trans_log_buf(args->trans, bp,
2579                        XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
2580        if ((entry->flags & XFS_ATTR_LOCAL) == 0) {
2581                name_rmt = xfs_attr_leaf_name_remote(leaf, args->index);
2582                name_rmt->valueblk = 0;
2583                name_rmt->valuelen = 0;
2584                xfs_trans_log_buf(args->trans, bp,
2585                         XFS_DA_LOGRANGE(leaf, name_rmt, sizeof(*name_rmt)));
2586        }
2587
2588        /*
2589         * Commit the flag value change and start the next trans in series.
2590         */
2591        return xfs_trans_roll(&args->trans, args->dp);
2592}
2593
2594/*
2595 * In a single transaction, clear the INCOMPLETE flag on the leaf entry
2596 * given by args->blkno/index and set the INCOMPLETE flag on the leaf
2597 * entry given by args->blkno2/index2.
2598 *
2599 * Note that they could be in different blocks, or in the same block.
2600 */
2601int
2602xfs_attr_leaf_flipflags(xfs_da_args_t *args)
2603{
2604        xfs_attr_leafblock_t *leaf1, *leaf2;
2605        xfs_attr_leaf_entry_t *entry1, *entry2;
2606        xfs_attr_leaf_name_remote_t *name_rmt;
2607        struct xfs_buf *bp1, *bp2;
2608        int error;
2609#ifdef DEBUG
2610        xfs_attr_leaf_name_local_t *name_loc;
2611        int namelen1, namelen2;
2612        char *name1, *name2;
2613#endif /* DEBUG */
2614
2615        trace_xfs_attr_leaf_flipflags(args);
2616
2617        /*
2618         * Read the block containing the "old" attr
2619         */
2620        error = xfs_da_read_buf(args->trans, args->dp, args->blkno, -1, &bp1,
2621                                             XFS_ATTR_FORK);
2622        if (error) {
2623                return(error);
2624        }
2625        ASSERT(bp1 != NULL);
2626
2627        /*
2628         * Read the block containing the "new" attr, if it is different
2629         */
2630        if (args->blkno2 != args->blkno) {
2631                error = xfs_da_read_buf(args->trans, args->dp, args->blkno2,
2632                                        -1, &bp2, XFS_ATTR_FORK);
2633                if (error) {
2634                        return(error);
2635                }
2636                ASSERT(bp2 != NULL);
2637        } else {
2638                bp2 = bp1;
2639        }
2640
2641        leaf1 = bp1->b_addr;
2642        ASSERT(leaf1->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2643        ASSERT(args->index < be16_to_cpu(leaf1->hdr.count));
2644        ASSERT(args->index >= 0);
2645        entry1 = &leaf1->entries[ args->index ];
2646
2647        leaf2 = bp2->b_addr;
2648        ASSERT(leaf2->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2649        ASSERT(args->index2 < be16_to_cpu(leaf2->hdr.count));
2650        ASSERT(args->index2 >= 0);
2651        entry2 = &leaf2->entries[ args->index2 ];
2652
2653#ifdef DEBUG
2654        if (entry1->flags & XFS_ATTR_LOCAL) {
2655                name_loc = xfs_attr_leaf_name_local(leaf1, args->index);
2656                namelen1 = name_loc->namelen;
2657                name1 = (char *)name_loc->nameval;
2658        } else {
2659                name_rmt = xfs_attr_leaf_name_remote(leaf1, args->index);
2660                namelen1 = name_rmt->namelen;
2661                name1 = (char *)name_rmt->name;
2662        }
2663        if (entry2->flags & XFS_ATTR_LOCAL) {
2664                name_loc = xfs_attr_leaf_name_local(leaf2, args->index2);
2665                namelen2 = name_loc->namelen;
2666                name2 = (char *)name_loc->nameval;
2667        } else {
2668                name_rmt = xfs_attr_leaf_name_remote(leaf2, args->index2);
2669                namelen2 = name_rmt->namelen;
2670                name2 = (char *)name_rmt->name;
2671        }
2672        ASSERT(be32_to_cpu(entry1->hashval) == be32_to_cpu(entry2->hashval));
2673        ASSERT(namelen1 == namelen2);
2674        ASSERT(memcmp(name1, name2, namelen1) == 0);
2675#endif /* DEBUG */
2676
2677        ASSERT(entry1->flags & XFS_ATTR_INCOMPLETE);
2678        ASSERT((entry2->flags & XFS_ATTR_INCOMPLETE) == 0);
2679
2680        entry1->flags &= ~XFS_ATTR_INCOMPLETE;
2681        xfs_trans_log_buf(args->trans, bp1,
2682                          XFS_DA_LOGRANGE(leaf1, entry1, sizeof(*entry1)));
2683        if (args->rmtblkno) {
2684                ASSERT((entry1->flags & XFS_ATTR_LOCAL) == 0);
2685                name_rmt = xfs_attr_leaf_name_remote(leaf1, args->index);
2686                name_rmt->valueblk = cpu_to_be32(args->rmtblkno);
2687                name_rmt->valuelen = cpu_to_be32(args->valuelen);
2688                xfs_trans_log_buf(args->trans, bp1,
2689                         XFS_DA_LOGRANGE(leaf1, name_rmt, sizeof(*name_rmt)));
2690        }
2691
2692        entry2->flags |= XFS_ATTR_INCOMPLETE;
2693        xfs_trans_log_buf(args->trans, bp2,
2694                          XFS_DA_LOGRANGE(leaf2, entry2, sizeof(*entry2)));
2695        if ((entry2->flags & XFS_ATTR_LOCAL) == 0) {
2696                name_rmt = xfs_attr_leaf_name_remote(leaf2, args->index2);
2697                name_rmt->valueblk = 0;
2698                name_rmt->valuelen = 0;
2699                xfs_trans_log_buf(args->trans, bp2,
2700                         XFS_DA_LOGRANGE(leaf2, name_rmt, sizeof(*name_rmt)));
2701        }
2702
2703        /*
2704         * Commit the flag value change and start the next trans in series.
2705         */
2706        error = xfs_trans_roll(&args->trans, args->dp);
2707
2708        return(error);
2709}
2710
2711/*========================================================================
2712 * Indiscriminately delete the entire attribute fork
2713 *========================================================================*/
2714
2715/*
2716 * Recurse (gasp!) through the attribute nodes until we find leaves.
2717 * We're doing a depth-first traversal in order to invalidate everything.
2718 */
2719int
2720xfs_attr_root_inactive(xfs_trans_t **trans, xfs_inode_t *dp)
2721{
2722        xfs_da_blkinfo_t *info;
2723        xfs_daddr_t blkno;
2724        struct xfs_buf *bp;
2725        int error;
2726
2727        /*
2728         * Read block 0 to see what we have to work with.
2729         * We only get here if we have extents, since we remove
2730         * the extents in reverse order the extent containing
2731         * block 0 must still be there.
2732         */
2733        error = xfs_da_read_buf(*trans, dp, 0, -1, &bp, XFS_ATTR_FORK);
2734        if (error)
2735                return(error);
2736        blkno = XFS_BUF_ADDR(bp);
2737
2738        /*
2739         * Invalidate the tree, even if the "tree" is only a single leaf block.
2740         * This is a depth-first traversal!
2741         */
2742        info = bp->b_addr;
2743        if (info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {
2744                error = xfs_attr_node_inactive(trans, dp, bp, 1);
2745        } else if (info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) {
2746                error = xfs_attr_leaf_inactive(trans, dp, bp);
2747        } else {
2748                error = XFS_ERROR(EIO);
2749                xfs_trans_brelse(*trans, bp);
2750        }
2751        if (error)
2752                return(error);
2753
2754        /*
2755         * Invalidate the incore copy of the root block.
2756         */
2757        error = xfs_da_get_buf(*trans, dp, 0, blkno, &bp, XFS_ATTR_FORK);
2758        if (error)
2759                return(error);
2760        xfs_trans_binval(*trans, bp);   /* remove from cache */
2761        /*
2762         * Commit the invalidate and start the next transaction.
2763         */
2764        error = xfs_trans_roll(trans, dp);
2765
2766        return (error);
2767}
2768
2769/*
2770 * Recurse (gasp!) through the attribute nodes until we find leaves.
2771 * We're doing a depth-first traversal in order to invalidate everything.
2772 */
2773STATIC int
2774xfs_attr_node_inactive(
2775        struct xfs_trans **trans,
2776        struct xfs_inode *dp,
2777        struct xfs_buf  *bp,
2778        int             level)
2779{
2780        xfs_da_blkinfo_t *info;
2781        xfs_da_intnode_t *node;
2782        xfs_dablk_t child_fsb;
2783        xfs_daddr_t parent_blkno, child_blkno;
2784        int error, count, i;
2785        struct xfs_buf *child_bp;
2786
2787        /*
2788         * Since this code is recursive (gasp!) we must protect ourselves.
2789         */
2790        if (level > XFS_DA_NODE_MAXDEPTH) {
2791                xfs_trans_brelse(*trans, bp);   /* no locks for later trans */
2792                return(XFS_ERROR(EIO));
2793        }
2794
2795        node = bp->b_addr;
2796        ASSERT(node->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
2797        parent_blkno = XFS_BUF_ADDR(bp);        /* save for re-read later */
2798        count = be16_to_cpu(node->hdr.count);
2799        if (!count) {
2800                xfs_trans_brelse(*trans, bp);
2801                return(0);
2802        }
2803        child_fsb = be32_to_cpu(node->btree[0].before);
2804        xfs_trans_brelse(*trans, bp);   /* no locks for later trans */
2805
2806        /*
2807         * If this is the node level just above the leaves, simply loop
2808         * over the leaves removing all of them.  If this is higher up
2809         * in the tree, recurse downward.
2810         */
2811        for (i = 0; i < count; i++) {
2812                /*
2813                 * Read the subsidiary block to see what we have to work with.
2814                 * Don't do this in a transaction.  This is a depth-first
2815                 * traversal of the tree so we may deal with many blocks
2816                 * before we come back to this one.
2817                 */
2818                error = xfs_da_read_buf(*trans, dp, child_fsb, -2, &child_bp,
2819                                                XFS_ATTR_FORK);
2820                if (error)
2821                        return(error);
2822                if (child_bp) {
2823                                                /* save for re-read later */
2824                        child_blkno = XFS_BUF_ADDR(child_bp);
2825
2826                        /*
2827                         * Invalidate the subtree, however we have to.
2828                         */
2829                        info = child_bp->b_addr;
2830                        if (info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC)) {
2831                                error = xfs_attr_node_inactive(trans, dp,
2832                                                child_bp, level+1);
2833                        } else if (info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC)) {
2834                                error = xfs_attr_leaf_inactive(trans, dp,
2835                                                child_bp);
2836                        } else {
2837                                error = XFS_ERROR(EIO);
2838                                xfs_trans_brelse(*trans, child_bp);
2839                        }
2840                        if (error)
2841                                return(error);
2842
2843                        /*
2844                         * Remove the subsidiary block from the cache
2845                         * and from the log.
2846                         */
2847                        error = xfs_da_get_buf(*trans, dp, 0, child_blkno,
2848                                &child_bp, XFS_ATTR_FORK);
2849                        if (error)
2850                                return(error);
2851                        xfs_trans_binval(*trans, child_bp);
2852                }
2853
2854                /*
2855                 * If we're not done, re-read the parent to get the next
2856                 * child block number.
2857                 */
2858                if ((i+1) < count) {
2859                        error = xfs_da_read_buf(*trans, dp, 0, parent_blkno,
2860                                &bp, XFS_ATTR_FORK);
2861                        if (error)
2862                                return(error);
2863                        child_fsb = be32_to_cpu(node->btree[i+1].before);
2864                        xfs_trans_brelse(*trans, bp);
2865                }
2866                /*
2867                 * Atomically commit the whole invalidate stuff.
2868                 */
2869                error = xfs_trans_roll(trans, dp);
2870                if (error)
2871                        return (error);
2872        }
2873
2874        return(0);
2875}
2876
2877/*
2878 * Invalidate all of the "remote" value regions pointed to by a particular
2879 * leaf block.
2880 * Note that we must release the lock on the buffer so that we are not
2881 * caught holding something that the logging code wants to flush to disk.
2882 */
2883STATIC int
2884xfs_attr_leaf_inactive(
2885        struct xfs_trans **trans,
2886        struct xfs_inode *dp,
2887        struct xfs_buf  *bp)
2888{
2889        xfs_attr_leafblock_t *leaf;
2890        xfs_attr_leaf_entry_t *entry;
2891        xfs_attr_leaf_name_remote_t *name_rmt;
2892        xfs_attr_inactive_list_t *list, *lp;
2893        int error, count, size, tmp, i;
2894
2895        leaf = bp->b_addr;
2896        ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC));
2897
2898        /*
2899         * Count the number of "remote" value extents.
2900         */
2901        count = 0;
2902        entry = &leaf->entries[0];
2903        for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
2904                if (be16_to_cpu(entry->nameidx) &&
2905                    ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
2906                        name_rmt = xfs_attr_leaf_name_remote(leaf, i);
2907                        if (name_rmt->valueblk)
2908                                count++;
2909                }
2910        }
2911
2912        /*
2913         * If there are no "remote" values, we're done.
2914         */
2915        if (count == 0) {
2916                xfs_trans_brelse(*trans, bp);
2917                return(0);
2918        }
2919
2920        /*
2921         * Allocate storage for a list of all the "remote" value extents.
2922         */
2923        size = count * sizeof(xfs_attr_inactive_list_t);
2924        list = (xfs_attr_inactive_list_t *)kmem_alloc(size, KM_SLEEP);
2925
2926        /*
2927         * Identify each of the "remote" value extents.
2928         */
2929        lp = list;
2930        entry = &leaf->entries[0];
2931        for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
2932                if (be16_to_cpu(entry->nameidx) &&
2933                    ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
2934                        name_rmt = xfs_attr_leaf_name_remote(leaf, i);
2935                        if (name_rmt->valueblk) {
2936                                lp->valueblk = be32_to_cpu(name_rmt->valueblk);
2937                                lp->valuelen = XFS_B_TO_FSB(dp->i_mount,
2938                                                    be32_to_cpu(name_rmt->valuelen));
2939                                lp++;
2940                        }
2941                }
2942        }
2943        xfs_trans_brelse(*trans, bp);   /* unlock for trans. in freextent() */
2944
2945        /*
2946         * Invalidate each of the "remote" value extents.
2947         */
2948        error = 0;
2949        for (lp = list, i = 0; i < count; i++, lp++) {
2950                tmp = xfs_attr_leaf_freextent(trans, dp,
2951                                lp->valueblk, lp->valuelen);
2952
2953                if (error == 0)
2954                        error = tmp;    /* save only the 1st errno */
2955        }
2956
2957        kmem_free((xfs_caddr_t)list);
2958        return(error);
2959}
2960
2961/*
2962 * Look at all the extents for this logical region,
2963 * invalidate any buffers that are incore/in transactions.
2964 */
2965STATIC int
2966xfs_attr_leaf_freextent(xfs_trans_t **trans, xfs_inode_t *dp,
2967                                    xfs_dablk_t blkno, int blkcnt)
2968{
2969        xfs_bmbt_irec_t map;
2970        xfs_dablk_t tblkno;
2971        int tblkcnt, dblkcnt, nmap, error;
2972        xfs_daddr_t dblkno;
2973        xfs_buf_t *bp;
2974
2975        /*
2976         * Roll through the "value", invalidating the attribute value's
2977         * blocks.
2978         */
2979        tblkno = blkno;
2980        tblkcnt = blkcnt;
2981        while (tblkcnt > 0) {
2982                /*
2983                 * Try to remember where we decided to put the value.
2984                 */
2985                nmap = 1;
2986                error = xfs_bmapi_read(dp, (xfs_fileoff_t)tblkno, tblkcnt,
2987                                       &map, &nmap, XFS_BMAPI_ATTRFORK);
2988                if (error) {
2989                        return(error);
2990                }
2991                ASSERT(nmap == 1);
2992                ASSERT(map.br_startblock != DELAYSTARTBLOCK);
2993
2994                /*
2995                 * If it's a hole, these are already unmapped
2996                 * so there's nothing to invalidate.
2997                 */
2998                if (map.br_startblock != HOLESTARTBLOCK) {
2999
3000                        dblkno = XFS_FSB_TO_DADDR(dp->i_mount,
3001                                                  map.br_startblock);
3002                        dblkcnt = XFS_FSB_TO_BB(dp->i_mount,
3003                                                map.br_blockcount);
3004                        bp = xfs_trans_get_buf(*trans,
3005                                        dp->i_mount->m_ddev_targp,
3006                                        dblkno, dblkcnt, 0);
3007                        if (!bp)
3008                                return ENOMEM;
3009                        xfs_trans_binval(*trans, bp);
3010                        /*
3011                         * Roll to next transaction.
3012                         */
3013                        error = xfs_trans_roll(trans, dp);
3014                        if (error)
3015                                return (error);
3016                }
3017
3018                tblkno += map.br_blockcount;
3019                tblkcnt -= map.br_blockcount;
3020        }
3021
3022        return(0);
3023}
3024
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.