fs/xfs/xfs_da_btree.c

   1 /*
   2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   3  * Copyright (c) 2013 Red Hat, Inc.
   4  * All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it would be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write the Free Software Foundation,
  17  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19 #include "xfs.h"
  20 #include "xfs_fs.h"
  21 #include "xfs_shared.h"
  22 #include "xfs_format.h"
  23 #include "xfs_log_format.h"
  24 #include "xfs_trans_resv.h"
  25 #include "xfs_bit.h"
  26 #include "xfs_sb.h"
  27 #include "xfs_ag.h"
  28 #include "xfs_mount.h"
  29 #include "xfs_da_format.h"
  30 #include "xfs_da_btree.h"
  31 #include "xfs_dir2.h"
  32 #include "xfs_dir2_priv.h"
  33 #include "xfs_inode.h"
  34 #include "xfs_trans.h"
  35 #include "xfs_inode_item.h"
  36 #include "xfs_alloc.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 #include "xfs_cksum.h"
  43 #include "xfs_buf_item.h"
  44
  45 /*
  46  * xfs_da_btree.c
  47  *
  48  * Routines to implement directories as Btrees of hashed names.
  49  */
  50
  51 /*========================================================================
  52  * Function prototypes for the kernel.
  53  *========================================================================*/
  54
  55 /*
  56  * Routines used for growing the Btree.
  57  */
  58 STATIC int xfs_da3_root_split(xfs_da_state_t *state,
  59                                             xfs_da_state_blk_t *existing_root,
  60                                             xfs_da_state_blk_t *new_child);
  61 STATIC int xfs_da3_node_split(xfs_da_state_t *state,
  62                                             xfs_da_state_blk_t *existing_blk,
  63                                             xfs_da_state_blk_t *split_blk,
  64                                             xfs_da_state_blk_t *blk_to_add,
  65                                             int treelevel,
  66                                             int *result);
  67 STATIC void xfs_da3_node_rebalance(xfs_da_state_t *state,
  68                                          xfs_da_state_blk_t *node_blk_1,
  69                                          xfs_da_state_blk_t *node_blk_2);
  70 STATIC void xfs_da3_node_add(xfs_da_state_t *state,
  71                                    xfs_da_state_blk_t *old_node_blk,
  72                                    xfs_da_state_blk_t *new_node_blk);
  73
  74 /*
  75  * Routines used for shrinking the Btree.
  76  */
  77 STATIC int xfs_da3_root_join(xfs_da_state_t *state,
  78                                            xfs_da_state_blk_t *root_blk);
  79 STATIC int xfs_da3_node_toosmall(xfs_da_state_t *state, int *retval);
  80 STATIC void xfs_da3_node_remove(xfs_da_state_t *state,
  81                                               xfs_da_state_blk_t *drop_blk);
  82 STATIC void xfs_da3_node_unbalance(xfs_da_state_t *state,
  83                                          xfs_da_state_blk_t *src_node_blk,
  84                                          xfs_da_state_blk_t *dst_node_blk);
  85
  86 /*
  87  * Utility routines.
  88  */
  89 STATIC int      xfs_da3_blk_unlink(xfs_da_state_t *state,
  90                                   xfs_da_state_blk_t *drop_blk,
  91                                   xfs_da_state_blk_t *save_blk);
  92
  93
  94 kmem_zone_t *xfs_da_state_zone; /* anchor for state struct zone */
  95
  96 /*
  97  * Allocate a dir-state structure.
  98  * We don't put them on the stack since they're large.
  99  */
 100 xfs_da_state_t *
 101 xfs_da_state_alloc(void)
 102 {
 103         return kmem_zone_zalloc(xfs_da_state_zone, KM_NOFS);
 104 }
 105
 106 /*
 107  * Kill the altpath contents of a da-state structure.
 108  */
 109 STATIC void
 110 xfs_da_state_kill_altpath(xfs_da_state_t *state)
 111 {
 112         int     i;
 113
 114         for (i = 0; i < state->altpath.active; i++)
 115                 state->altpath.blk[i].bp = NULL;
 116         state->altpath.active = 0;
 117 }
 118
 119 /*
 120  * Free a da-state structure.
 121  */
 122 void
 123 xfs_da_state_free(xfs_da_state_t *state)
 124 {
 125         xfs_da_state_kill_altpath(state);
 126 #ifdef DEBUG
 127         memset((char *)state, 0, sizeof(*state));
 128 #endif /* DEBUG */
 129         kmem_zone_free(xfs_da_state_zone, state);
 130 }
 131
 132 void
 133 xfs_da3_node_hdr_from_disk(
 134         struct xfs_da3_icnode_hdr       *to,
 135         struct xfs_da_intnode           *from)
 136 {
 137         ASSERT(from->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC) ||
 138                from->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC));
 139
 140         if (from->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC)) {
 141                 struct xfs_da3_node_hdr *hdr3 = (struct xfs_da3_node_hdr *)from;
 142
 143                 to->forw = be32_to_cpu(hdr3->info.hdr.forw);
 144                 to->back = be32_to_cpu(hdr3->info.hdr.back);
 145                 to->magic = be16_to_cpu(hdr3->info.hdr.magic);
 146                 to->count = be16_to_cpu(hdr3->__count);
 147                 to->level = be16_to_cpu(hdr3->__level);
 148                 return;
 149         }
 150         to->forw = be32_to_cpu(from->hdr.info.forw);
 151         to->back = be32_to_cpu(from->hdr.info.back);
 152         to->magic = be16_to_cpu(from->hdr.info.magic);
 153         to->count = be16_to_cpu(from->hdr.__count);
 154         to->level = be16_to_cpu(from->hdr.__level);
 155 }
 156
 157 void
 158 xfs_da3_node_hdr_to_disk(
 159         struct xfs_da_intnode           *to,
 160         struct xfs_da3_icnode_hdr       *from)
 161 {
 162         ASSERT(from->magic == XFS_DA_NODE_MAGIC ||
 163                from->magic == XFS_DA3_NODE_MAGIC);
 164
 165         if (from->magic == XFS_DA3_NODE_MAGIC) {
 166                 struct xfs_da3_node_hdr *hdr3 = (struct xfs_da3_node_hdr *)to;
 167
 168                 hdr3->info.hdr.forw = cpu_to_be32(from->forw);
 169                 hdr3->info.hdr.back = cpu_to_be32(from->back);
 170                 hdr3->info.hdr.magic = cpu_to_be16(from->magic);
 171                 hdr3->__count = cpu_to_be16(from->count);
 172                 hdr3->__level = cpu_to_be16(from->level);
 173                 return;
 174         }
 175         to->hdr.info.forw = cpu_to_be32(from->forw);
 176         to->hdr.info.back = cpu_to_be32(from->back);
 177         to->hdr.info.magic = cpu_to_be16(from->magic);
 178         to->hdr.__count = cpu_to_be16(from->count);
 179         to->hdr.__level = cpu_to_be16(from->level);
 180 }
 181
 182 static bool
 183 xfs_da3_node_verify(
 184         struct xfs_buf          *bp)
 185 {
 186         struct xfs_mount        *mp = bp->b_target->bt_mount;
 187         struct xfs_da_intnode   *hdr = bp->b_addr;
 188         struct xfs_da3_icnode_hdr ichdr;
 189
 190         xfs_da3_node_hdr_from_disk(&ichdr, hdr);
 191
 192         if (xfs_sb_version_hascrc(&mp->m_sb)) {
 193                 struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
 194
 195                 if (ichdr.magic != XFS_DA3_NODE_MAGIC)
 196                         return false;
 197
 198                 if (!uuid_equal(&hdr3->info.uuid, &mp->m_sb.sb_uuid))
 199                         return false;
 200                 if (be64_to_cpu(hdr3->info.blkno) != bp->b_bn)
 201                         return false;
 202         } else {
 203                 if (ichdr.magic != XFS_DA_NODE_MAGIC)
 204                         return false;
 205         }
 206         if (ichdr.level == 0)
 207                 return false;
 208         if (ichdr.level > XFS_DA_NODE_MAXDEPTH)
 209                 return false;
 210         if (ichdr.count == 0)
 211                 return false;
 212
 213         /*
 214          * we don't know if the node is for and attribute or directory tree,
 215          * so only fail if the count is outside both bounds
 216          */
 217         if (ichdr.count > mp->m_dir_node_ents &&
 218             ichdr.count > mp->m_attr_node_ents)
 219                 return false;
 220
 221         /* XXX: hash order check? */
 222
 223         return true;
 224 }
 225
 226 static void
 227 xfs_da3_node_write_verify(
 228         struct xfs_buf  *bp)
 229 {
 230         struct xfs_mount        *mp = bp->b_target->bt_mount;
 231         struct xfs_buf_log_item *bip = bp->b_fspriv;
 232         struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
 233
 234         if (!xfs_da3_node_verify(bp)) {
 235                 XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
 236                 xfs_buf_ioerror(bp, EFSCORRUPTED);
 237                 return;
 238         }
 239
 240         if (!xfs_sb_version_hascrc(&mp->m_sb))
 241                 return;
 242
 243         if (bip)
 244                 hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn);
 245
 246         xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_DA3_NODE_CRC_OFF);
 247 }
 248
 249 /*
 250  * leaf/node format detection on trees is sketchy, so a node read can be done on
 251  * leaf level blocks when detection identifies the tree as a node format tree
 252  * incorrectly. In this case, we need to swap the verifier to match the correct
 253  * format of the block being read.
 254  */
 255 static void
 256 xfs_da3_node_read_verify(
 257         struct xfs_buf          *bp)
 258 {
 259         struct xfs_mount        *mp = bp->b_target->bt_mount;
 260         struct xfs_da_blkinfo   *info = bp->b_addr;
 261
 262         switch (be16_to_cpu(info->magic)) {
 263                 case XFS_DA3_NODE_MAGIC:
 264                         if (!xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length),
 265                                               XFS_DA3_NODE_CRC_OFF))
 266                                 break;
 267                         /* fall through */
 268                 case XFS_DA_NODE_MAGIC:
 269                         if (!xfs_da3_node_verify(bp))
 270                                 break;
 271                         return;
 272                 case XFS_ATTR_LEAF_MAGIC:
 273                 case XFS_ATTR3_LEAF_MAGIC:
 274                         bp->b_ops = &xfs_attr3_leaf_buf_ops;
 275                         bp->b_ops->verify_read(bp);
 276                         return;
 277                 case XFS_DIR2_LEAFN_MAGIC:
 278                 case XFS_DIR3_LEAFN_MAGIC:
 279                         bp->b_ops = &xfs_dir3_leafn_buf_ops;
 280                         bp->b_ops->verify_read(bp);
 281                         return;
 282                 default:
 283                         break;
 284         }
 285
 286         /* corrupt block */
 287         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
 288         xfs_buf_ioerror(bp, EFSCORRUPTED);
 289 }
 290
 291 const struct xfs_buf_ops xfs_da3_node_buf_ops = {
 292         .verify_read = xfs_da3_node_read_verify,
 293         .verify_write = xfs_da3_node_write_verify,
 294 };
 295
 296 int
 297 xfs_da3_node_read(
 298         struct xfs_trans        *tp,
 299         struct xfs_inode        *dp,
 300         xfs_dablk_t             bno,
 301         xfs_daddr_t             mappedbno,
 302         struct xfs_buf          **bpp,
 303         int                     which_fork)
 304 {
 305         int                     err;
 306
 307         err = xfs_da_read_buf(tp, dp, bno, mappedbno, bpp,
 308                                         which_fork, &xfs_da3_node_buf_ops);
 309         if (!err && tp) {
 310                 struct xfs_da_blkinfo   *info = (*bpp)->b_addr;
 311                 int                     type;
 312
 313                 switch (be16_to_cpu(info->magic)) {
 314                 case XFS_DA_NODE_MAGIC:
 315                 case XFS_DA3_NODE_MAGIC:
 316                         type = XFS_BLFT_DA_NODE_BUF;
 317                         break;
 318                 case XFS_ATTR_LEAF_MAGIC:
 319                 case XFS_ATTR3_LEAF_MAGIC:
 320                         type = XFS_BLFT_ATTR_LEAF_BUF;
 321                         break;
 322                 case XFS_DIR2_LEAFN_MAGIC:
 323                 case XFS_DIR3_LEAFN_MAGIC:
 324                         type = XFS_BLFT_DIR_LEAFN_BUF;
 325                         break;
 326                 default:
 327                         type = 0;
 328                         ASSERT(0);
 329                         break;
 330                 }
 331                 xfs_trans_buf_set_type(tp, *bpp, type);
 332         }
 333         return err;
 334 }
 335
 336 /*========================================================================
 337  * Routines used for growing the Btree.
 338  *========================================================================*/
 339
 340 /*
 341  * Create the initial contents of an intermediate node.
 342  */
 343 int
 344 xfs_da3_node_create(
 345         struct xfs_da_args      *args,
 346         xfs_dablk_t             blkno,
 347         int                     level,
 348         struct xfs_buf          **bpp,
 349         int                     whichfork)
 350 {
 351         struct xfs_da_intnode   *node;
 352         struct xfs_trans        *tp = args->trans;
 353         struct xfs_mount        *mp = tp->t_mountp;
 354         struct xfs_da3_icnode_hdr ichdr = {0};
 355         struct xfs_buf          *bp;
 356         int                     error;
 357
 358         trace_xfs_da_node_create(args);
 359         ASSERT(level <= XFS_DA_NODE_MAXDEPTH);
 360
 361         error = xfs_da_get_buf(tp, args->dp, blkno, -1, &bp, whichfork);
 362         if (error)
 363                 return(error);
 364         bp->b_ops = &xfs_da3_node_buf_ops;
 365         xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DA_NODE_BUF);
 366         node = bp->b_addr;
 367
 368         if (xfs_sb_version_hascrc(&mp->m_sb)) {
 369                 struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
 370
 371                 ichdr.magic = XFS_DA3_NODE_MAGIC;
 372                 hdr3->info.blkno = cpu_to_be64(bp->b_bn);
 373                 hdr3->info.owner = cpu_to_be64(args->dp->i_ino);
 374                 uuid_copy(&hdr3->info.uuid, &mp->m_sb.sb_uuid);
 375         } else {
 376                 ichdr.magic = XFS_DA_NODE_MAGIC;
 377         }
 378         ichdr.level = level;
 379
 380         xfs_da3_node_hdr_to_disk(node, &ichdr);
 381         xfs_trans_log_buf(tp, bp,
 382                 XFS_DA_LOGRANGE(node, &node->hdr, xfs_da3_node_hdr_size(node)));
 383
 384         *bpp = bp;
 385         return(0);
 386 }
 387
 388 /*
 389  * Split a leaf node, rebalance, then possibly split
 390  * intermediate nodes, rebalance, etc.
 391  */
 392 int                                                     /* error */
 393 xfs_da3_split(
 394         struct xfs_da_state     *state)
 395 {
 396         struct xfs_da_state_blk *oldblk;
 397         struct xfs_da_state_blk *newblk;
 398         struct xfs_da_state_blk *addblk;
 399         struct xfs_da_intnode   *node;
 400         struct xfs_buf          *bp;
 401         int                     max;
 402         int                     action = 0;
 403         int                     error;
 404         int                     i;
 405
 406         trace_xfs_da_split(state->args);
 407
 408         /*
 409          * Walk back up the tree splitting/inserting/adjusting as necessary.
 410          * If we need to insert and there isn't room, split the node, then
 411          * decide which fragment to insert the new block from below into.
 412          * Note that we may split the root this way, but we need more fixup.
 413          */
 414         max = state->path.active - 1;
 415         ASSERT((max >= 0) && (max < XFS_DA_NODE_MAXDEPTH));
 416         ASSERT(state->path.blk[max].magic == XFS_ATTR_LEAF_MAGIC ||
 417                state->path.blk[max].magic == XFS_DIR2_LEAFN_MAGIC);
 418
 419         addblk = &state->path.blk[max];         /* initial dummy value */
 420         for (i = max; (i >= 0) && addblk; state->path.active--, i--) {
 421                 oldblk = &state->path.blk[i];
 422                 newblk = &state->altpath.blk[i];
 423
 424                 /*
 425                  * If a leaf node then
 426                  *     Allocate a new leaf node, then rebalance across them.
 427                  * else if an intermediate node then
 428                  *     We split on the last layer, must we split the node?
 429                  */
 430                 switch (oldblk->magic) {
 431                 case XFS_ATTR_LEAF_MAGIC:
 432                         error = xfs_attr3_leaf_split(state, oldblk, newblk);
 433                         if ((error != 0) && (error != ENOSPC)) {
 434                                 return(error);  /* GROT: attr is inconsistent */
 435                         }
 436                         if (!error) {
 437                                 addblk = newblk;
 438                                 break;
 439                         }
 440                         /*
 441                          * Entry wouldn't fit, split the leaf again.
 442                          */
 443                         state->extravalid = 1;
 444                         if (state->inleaf) {
 445                                 state->extraafter = 0;  /* before newblk */
 446                                 trace_xfs_attr_leaf_split_before(state->args);
 447                                 error = xfs_attr3_leaf_split(state, oldblk,
 448                                                             &state->extrablk);
 449                         } else {
 450                                 state->extraafter = 1;  /* after newblk */
 451                                 trace_xfs_attr_leaf_split_after(state->args);
 452                                 error = xfs_attr3_leaf_split(state, newblk,
 453                                                             &state->extrablk);
 454                         }
 455                         if (error)
 456                                 return(error);  /* GROT: attr inconsistent */
 457                         addblk = newblk;
 458                         break;
 459                 case XFS_DIR2_LEAFN_MAGIC:
 460                         error = xfs_dir2_leafn_split(state, oldblk, newblk);
 461                         if (error)
 462                                 return error;
 463                         addblk = newblk;
 464                         break;
 465                 case XFS_DA_NODE_MAGIC:
 466                         error = xfs_da3_node_split(state, oldblk, newblk, addblk,
 467                                                          max - i, &action);
 468                         addblk->bp = NULL;
 469                         if (error)
 470                                 return(error);  /* GROT: dir is inconsistent */
 471                         /*
 472                          * Record the newly split block for the next time thru?
 473                          */
 474                         if (action)
 475                                 addblk = newblk;
 476                         else
 477                                 addblk = NULL;
 478                         break;
 479                 }
 480
 481                 /*
 482                  * Update the btree to show the new hashval for this child.
 483                  */
 484                 xfs_da3_fixhashpath(state, &state->path);
 485         }
 486         if (!addblk)
 487                 return(0);
 488
 489         /*
 490          * Split the root node.
 491          */
 492         ASSERT(state->path.active == 0);
 493         oldblk = &state->path.blk[0];
 494         error = xfs_da3_root_split(state, oldblk, addblk);
 495         if (error) {
 496                 addblk->bp = NULL;
 497                 return(error);  /* GROT: dir is inconsistent */
 498         }
 499
 500         /*
 501          * Update pointers to the node which used to be block 0 and
 502          * just got bumped because of the addition of a new root node.
 503          * There might be three blocks involved if a double split occurred,
 504          * and the original block 0 could be at any position in the list.
 505          *
 506          * Note: the magic numbers and sibling pointers are in the same
 507          * physical place for both v2 and v3 headers (by design). Hence it
 508          * doesn't matter which version of the xfs_da_intnode structure we use
 509          * here as the result will be the same using either structure.
 510          */
 511         node = oldblk->bp->b_addr;
 512         if (node->hdr.info.forw) {
 513                 if (be32_to_cpu(node->hdr.info.forw) == addblk->blkno) {
 514                         bp = addblk->bp;
 515                 } else {
 516                         ASSERT(state->extravalid);
 517                         bp = state->extrablk.bp;
 518                 }
 519                 node = bp->b_addr;
 520                 node->hdr.info.back = cpu_to_be32(oldblk->blkno);
 521                 xfs_trans_log_buf(state->args->trans, bp,
 522                     XFS_DA_LOGRANGE(node, &node->hdr.info,
 523                     sizeof(node->hdr.info)));
 524         }
 525         node = oldblk->bp->b_addr;
 526         if (node->hdr.info.back) {
 527                 if (be32_to_cpu(node->hdr.info.back) == addblk->blkno) {
 528                         bp = addblk->bp;
 529                 } else {
 530                         ASSERT(state->extravalid);
 531                         bp = state->extrablk.bp;
 532                 }
 533                 node = bp->b_addr;
 534                 node->hdr.info.forw = cpu_to_be32(oldblk->blkno);
 535                 xfs_trans_log_buf(state->args->trans, bp,
 536                     XFS_DA_LOGRANGE(node, &node->hdr.info,
 537                     sizeof(node->hdr.info)));
 538         }
 539         addblk->bp = NULL;
 540         return(0);
 541 }
 542
 543 /*
 544  * Split the root.  We have to create a new root and point to the two
 545  * parts (the split old root) that we just created.  Copy block zero to
 546  * the EOF, extending the inode in process.
 547  */
 548 STATIC int                                              /* error */
 549 xfs_da3_root_split(
 550         struct xfs_da_state     *state,
 551         struct xfs_da_state_blk *blk1,
 552         struct xfs_da_state_blk *blk2)
 553 {
 554         struct xfs_da_intnode   *node;
 555         struct xfs_da_intnode   *oldroot;
 556         struct xfs_da_node_entry *btree;
 557         struct xfs_da3_icnode_hdr nodehdr;
 558         struct xfs_da_args      *args;
 559         struct xfs_buf          *bp;
 560         struct xfs_inode        *dp;
 561         struct xfs_trans        *tp;
 562         struct xfs_mount        *mp;
 563         struct xfs_dir2_leaf    *leaf;
 564         xfs_dablk_t             blkno;
 565         int                     level;
 566         int                     error;
 567         int                     size;
 568
 569         trace_xfs_da_root_split(state->args);
 570
 571         /*
 572          * Copy the existing (incorrect) block from the root node position
 573          * to a free space somewhere.
 574          */
 575         args = state->args;
 576         error = xfs_da_grow_inode(args, &blkno);
 577         if (error)
 578                 return error;
 579
 580         dp = args->dp;
 581         tp = args->trans;
 582         mp = state->mp;
 583         error = xfs_da_get_buf(tp, dp, blkno, -1, &bp, args->whichfork);
 584         if (error)
 585                 return error;
 586         node = bp->b_addr;
 587         oldroot = blk1->bp->b_addr;
 588         if (oldroot->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC) ||
 589             oldroot->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC)) {
 590                 struct xfs_da3_icnode_hdr nodehdr;
 591
 592                 xfs_da3_node_hdr_from_disk(&nodehdr, oldroot);
 593                 btree = xfs_da3_node_tree_p(oldroot);
 594                 size = (int)((char *)&btree[nodehdr.count] - (char *)oldroot);
 595                 level = nodehdr.level;
 596
 597                 /*
 598                  * we are about to copy oldroot to bp, so set up the type
 599                  * of bp while we know exactly what it will be.
 600                  */
 601                 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DA_NODE_BUF);
 602         } else {
 603                 struct xfs_dir3_icleaf_hdr leafhdr;
 604                 struct xfs_dir2_leaf_entry *ents;
 605
 606                 leaf = (xfs_dir2_leaf_t *)oldroot;
 607                 xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
 608                 ents = xfs_dir3_leaf_ents_p(leaf);
 609
 610                 ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC ||
 611                        leafhdr.magic == XFS_DIR3_LEAFN_MAGIC);
 612                 size = (int)((char *)&ents[leafhdr.count] - (char *)leaf);
 613                 level = 0;
 614
 615                 /*
 616                  * we are about to copy oldroot to bp, so set up the type
 617                  * of bp while we know exactly what it will be.
 618                  */
 619                 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_LEAFN_BUF);
 620         }
 621
 622         /*
 623          * we can copy most of the information in the node from one block to
 624          * another, but for CRC enabled headers we have to make sure that the
 625          * block specific identifiers are kept intact. We update the buffer
 626          * directly for this.
 627          */
 628         memcpy(node, oldroot, size);
 629         if (oldroot->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC) ||
 630             oldroot->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) {
 631                 struct xfs_da3_intnode *node3 = (struct xfs_da3_intnode *)node;
 632
 633                 node3->hdr.info.blkno = cpu_to_be64(bp->b_bn);
 634         }
 635         xfs_trans_log_buf(tp, bp, 0, size - 1);
 636
 637         bp->b_ops = blk1->bp->b_ops;
 638         xfs_trans_buf_copy_type(bp, blk1->bp);
 639         blk1->bp = bp;
 640         blk1->blkno = blkno;
 641
 642         /*
 643          * Set up the new root node.
 644          */
 645         error = xfs_da3_node_create(args,
 646                 (args->whichfork == XFS_DATA_FORK) ? mp->m_dirleafblk : 0,
 647                 level + 1, &bp, args->whichfork);
 648         if (error)
 649                 return error;
 650
 651         node = bp->b_addr;
 652         xfs_da3_node_hdr_from_disk(&nodehdr, node);
 653         btree = xfs_da3_node_tree_p(node);
 654         btree[0].hashval = cpu_to_be32(blk1->hashval);
 655         btree[0].before = cpu_to_be32(blk1->blkno);
 656         btree[1].hashval = cpu_to_be32(blk2->hashval);
 657         btree[1].before = cpu_to_be32(blk2->blkno);
 658         nodehdr.count = 2;
 659         xfs_da3_node_hdr_to_disk(node, &nodehdr);
 660
 661 #ifdef DEBUG
 662         if (oldroot->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
 663             oldroot->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) {
 664                 ASSERT(blk1->blkno >= mp->m_dirleafblk &&
 665                        blk1->blkno < mp->m_dirfreeblk);
 666                 ASSERT(blk2->blkno >= mp->m_dirleafblk &&
 667                        blk2->blkno < mp->m_dirfreeblk);
 668         }
 669 #endif
 670
 671         /* Header is already logged by xfs_da_node_create */
 672         xfs_trans_log_buf(tp, bp,
 673                 XFS_DA_LOGRANGE(node, btree, sizeof(xfs_da_node_entry_t) * 2));
 674
 675         return 0;
 676 }
 677
 678 /*
 679  * Split the node, rebalance, then add the new entry.
 680  */
 681 STATIC int                                              /* error */
 682 xfs_da3_node_split(
 683         struct xfs_da_state     *state,
 684         struct xfs_da_state_blk *oldblk,
 685         struct xfs_da_state_blk *newblk,
 686         struct xfs_da_state_blk *addblk,
 687         int                     treelevel,
 688         int                     *result)
 689 {
 690         struct xfs_da_intnode   *node;
 691         struct xfs_da3_icnode_hdr nodehdr;
 692         xfs_dablk_t             blkno;
 693         int                     newcount;
 694         int                     error;
 695         int                     useextra;
 696
 697         trace_xfs_da_node_split(state->args);
 698
 699         node = oldblk->bp->b_addr;
 700         xfs_da3_node_hdr_from_disk(&nodehdr, node);
 701
 702         /*
 703          * With V2 dirs the extra block is data or freespace.
 704          */
 705         useextra = state->extravalid && state->args->whichfork == XFS_ATTR_FORK;
 706         newcount = 1 + useextra;
 707         /*
 708          * Do we have to split the node?
 709          */
 710         if (nodehdr.count + newcount > state->node_ents) {
 711                 /*
 712                  * Allocate a new node, add to the doubly linked chain of
 713                  * nodes, then move some of our excess entries into it.
 714                  */
 715                 error = xfs_da_grow_inode(state->args, &blkno);
 716                 if (error)
 717                         return(error);  /* GROT: dir is inconsistent */
 718
 719                 error = xfs_da3_node_create(state->args, blkno, treelevel,
 720                                            &newblk->bp, state->args->whichfork);
 721                 if (error)
 722                         return(error);  /* GROT: dir is inconsistent */
 723                 newblk->blkno = blkno;
 724                 newblk->magic = XFS_DA_NODE_MAGIC;
 725                 xfs_da3_node_rebalance(state, oldblk, newblk);
 726                 error = xfs_da3_blk_link(state, oldblk, newblk);
 727                 if (error)
 728                         return(error);
 729                 *result = 1;
 730         } else {
 731                 *result = 0;
 732         }
 733
 734         /*
 735          * Insert the new entry(s) into the correct block
 736          * (updating last hashval in the process).
 737          *
 738          * xfs_da3_node_add() inserts BEFORE the given index,
 739          * and as a result of using node_lookup_int() we always
 740          * point to a valid entry (not after one), but a split
 741          * operation always results in a new block whose hashvals
 742          * FOLLOW the current block.
 743          *
 744          * If we had double-split op below us, then add the extra block too.
 745          */
 746         node = oldblk->bp->b_addr;
 747         xfs_da3_node_hdr_from_disk(&nodehdr, node);
 748         if (oldblk->index <= nodehdr.count) {
 749                 oldblk->index++;
 750                 xfs_da3_node_add(state, oldblk, addblk);
 751                 if (useextra) {
 752                         if (state->extraafter)
 753                                 oldblk->index++;
 754                         xfs_da3_node_add(state, oldblk, &state->extrablk);
 755                         state->extravalid = 0;
 756                 }
 757         } else {
 758                 newblk->index++;
 759                 xfs_da3_node_add(state, newblk, addblk);
 760                 if (useextra) {
 761                         if (state->extraafter)
 762                                 newblk->index++;
 763                         xfs_da3_node_add(state, newblk, &state->extrablk);
 764                         state->extravalid = 0;
 765                 }
 766         }
 767
 768         return(0);
 769 }
 770
 771 /*
 772  * Balance the btree elements between two intermediate nodes,
 773  * usually one full and one empty.
 774  *
 775  * NOTE: if blk2 is empty, then it will get the upper half of blk1.
 776  */
 777 STATIC void
 778 xfs_da3_node_rebalance(
 779         struct xfs_da_state     *state,
 780         struct xfs_da_state_blk *blk1,
 781         struct xfs_da_state_blk *blk2)
 782 {
 783         struct xfs_da_intnode   *node1;
 784         struct xfs_da_intnode   *node2;
 785         struct xfs_da_intnode   *tmpnode;
 786         struct xfs_da_node_entry *btree1;
 787         struct xfs_da_node_entry *btree2;
 788         struct xfs_da_node_entry *btree_s;
 789         struct xfs_da_node_entry *btree_d;
 790         struct xfs_da3_icnode_hdr nodehdr1;
 791         struct xfs_da3_icnode_hdr nodehdr2;
 792         struct xfs_trans        *tp;
 793         int                     count;
 794         int                     tmp;
 795         int                     swap = 0;
 796
 797         trace_xfs_da_node_rebalance(state->args);
 798
 799         node1 = blk1->bp->b_addr;
 800         node2 = blk2->bp->b_addr;
 801         xfs_da3_node_hdr_from_disk(&nodehdr1, node1);
 802         xfs_da3_node_hdr_from_disk(&nodehdr2, node2);
 803         btree1 = xfs_da3_node_tree_p(node1);
 804         btree2 = xfs_da3_node_tree_p(node2);
 805
 806         /*
 807          * Figure out how many entries need to move, and in which direction.
 808          * Swap the nodes around if that makes it simpler.
 809          */
 810         if (nodehdr1.count > 0 && nodehdr2.count > 0 &&
 811             ((be32_to_cpu(btree2[0].hashval) < be32_to_cpu(btree1[0].hashval)) ||
 812              (be32_to_cpu(btree2[nodehdr2.count - 1].hashval) <
 813                         be32_to_cpu(btree1[nodehdr1.count - 1].hashval)))) {
 814                 tmpnode = node1;
 815                 node1 = node2;
 816                 node2 = tmpnode;
 817                 xfs_da3_node_hdr_from_disk(&nodehdr1, node1);
 818                 xfs_da3_node_hdr_from_disk(&nodehdr2, node2);
 819                 btree1 = xfs_da3_node_tree_p(node1);
 820                 btree2 = xfs_da3_node_tree_p(node2);
 821                 swap = 1;
 822         }
 823
 824         count = (nodehdr1.count - nodehdr2.count) / 2;
 825         if (count == 0)
 826                 return;
 827         tp = state->args->trans;
 828         /*
 829          * Two cases: high-to-low and low-to-high.
 830          */
 831         if (count > 0) {
 832                 /*
 833                  * Move elements in node2 up to make a hole.
 834                  */
 835                 tmp = nodehdr2.count;
 836                 if (tmp > 0) {
 837                         tmp *= (uint)sizeof(xfs_da_node_entry_t);
 838                         btree_s = &btree2[0];
 839                         btree_d = &btree2[count];
 840                         memmove(btree_d, btree_s, tmp);
 841                 }
 842
 843                 /*
 844                  * Move the req'd B-tree elements from high in node1 to
 845                  * low in node2.
 846                  */
 847                 nodehdr2.count += count;
 848                 tmp = count * (uint)sizeof(xfs_da_node_entry_t);
 849                 btree_s = &btree1[nodehdr1.count - count];
 850                 btree_d = &btree2[0];
 851                 memcpy(btree_d, btree_s, tmp);
 852                 nodehdr1.count -= count;
 853         } else {
 854                 /*
 855                  * Move the req'd B-tree elements from low in node2 to
 856                  * high in node1.
 857                  */
 858                 count = -count;
 859                 tmp = count * (uint)sizeof(xfs_da_node_entry_t);
 860                 btree_s = &btree2[0];
 861                 btree_d = &btree1[nodehdr1.count];
 862                 memcpy(btree_d, btree_s, tmp);
 863                 nodehdr1.count += count;
 864
 865                 xfs_trans_log_buf(tp, blk1->bp,
 866                         XFS_DA_LOGRANGE(node1, btree_d, tmp));
 867
 868                 /*
 869                  * Move elements in node2 down to fill the hole.
 870                  */
 871                 tmp  = nodehdr2.count - count;
 872                 tmp *= (uint)sizeof(xfs_da_node_entry_t);
 873                 btree_s = &btree2[count];
 874                 btree_d = &btree2[0];
 875                 memmove(btree_d, btree_s, tmp);
 876                 nodehdr2.count -= count;
 877         }
 878
 879         /*
 880          * Log header of node 1 and all current bits of node 2.
 881          */
 882         xfs_da3_node_hdr_to_disk(node1, &nodehdr1);
 883         xfs_trans_log_buf(tp, blk1->bp,
 884                 XFS_DA_LOGRANGE(node1, &node1->hdr,
 885                                 xfs_da3_node_hdr_size(node1)));
 886
 887         xfs_da3_node_hdr_to_disk(node2, &nodehdr2);
 888         xfs_trans_log_buf(tp, blk2->bp,
 889                 XFS_DA_LOGRANGE(node2, &node2->hdr,
 890                                 xfs_da3_node_hdr_size(node2) +
 891                                 (sizeof(btree2[0]) * nodehdr2.count)));
 892
 893         /*
 894          * Record the last hashval from each block for upward propagation.
 895          * (note: don't use the swapped node pointers)
 896          */
 897         if (swap) {
 898                 node1 = blk1->bp->b_addr;
 899                 node2 = blk2->bp->b_addr;
 900                 xfs_da3_node_hdr_from_disk(&nodehdr1, node1);
 901                 xfs_da3_node_hdr_from_disk(&nodehdr2, node2);
 902                 btree1 = xfs_da3_node_tree_p(node1);
 903                 btree2 = xfs_da3_node_tree_p(node2);
 904         }
 905         blk1->hashval = be32_to_cpu(btree1[nodehdr1.count - 1].hashval);
 906         blk2->hashval = be32_to_cpu(btree2[nodehdr2.count - 1].hashval);
 907
 908         /*
 909          * Adjust the expected index for insertion.
 910          */
 911         if (blk1->index >= nodehdr1.count) {
 912                 blk2->index = blk1->index - nodehdr1.count;
 913                 blk1->index = nodehdr1.count + 1;       /* make it invalid */
 914         }
 915 }
 916
 917 /*
 918  * Add a new entry to an intermediate node.
 919  */
 920 STATIC void
 921 xfs_da3_node_add(
 922         struct xfs_da_state     *state,
 923         struct xfs_da_state_blk *oldblk,
 924         struct xfs_da_state_blk *newblk)
 925 {
 926         struct xfs_da_intnode   *node;
 927         struct xfs_da3_icnode_hdr nodehdr;
 928         struct xfs_da_node_entry *btree;
 929         int                     tmp;
 930
 931         trace_xfs_da_node_add(state->args);
 932
 933         node = oldblk->bp->b_addr;
 934         xfs_da3_node_hdr_from_disk(&nodehdr, node);
 935         btree = xfs_da3_node_tree_p(node);
 936
 937         ASSERT(oldblk->index >= 0 && oldblk->index <= nodehdr.count);
 938         ASSERT(newblk->blkno != 0);
 939         if (state->args->whichfork == XFS_DATA_FORK)
 940                 ASSERT(newblk->blkno >= state->mp->m_dirleafblk &&
 941                        newblk->blkno < state->mp->m_dirfreeblk);
 942
 943         /*
 944          * We may need to make some room before we insert the new node.
 945          */
 946         tmp = 0;
 947         if (oldblk->index < nodehdr.count) {
 948                 tmp = (nodehdr.count - oldblk->index) * (uint)sizeof(*btree);
 949                 memmove(&btree[oldblk->index + 1], &btree[oldblk->index], tmp);
 950         }
 951         btree[oldblk->index].hashval = cpu_to_be32(newblk->hashval);
 952         btree[oldblk->index].before = cpu_to_be32(newblk->blkno);
 953         xfs_trans_log_buf(state->args->trans, oldblk->bp,
 954                 XFS_DA_LOGRANGE(node, &btree[oldblk->index],
 955                                 tmp + sizeof(*btree)));
 956
 957         nodehdr.count += 1;
 958         xfs_da3_node_hdr_to_disk(node, &nodehdr);
 959         xfs_trans_log_buf(state->args->trans, oldblk->bp,
 960                 XFS_DA_LOGRANGE(node, &node->hdr, xfs_da3_node_hdr_size(node)));
 961
 962         /*
 963          * Copy the last hash value from the oldblk to propagate upwards.
 964          */
 965         oldblk->hashval = be32_to_cpu(btree[nodehdr.count - 1].hashval);
 966 }
 967
 968 /*========================================================================
 969  * Routines used for shrinking the Btree.
 970  *========================================================================*/
 971
 972 /*
 973  * Deallocate an empty leaf node, remove it from its parent,
 974  * possibly deallocating that block, etc...
 975  */
 976 int
 977 xfs_da3_join(
 978         struct xfs_da_state     *state)
 979 {
 980         struct xfs_da_state_blk *drop_blk;
 981         struct xfs_da_state_blk *save_blk;
 982         int                     action = 0;
 983         int                     error;
 984
 985         trace_xfs_da_join(state->args);
 986
 987         drop_blk = &state->path.blk[ state->path.active-1 ];
 988         save_blk = &state->altpath.blk[ state->path.active-1 ];
 989         ASSERT(state->path.blk[0].magic == XFS_DA_NODE_MAGIC);
 990         ASSERT(drop_blk->magic == XFS_ATTR_LEAF_MAGIC ||
 991                drop_blk->magic == XFS_DIR2_LEAFN_MAGIC);
 992
 993         /*
 994          * Walk back up the tree joining/deallocating as necessary.
 995          * When we stop dropping blocks, break out.
 996          */
 997         for (  ; state->path.active >= 2; drop_blk--, save_blk--,
 998                  state->path.active--) {
 999                 /*
1000                  * See if we can combine the block with a neighbor.
1001                  *   (action == 0) => no options, just leave
1002                  *   (action == 1) => coalesce, then unlink
1003                  *   (action == 2) => block empty, unlink it
1004                  */
1005                 switch (drop_blk->magic) {
1006                 case XFS_ATTR_LEAF_MAGIC:
1007                         error = xfs_attr3_leaf_toosmall(state, &action);
1008                         if (error)
1009                                 return(error);
1010                         if (action == 0)
1011                                 return(0);
1012                         xfs_attr3_leaf_unbalance(state, drop_blk, save_blk);
1013                         break;
1014                 case XFS_DIR2_LEAFN_MAGIC:
1015                         error = xfs_dir2_leafn_toosmall(state, &action);
1016                         if (error)
1017                                 return error;
1018                         if (action == 0)
1019                                 return 0;
1020                         xfs_dir2_leafn_unbalance(state, drop_blk, save_blk);
1021                         break;
1022                 case XFS_DA_NODE_MAGIC:
1023                         /*
1024                          * Remove the offending node, fixup hashvals,
1025                          * check for a toosmall neighbor.
1026                          */
1027                         xfs_da3_node_remove(state, drop_blk);
1028                         xfs_da3_fixhashpath(state, &state->path);
1029                         error = xfs_da3_node_toosmall(state, &action);
1030                         if (error)
1031                                 return(error);
1032                         if (action == 0)
1033                                 return 0;
1034                         xfs_da3_node_unbalance(state, drop_blk, save_blk);
1035                         break;
1036                 }
1037                 xfs_da3_fixhashpath(state, &state->altpath);
1038                 error = xfs_da3_blk_unlink(state, drop_blk, save_blk);
1039                 xfs_da_state_kill_altpath(state);
1040                 if (error)
1041                         return(error);
1042                 error = xfs_da_shrink_inode(state->args, drop_blk->blkno,
1043                                                          drop_blk->bp);
1044                 drop_blk->bp = NULL;
1045                 if (error)
1046                         return(error);
1047         }
1048         /*
1049          * We joined all the way to the top.  If it turns out that
1050          * we only have one entry in the root, make the child block
1051          * the new root.
1052          */
1053         xfs_da3_node_remove(state, drop_blk);
1054         xfs_da3_fixhashpath(state, &state->path);
1055         error = xfs_da3_root_join(state, &state->path.blk[0]);
1056         return(error);
1057 }
1058
1059 #ifdef  DEBUG
1060 static void
1061 xfs_da_blkinfo_onlychild_validate(struct xfs_da_blkinfo *blkinfo, __u16 level)
1062 {
1063         __be16  magic = blkinfo->magic;
1064
1065         if (level == 1) {
1066                 ASSERT(magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
1067                        magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC) ||
1068                        magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC) ||
1069                        magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC));
1070         } else {
1071                 ASSERT(magic == cpu_to_be16(XFS_DA_NODE_MAGIC) ||
1072                        magic == cpu_to_be16(XFS_DA3_NODE_MAGIC));
1073         }
1074         ASSERT(!blkinfo->forw);
1075         ASSERT(!blkinfo->back);
1076 }
1077 #else   /* !DEBUG */
1078 #define xfs_da_blkinfo_onlychild_validate(blkinfo, level)
1079 #endif  /* !DEBUG */
1080
1081 /*
1082  * We have only one entry in the root.  Copy the only remaining child of
1083  * the old root to block 0 as the new root node.
1084  */
1085 STATIC int
1086 xfs_da3_root_join(
1087         struct xfs_da_state     *state,
1088         struct xfs_da_state_blk *root_blk)
1089 {
1090         struct xfs_da_intnode   *oldroot;
1091         struct xfs_da_args      *args;
1092         xfs_dablk_t             child;
1093         struct xfs_buf          *bp;
1094         struct xfs_da3_icnode_hdr oldroothdr;
1095         struct xfs_da_node_entry *btree;
1096         int                     error;
1097
1098         trace_xfs_da_root_join(state->args);
1099
1100         ASSERT(root_blk->magic == XFS_DA_NODE_MAGIC);
1101
1102         args = state->args;
1103         oldroot = root_blk->bp->b_addr;
1104         xfs_da3_node_hdr_from_disk(&oldroothdr, oldroot);
1105         ASSERT(oldroothdr.forw == 0);
1106         ASSERT(oldroothdr.back == 0);
1107
1108         /*
1109          * If the root has more than one child, then don't do anything.
1110          */
1111         if (oldroothdr.count > 1)
1112                 return 0;
1113
1114         /*
1115          * Read in the (only) child block, then copy those bytes into
1116          * the root block's buffer and free the original child block.
1117          */
1118         btree = xfs_da3_node_tree_p(oldroot);
1119         child = be32_to_cpu(btree[0].before);
1120         ASSERT(child != 0);
1121         error = xfs_da3_node_read(args->trans, args->dp, child, -1, &bp,
1122                                              args->whichfork);
1123         if (error)
1124                 return error;
1125         xfs_da_blkinfo_onlychild_validate(bp->b_addr, oldroothdr.level);
1126
1127         /*
1128          * This could be copying a leaf back into the root block in the case of
1129          * there only being a single leaf block left in the tree. Hence we have
1130          * to update the b_ops pointer as well to match the buffer type change
1131          * that could occur. For dir3 blocks we also need to update the block
1132          * number in the buffer header.
1133          */
1134         memcpy(root_blk->bp->b_addr, bp->b_addr, state->blocksize);
1135         root_blk->bp->b_ops = bp->b_ops;
1136         xfs_trans_buf_copy_type(root_blk->bp, bp);
1137         if (oldroothdr.magic == XFS_DA3_NODE_MAGIC) {
1138                 struct xfs_da3_blkinfo *da3 = root_blk->bp->b_addr;
1139                 da3->blkno = cpu_to_be64(root_blk->bp->b_bn);
1140         }
1141         xfs_trans_log_buf(args->trans, root_blk->bp, 0, state->blocksize - 1);
1142         error = xfs_da_shrink_inode(args, child, bp);
1143         return(error);
1144 }
1145
1146 /*
1147  * Check a node block and its neighbors to see if the block should be
1148  * collapsed into one or the other neighbor.  Always keep the block
1149  * with the smaller block number.
1150  * If the current block is over 50% full, don't try to join it, return 0.
1151  * If the block is empty, fill in the state structure and return 2.
1152  * If it can be collapsed, fill in the state structure and return 1.
1153  * If nothing can be done, return 0.
1154  */
1155 STATIC int
1156 xfs_da3_node_toosmall(
1157         struct xfs_da_state     *state,
1158         int                     *action)
1159 {
1160         struct xfs_da_intnode   *node;
1161         struct xfs_da_state_blk *blk;
1162         struct xfs_da_blkinfo   *info;
1163         xfs_dablk_t             blkno;
1164         struct xfs_buf          *bp;
1165         struct xfs_da3_icnode_hdr nodehdr;
1166         int                     count;
1167         int                     forward;
1168         int                     error;
1169         int                     retval;
1170         int                     i;
1171
1172         trace_xfs_da_node_toosmall(state->args);
1173
1174         /*
1175          * Check for the degenerate case of the block being over 50% full.
1176          * If so, it's not worth even looking to see if we might be able
1177          * to coalesce with a sibling.
1178          */
1179         blk = &state->path.blk[ state->path.active-1 ];
1180         info = blk->bp->b_addr;
1181         node = (xfs_da_intnode_t *)info;
1182         xfs_da3_node_hdr_from_disk(&nodehdr, node);
1183         if (nodehdr.count > (state->node_ents >> 1)) {
1184                 *action = 0;    /* blk over 50%, don't try to join */
1185                 return(0);      /* blk over 50%, don't try to join */
1186         }
1187
1188         /*
1189          * Check for the degenerate case of the block being empty.
1190          * If the block is empty, we'll simply delete it, no need to
1191          * coalesce it with a sibling block.  We choose (arbitrarily)
1192          * to merge with the forward block unless it is NULL.
1193          */
1194         if (nodehdr.count == 0) {
1195                 /*
1196                  * Make altpath point to the block we want to keep and
1197                  * path point to the block we want to drop (this one).
1198                  */
1199                 forward = (info->forw != 0);
1200                 memcpy(&state->altpath, &state->path, sizeof(state->path));
1201                 error = xfs_da3_path_shift(state, &state->altpath, forward,
1202                                                  0, &retval);
1203                 if (error)
1204                         return(error);
1205                 if (retval) {
1206                         *action = 0;
1207                 } else {
1208                         *action = 2;
1209                 }
1210                 return(0);
1211         }
1212
1213         /*
1214          * Examine each sibling block to see if we can coalesce with
1215          * at least 25% free space to spare.  We need to figure out
1216          * whether to merge with the forward or the backward block.
1217          * We prefer coalescing with the lower numbered sibling so as
1218          * to shrink a directory over time.
1219          */
1220         count  = state->node_ents;
1221         count -= state->node_ents >> 2;
1222         count -= nodehdr.count;
1223
1224         /* start with smaller blk num */
1225         forward = nodehdr.forw < nodehdr.back;
1226         for (i = 0; i < 2; forward = !forward, i++) {
1227                 struct xfs_da3_icnode_hdr thdr;
1228                 if (forward)
1229                         blkno = nodehdr.forw;
1230                 else
1231                         blkno = nodehdr.back;
1232                 if (blkno == 0)
1233                         continue;
1234                 error = xfs_da3_node_read(state->args->trans, state->args->dp,
1235                                         blkno, -1, &bp, state->args->whichfork);
1236                 if (error)
1237                         return(error);
1238
1239                 node = bp->b_addr;
1240                 xfs_da3_node_hdr_from_disk(&thdr, node);
1241                 xfs_trans_brelse(state->args->trans, bp);
1242
1243                 if (count - thdr.count >= 0)
1244                         break;  /* fits with at least 25% to spare */
1245         }
1246         if (i >= 2) {
1247                 *action = 0;
1248                 return 0;
1249         }
1250
1251         /*
1252          * Make altpath point to the block we want to keep (the lower
1253          * numbered block) and path point to the block we want to drop.
1254          */
1255         memcpy(&state->altpath, &state->path, sizeof(state->path));
1256         if (blkno < blk->blkno) {
1257                 error = xfs_da3_path_shift(state, &state->altpath, forward,
1258                                                  0, &retval);
1259         } else {
1260                 error = xfs_da3_path_shift(state, &state->path, forward,
1261                                                  0, &retval);
1262         }
1263         if (error)
1264                 return error;
1265         if (retval) {
1266                 *action = 0;
1267                 return 0;
1268         }
1269         *action = 1;
1270         return 0;
1271 }
1272
1273 /*
1274  * Pick up the last hashvalue from an intermediate node.
1275  */
1276 STATIC uint
1277 xfs_da3_node_lasthash(
1278         struct xfs_buf          *bp,
1279         int                     *count)
1280 {
1281         struct xfs_da_intnode    *node;
1282         struct xfs_da_node_entry *btree;
1283         struct xfs_da3_icnode_hdr nodehdr;
1284
1285         node = bp->b_addr;
1286         xfs_da3_node_hdr_from_disk(&nodehdr, node);
1287         if (count)
1288                 *count = nodehdr.count;
1289         if (!nodehdr.count)
1290                 return 0;
1291         btree = xfs_da3_node_tree_p(node);
1292         return be32_to_cpu(btree[nodehdr.count - 1].hashval);
1293 }
1294
1295 /*
1296  * Walk back up the tree adjusting hash values as necessary,
1297  * when we stop making changes, return.
1298  */
1299 void
1300 xfs_da3_fixhashpath(
1301         struct xfs_da_state     *state,
1302         struct xfs_da_state_path *path)
1303 {
1304         struct xfs_da_state_blk *blk;
1305         struct xfs_da_intnode   *node;
1306         struct xfs_da_node_entry *btree;
1307         xfs_dahash_t            lasthash=0;
1308         int                     level;
1309         int                     count;
1310
1311         trace_xfs_da_fixhashpath(state->args);
1312
1313         level = path->active-1;
1314         blk = &path->blk[ level ];
1315         switch (blk->magic) {
1316         case XFS_ATTR_LEAF_MAGIC:
1317                 lasthash = xfs_attr_leaf_lasthash(blk->bp, &count);
1318                 if (count == 0)
1319                         return;
1320                 break;
1321         case XFS_DIR2_LEAFN_MAGIC:
1322                 lasthash = xfs_dir2_leafn_lasthash(blk->bp, &count);
1323                 if (count == 0)
1324                         return;
1325                 break;
1326         case XFS_DA_NODE_MAGIC:
1327                 lasthash = xfs_da3_node_lasthash(blk->bp, &count);
1328                 if (count == 0)
1329                         return;
1330                 break;
1331         }
1332         for (blk--, level--; level >= 0; blk--, level--) {
1333                 struct xfs_da3_icnode_hdr nodehdr;
1334
1335                 node = blk->bp->b_addr;
1336                 xfs_da3_node_hdr_from_disk(&nodehdr, node);
1337                 btree = xfs_da3_node_tree_p(node);
1338                 if (be32_to_cpu(btree->hashval) == lasthash)
1339                         break;
1340                 blk->hashval = lasthash;
1341                 btree[blk->index].hashval = cpu_to_be32(lasthash);
1342                 xfs_trans_log_buf(state->args->trans, blk->bp,
1343                                   XFS_DA_LOGRANGE(node, &btree[blk->index],
1344                                                   sizeof(*btree)));
1345
1346                 lasthash = be32_to_cpu(btree[nodehdr.count - 1].hashval);
1347         }
1348 }
1349
1350 /*
1351  * Remove an entry from an intermediate node.
1352  */
1353 STATIC void
1354 xfs_da3_node_remove(
1355         struct xfs_da_state     *state,
1356         struct xfs_da_state_blk *drop_blk)
1357 {
1358         struct xfs_da_intnode   *node;
1359         struct xfs_da3_icnode_hdr nodehdr;
1360         struct xfs_da_node_entry *btree;
1361         int                     index;
1362         int                     tmp;
1363
1364         trace_xfs_da_node_remove(state->args);
1365
1366         node = drop_blk->bp->b_addr;
1367         xfs_da3_node_hdr_from_disk(&nodehdr, node);
1368         ASSERT(drop_blk->index < nodehdr.count);
1369         ASSERT(drop_blk->index >= 0);
1370
1371         /*
1372          * Copy over the offending entry, or just zero it out.
1373          */
1374         index = drop_blk->index;
1375         btree = xfs_da3_node_tree_p(node);
1376         if (index < nodehdr.count - 1) {
1377                 tmp  = nodehdr.count - index - 1;
1378                 tmp *= (uint)sizeof(xfs_da_node_entry_t);
1379                 memmove(&btree[index], &btree[index + 1], tmp);
1380                 xfs_trans_log_buf(state->args->trans, drop_blk->bp,
1381                     XFS_DA_LOGRANGE(node, &btree[index], tmp));
1382                 index = nodehdr.count - 1;
1383         }
1384         memset(&btree[index], 0, sizeof(xfs_da_node_entry_t));
1385         xfs_trans_log_buf(state->args->trans, drop_blk->bp,
1386             XFS_DA_LOGRANGE(node, &btree[index], sizeof(btree[index])));
1387         nodehdr.count -= 1;
1388         xfs_da3_node_hdr_to_disk(node, &nodehdr);
1389         xfs_trans_log_buf(state->args->trans, drop_blk->bp,
1390             XFS_DA_LOGRANGE(node, &node->hdr, xfs_da3_node_hdr_size(node)));
1391
1392         /*
1393          * Copy the last hash value from the block to propagate upwards.
1394          */
1395         drop_blk->hashval = be32_to_cpu(btree[index - 1].hashval);
1396 }
1397
1398 /*
1399  * Unbalance the elements between two intermediate nodes,
1400  * move all Btree elements from one node into another.
1401  */
1402 STATIC void
1403 xfs_da3_node_unbalance(
1404         struct xfs_da_state     *state,
1405         struct xfs_da_state_blk *drop_blk,
1406         struct xfs_da_state_blk *save_blk)
1407 {
1408         struct xfs_da_intnode   *drop_node;
1409         struct xfs_da_intnode   *save_node;
1410         struct xfs_da_node_entry *drop_btree;
1411         struct xfs_da_node_entry *save_btree;
1412         struct xfs_da3_icnode_hdr drop_hdr;
1413         struct xfs_da3_icnode_hdr save_hdr;
1414         struct xfs_trans        *tp;
1415         int                     sindex;
1416         int                     tmp;
1417
1418         trace_xfs_da_node_unbalance(state->args);
1419
1420         drop_node = drop_blk->bp->b_addr;
1421         save_node = save_blk->bp->b_addr;
1422         xfs_da3_node_hdr_from_disk(&drop_hdr, drop_node);
1423         xfs_da3_node_hdr_from_disk(&save_hdr, save_node);
1424         drop_btree = xfs_da3_node_tree_p(drop_node);
1425         save_btree = xfs_da3_node_tree_p(save_node);
1426         tp = state->args->trans;
1427
1428         /*
1429          * If the dying block has lower hashvals, then move all the
1430          * elements in the remaining block up to make a hole.
1431          */
1432         if ((be32_to_cpu(drop_btree[0].hashval) <
1433                         be32_to_cpu(save_btree[0].hashval)) ||
1434             (be32_to_cpu(drop_btree[drop_hdr.count - 1].hashval) <
1435                         be32_to_cpu(save_btree[save_hdr.count - 1].hashval))) {
1436                 /* XXX: check this - is memmove dst correct? */
1437                 tmp = save_hdr.count * sizeof(xfs_da_node_entry_t);
1438                 memmove(&save_btree[drop_hdr.count], &save_btree[0], tmp);
1439
1440                 sindex = 0;
1441                 xfs_trans_log_buf(tp, save_blk->bp,
1442                         XFS_DA_LOGRANGE(save_node, &save_btree[0],
1443                                 (save_hdr.count + drop_hdr.count) *
1444                                                 sizeof(xfs_da_node_entry_t)));
1445         } else {
1446                 sindex = save_hdr.count;
1447                 xfs_trans_log_buf(tp, save_blk->bp,
1448                         XFS_DA_LOGRANGE(save_node, &save_btree[sindex],
1449                                 drop_hdr.count * sizeof(xfs_da_node_entry_t)));
1450         }
1451
1452         /*
1453          * Move all the B-tree elements from drop_blk to save_blk.
1454          */
1455         tmp = drop_hdr.count * (uint)sizeof(xfs_da_node_entry_t);
1456         memcpy(&save_btree[sindex], &drop_btree[0], tmp);
1457         save_hdr.count += drop_hdr.count;
1458
1459         xfs_da3_node_hdr_to_disk(save_node, &save_hdr);
1460         xfs_trans_log_buf(tp, save_blk->bp,
1461                 XFS_DA_LOGRANGE(save_node, &save_node->hdr,
1462                                 xfs_da3_node_hdr_size(save_node)));
1463
1464         /*
1465          * Save the last hashval in the remaining block for upward propagation.
1466          */
1467         save_blk->hashval = be32_to_cpu(save_btree[save_hdr.count - 1].hashval);
1468 }
1469
1470 /*========================================================================
1471  * Routines used for finding things in the Btree.
1472  *========================================================================*/
1473
1474 /*
1475  * Walk down the Btree looking for a particular filename, filling
1476  * in the state structure as we go.
1477  *
1478  * We will set the state structure to point to each of the elements
1479  * in each of the nodes where either the hashval is or should be.
1480  *
1481  * We support duplicate hashval's so for each entry in the current
1482  * node that could contain the desired hashval, descend.  This is a
1483  * pruned depth-first tree search.
1484  */
1485 int                                                     /* error */
1486 xfs_da3_node_lookup_int(
1487         struct xfs_da_state     *state,
1488         int                     *result)
1489 {
1490         struct xfs_da_state_blk *blk;
1491         struct xfs_da_blkinfo   *curr;
1492         struct xfs_da_intnode   *node;
1493         struct xfs_da_node_entry *btree;
1494         struct xfs_da3_icnode_hdr nodehdr;
1495         struct xfs_da_args      *args;
1496         xfs_dablk_t             blkno;
1497         xfs_dahash_t            hashval;
1498         xfs_dahash_t            btreehashval;
1499         int                     probe;
1500         int                     span;
1501         int                     max;
1502         int                     error;
1503         int                     retval;
1504
1505         args = state->args;
1506
1507         /*
1508          * Descend thru the B-tree searching each level for the right
1509          * node to use, until the right hashval is found.
1510          */
1511         blkno = (args->whichfork == XFS_DATA_FORK)? state->mp->m_dirleafblk : 0;
1512         for (blk = &state->path.blk[0], state->path.active = 1;
1513                          state->path.active <= XFS_DA_NODE_MAXDEPTH;
1514                          blk++, state->path.active++) {
1515                 /*
1516                  * Read the next node down in the tree.
1517                  */
1518                 blk->blkno = blkno;
1519                 error = xfs_da3_node_read(args->trans, args->dp, blkno,
1520                                         -1, &blk->bp, args->whichfork);
1521                 if (error) {
1522                         blk->blkno = 0;
1523                         state->path.active--;
1524                         return(error);
1525                 }
1526                 curr = blk->bp->b_addr;
1527                 blk->magic = be16_to_cpu(curr->magic);
1528
1529                 if (blk->magic == XFS_ATTR_LEAF_MAGIC ||
1530                     blk->magic == XFS_ATTR3_LEAF_MAGIC) {
1531                         blk->magic = XFS_ATTR_LEAF_MAGIC;
1532                         blk->hashval = xfs_attr_leaf_lasthash(blk->bp, NULL);
1533                         break;
1534                 }
1535
1536                 if (blk->magic == XFS_DIR2_LEAFN_MAGIC ||
1537                     blk->magic == XFS_DIR3_LEAFN_MAGIC) {
1538                         blk->magic = XFS_DIR2_LEAFN_MAGIC;
1539                         blk->hashval = xfs_dir2_leafn_lasthash(blk->bp, NULL);
1540                         break;
1541                 }
1542
1543                 blk->magic = XFS_DA_NODE_MAGIC;
1544
1545
1546                 /*
1547                  * Search an intermediate node for a match.
1548                  */
1549                 node = blk->bp->b_addr;
1550                 xfs_da3_node_hdr_from_disk(&nodehdr, node);
1551                 btree = xfs_da3_node_tree_p(node);
1552
1553                 max = nodehdr.count;
1554                 blk->hashval = be32_to_cpu(btree[max - 1].hashval);
1555
1556                 /*
1557                  * Binary search.  (note: small blocks will skip loop)
1558                  */
1559                 probe = span = max / 2;
1560                 hashval = args->hashval;
1561                 while (span > 4) {
1562                         span /= 2;
1563                         btreehashval = be32_to_cpu(btree[probe].hashval);
1564                         if (btreehashval < hashval)
1565                                 probe += span;
1566                         else if (btreehashval > hashval)
1567                                 probe -= span;
1568                         else
1569                                 break;
1570                 }
1571                 ASSERT((probe >= 0) && (probe < max));
1572                 ASSERT((span <= 4) ||
1573                         (be32_to_cpu(btree[probe].hashval) == hashval));
1574
1575                 /*
1576                  * Since we may have duplicate hashval's, find the first
1577                  * matching hashval in the node.
1578                  */
1579                 while (probe > 0 &&
1580                        be32_to_cpu(btree[probe].hashval) >= hashval) {
1581                         probe--;
1582                 }
1583                 while (probe < max &&
1584                        be32_to_cpu(btree[probe].hashval) < hashval) {
1585                         probe++;
1586                 }
1587
1588                 /*
1589                  * Pick the right block to descend on.
1590                  */
1591                 if (probe == max) {
1592                         blk->index = max - 1;
1593                         blkno = be32_to_cpu(btree[max - 1].before);
1594                 } else {
1595                         blk->index = probe;
1596                         blkno = be32_to_cpu(btree[probe].before);
1597                 }
1598         }
1599
1600         /*
1601          * A leaf block that ends in the hashval that we are interested in
1602          * (final hashval == search hashval) means that the next block may
1603          * contain more entries with the same hashval, shift upward to the
1604          * next leaf and keep searching.
1605          */
1606         for (;;) {
1607                 if (blk->magic == XFS_DIR2_LEAFN_MAGIC) {
1608                         retval = xfs_dir2_leafn_lookup_int(blk->bp, args,
1609                                                         &blk->index, state);
1610                 } else if (blk->magic == XFS_ATTR_LEAF_MAGIC) {
1611                         retval = xfs_attr3_leaf_lookup_int(blk->bp, args);
1612                         blk->index = args->index;
1613                         args->blkno = blk->blkno;
1614                 } else {
1615                         ASSERT(0);
1616                         return XFS_ERROR(EFSCORRUPTED);
1617                 }
1618                 if (((retval == ENOENT) || (retval == ENOATTR)) &&
1619                     (blk->hashval == args->hashval)) {
1620                         error = xfs_da3_path_shift(state, &state->path, 1, 1,
1621                                                          &retval);
1622                         if (error)
1623                                 return(error);
1624                         if (retval == 0) {
1625                                 continue;
1626                         } else if (blk->magic == XFS_ATTR_LEAF_MAGIC) {
1627                                 /* path_shift() gives ENOENT */
1628                                 retval = XFS_ERROR(ENOATTR);
1629                         }
1630                 }
1631                 break;
1632         }
1633         *result = retval;
1634         return(0);
1635 }
1636
1637 /*========================================================================
1638  * Utility routines.
1639  *========================================================================*/
1640
1641 /*
1642  * Compare two intermediate nodes for "order".
1643  */
1644 STATIC int
1645 xfs_da3_node_order(
1646         struct xfs_buf  *node1_bp,
1647         struct xfs_buf  *node2_bp)
1648 {
1649         struct xfs_da_intnode   *node1;
1650         struct xfs_da_intnode   *node2;
1651         struct xfs_da_node_entry *btree1;
1652         struct xfs_da_node_entry *btree2;
1653         struct xfs_da3_icnode_hdr node1hdr;
1654         struct xfs_da3_icnode_hdr node2hdr;
1655
1656         node1 = node1_bp->b_addr;
1657         node2 = node2_bp->b_addr;
1658         xfs_da3_node_hdr_from_disk(&node1hdr, node1);
1659         xfs_da3_node_hdr_from_disk(&node2hdr, node2);
1660         btree1 = xfs_da3_node_tree_p(node1);
1661         btree2 = xfs_da3_node_tree_p(node2);
1662
1663         if (node1hdr.count > 0 && node2hdr.count > 0 &&
1664             ((be32_to_cpu(btree2[0].hashval) < be32_to_cpu(btree1[0].hashval)) ||
1665              (be32_to_cpu(btree2[node2hdr.count - 1].hashval) <
1666               be32_to_cpu(btree1[node1hdr.count - 1].hashval)))) {
1667                 return 1;
1668         }
1669         return 0;
1670 }
1671
1672 /*
1673  * Link a new block into a doubly linked list of blocks (of whatever type).
1674  */
1675 int                                                     /* error */
1676 xfs_da3_blk_link(
1677         struct xfs_da_state     *state,
1678         struct xfs_da_state_blk *old_blk,
1679         struct xfs_da_state_blk *new_blk)
1680 {
1681         struct xfs_da_blkinfo   *old_info;
1682         struct xfs_da_blkinfo   *new_info;
1683         struct xfs_da_blkinfo   *tmp_info;
1684         struct xfs_da_args      *args;
1685         struct xfs_buf          *bp;
1686         int                     before = 0;
1687         int                     error;
1688
1689         /*
1690          * Set up environment.
1691          */
1692         args = state->args;
1693         ASSERT(args != NULL);
1694         old_info = old_blk->bp->b_addr;
1695         new_info = new_blk->bp->b_addr;
1696         ASSERT(old_blk->magic == XFS_DA_NODE_MAGIC ||
1697                old_blk->magic == XFS_DIR2_LEAFN_MAGIC ||
1698                old_blk->magic == XFS_ATTR_LEAF_MAGIC);
1699
1700         switch (old_blk->magic) {
1701         case XFS_ATTR_LEAF_MAGIC:
1702                 before = xfs_attr_leaf_order(old_blk->bp, new_blk->bp);
1703                 break;
1704         case XFS_DIR2_LEAFN_MAGIC:
1705                 before = xfs_dir2_leafn_order(old_blk->bp, new_blk->bp);
1706                 break;
1707         case XFS_DA_NODE_MAGIC:
1708                 before = xfs_da3_node_order(old_blk->bp, new_blk->bp);
1709                 break;
1710         }
1711
1712         /*
1713          * Link blocks in appropriate order.
1714          */
1715         if (before) {
1716                 /*
1717                  * Link new block in before existing block.
1718                  */
1719                 trace_xfs_da_link_before(args);
1720                 new_info->forw = cpu_to_be32(old_blk->blkno);
1721                 new_info->back = old_info->back;
1722                 if (old_info->back) {
1723                         error = xfs_da3_node_read(args->trans, args->dp,
1724                                                 be32_to_cpu(old_info->back),
1725                                                 -1, &bp, args->whichfork);
1726                         if (error)
1727                                 return(error);
1728                         ASSERT(bp != NULL);
1729                         tmp_info = bp->b_addr;
1730                         ASSERT(tmp_info->magic == old_info->magic);
1731                         ASSERT(be32_to_cpu(tmp_info->forw) == old_blk->blkno);
1732                         tmp_info->forw = cpu_to_be32(new_blk->blkno);
1733                         xfs_trans_log_buf(args->trans, bp, 0, sizeof(*tmp_info)-1);
1734                 }
1735                 old_info->back = cpu_to_be32(new_blk->blkno);
1736         } else {
1737                 /*
1738                  * Link new block in after existing block.
1739                  */
1740                 trace_xfs_da_link_after(args);
1741                 new_info->forw = old_info->forw;
1742                 new_info->back = cpu_to_be32(old_blk->blkno);
1743                 if (old_info->forw) {
1744                         error = xfs_da3_node_read(args->trans, args->dp,
1745                                                 be32_to_cpu(old_info->forw),
1746                                                 -1, &bp, args->whichfork);
1747                         if (error)
1748                                 return(error);
1749                         ASSERT(bp != NULL);
1750                         tmp_info = bp->b_addr;
1751                         ASSERT(tmp_info->magic == old_info->magic);
1752                         ASSERT(be32_to_cpu(tmp_info->back) == old_blk->blkno);
1753                         tmp_info->back = cpu_to_be32(new_blk->blkno);
1754                         xfs_trans_log_buf(args->trans, bp, 0, sizeof(*tmp_info)-1);
1755                 }
1756                 old_info->forw = cpu_to_be32(new_blk->blkno);
1757         }
1758
1759         xfs_trans_log_buf(args->trans, old_blk->bp, 0, sizeof(*tmp_info) - 1);
1760         xfs_trans_log_buf(args->trans, new_blk->bp, 0, sizeof(*tmp_info) - 1);
1761         return(0);
1762 }
1763
1764 /*
1765  * Unlink a block from a doubly linked list of blocks.
1766  */
1767 STATIC int                                              /* error */
1768 xfs_da3_blk_unlink(
1769         struct xfs_da_state     *state,
1770         struct xfs_da_state_blk *drop_blk,
1771         struct xfs_da_state_blk *save_blk)
1772 {
1773         struct xfs_da_blkinfo   *drop_info;
1774         struct xfs_da_blkinfo   *save_info;
1775         struct xfs_da_blkinfo   *tmp_info;
1776         struct xfs_da_args      *args;
1777         struct xfs_buf          *bp;
1778         int                     error;
1779
1780         /*
1781          * Set up environment.
1782          */
1783         args = state->args;
1784         ASSERT(args != NULL);
1785         save_info = save_blk->bp->b_addr;
1786         drop_info = drop_blk->bp->b_addr;
1787         ASSERT(save_blk->magic == XFS_DA_NODE_MAGIC ||
1788                save_blk->magic == XFS_DIR2_LEAFN_MAGIC ||
1789                save_blk->magic == XFS_ATTR_LEAF_MAGIC);
1790         ASSERT(save_blk->magic == drop_blk->magic);
1791         ASSERT((be32_to_cpu(save_info->forw) == drop_blk->blkno) ||
1792                (be32_to_cpu(save_info->back) == drop_blk->blkno));
1793         ASSERT((be32_to_cpu(drop_info->forw) == save_blk->blkno) ||
1794                (be32_to_cpu(drop_info->back) == save_blk->blkno));
1795
1796         /*
1797          * Unlink the leaf block from the doubly linked chain of leaves.
1798          */
1799         if (be32_to_cpu(save_info->back) == drop_blk->blkno) {
1800                 trace_xfs_da_unlink_back(args);
1801                 save_info->back = drop_info->back;
1802                 if (drop_info->back) {
1803                         error = xfs_da3_node_read(args->trans, args->dp,
1804                                                 be32_to_cpu(drop_info->back),
1805                                                 -1, &bp, args->whichfork);
1806                         if (error)
1807                                 return(error);
1808                         ASSERT(bp != NULL);
1809                         tmp_info = bp->b_addr;
1810                         ASSERT(tmp_info->magic == save_info->magic);
1811                         ASSERT(be32_to_cpu(tmp_info->forw) == drop_blk->blkno);
1812                         tmp_info->forw = cpu_to_be32(save_blk->blkno);
1813                         xfs_trans_log_buf(args->trans, bp, 0,
1814                                                     sizeof(*tmp_info) - 1);
1815                 }
1816         } else {
1817                 trace_xfs_da_unlink_forward(args);
1818                 save_info->forw = drop_info->forw;
1819                 if (drop_info->forw) {
1820                         error = xfs_da3_node_read(args->trans, args->dp,
1821                                                 be32_to_cpu(drop_info->forw),
1822                                                 -1, &bp, args->whichfork);
1823                         if (error)
1824                                 return(error);
1825                         ASSERT(bp != NULL);
1826                         tmp_info = bp->b_addr;
1827                         ASSERT(tmp_info->magic == save_info->magic);
1828                         ASSERT(be32_to_cpu(tmp_info->back) == drop_blk->blkno);
1829                         tmp_info->back = cpu_to_be32(save_blk->blkno);
1830                         xfs_trans_log_buf(args->trans, bp, 0,
1831                                                     sizeof(*tmp_info) - 1);
1832                 }
1833         }
1834
1835         xfs_trans_log_buf(args->trans, save_blk->bp, 0, sizeof(*save_info) - 1);
1836         return(0);
1837 }
1838
1839 /*
1840  * Move a path "forward" or "!forward" one block at the current level.
1841  *
1842  * This routine will adjust a "path" to point to the next block
1843  * "forward" (higher hashvalues) or "!forward" (lower hashvals) in the
1844  * Btree, including updating pointers to the intermediate nodes between
1845  * the new bottom and the root.
1846  */
1847 int                                                     /* error */
1848 xfs_da3_path_shift(
1849         struct xfs_da_state     *state,
1850         struct xfs_da_state_path *path,
1851         int                     forward,
1852         int                     release,
1853         int                     *result)
1854 {
1855         struct xfs_da_state_blk *blk;
1856         struct xfs_da_blkinfo   *info;
1857         struct xfs_da_intnode   *node;
1858         struct xfs_da_args      *args;
1859         struct xfs_da_node_entry *btree;
1860         struct xfs_da3_icnode_hdr nodehdr;
1861         xfs_dablk_t             blkno = 0;
1862         int                     level;
1863         int                     error;
1864
1865         trace_xfs_da_path_shift(state->args);
1866
1867         /*
1868          * Roll up the Btree looking for the first block where our
1869          * current index is not at the edge of the block.  Note that
1870          * we skip the bottom layer because we want the sibling block.
1871          */
1872         args = state->args;
1873         ASSERT(args != NULL);
1874         ASSERT(path != NULL);
1875         ASSERT((path->active > 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
1876         level = (path->active-1) - 1;   /* skip bottom layer in path */
1877         for (blk = &path->blk[level]; level >= 0; blk--, level--) {
1878                 node = blk->bp->b_addr;
1879                 xfs_da3_node_hdr_from_disk(&nodehdr, node);
1880                 btree = xfs_da3_node_tree_p(node);
1881
1882                 if (forward && (blk->index < nodehdr.count - 1)) {
1883                         blk->index++;
1884                         blkno = be32_to_cpu(btree[blk->index].before);
1885                         break;
1886                 } else if (!forward && (blk->index > 0)) {
1887                         blk->index--;
1888                         blkno = be32_to_cpu(btree[blk->index].before);
1889                         break;
1890                 }
1891         }
1892         if (level < 0) {
1893                 *result = XFS_ERROR(ENOENT);    /* we're out of our tree */
1894                 ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
1895                 return(0);
1896         }
1897
1898         /*
1899          * Roll down the edge of the subtree until we reach the
1900          * same depth we were at originally.
1901          */
1902         for (blk++, level++; level < path->active; blk++, level++) {
1903                 /*
1904                  * Release the old block.
1905                  * (if it's dirty, trans won't actually let go)
1906                  */
1907                 if (release)
1908                         xfs_trans_brelse(args->trans, blk->bp);
1909
1910                 /*
1911                  * Read the next child block.
1912                  */
1913                 blk->blkno = blkno;
1914                 error = xfs_da3_node_read(args->trans, args->dp, blkno, -1,
1915                                         &blk->bp, args->whichfork);
1916                 if (error)
1917                         return(error);
1918                 info = blk->bp->b_addr;
1919                 ASSERT(info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC) ||
1920                        info->magic == cpu_to_be16(XFS_DA3_NODE_MAGIC) ||
1921                        info->magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
1922                        info->magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC) ||
1923                        info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC) ||
1924                        info->magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC));
1925
1926
1927                 /*
1928                  * Note: we flatten the magic number to a single type so we
1929                  * don't have to compare against crc/non-crc types elsewhere.
1930                  */
1931                 switch (be16_to_cpu(info->magic)) {
1932                 case XFS_DA_NODE_MAGIC:
1933                 case XFS_DA3_NODE_MAGIC:
1934                         blk->magic = XFS_DA_NODE_MAGIC;
1935                         node = (xfs_da_intnode_t *)info;
1936                         xfs_da3_node_hdr_from_disk(&nodehdr, node);
1937                         btree = xfs_da3_node_tree_p(node);
1938                         blk->hashval = be32_to_cpu(btree[nodehdr.count - 1].hashval);
1939                         if (forward)
1940                                 blk->index = 0;
1941                         else
1942                                 blk->index = nodehdr.count - 1;
1943                         blkno = be32_to_cpu(btree[blk->index].before);
1944                         break;
1945                 case XFS_ATTR_LEAF_MAGIC:
1946                 case XFS_ATTR3_LEAF_MAGIC:
1947                         blk->magic = XFS_ATTR_LEAF_MAGIC;
1948                         ASSERT(level == path->active-1);
1949                         blk->index = 0;
1950                         blk->hashval = xfs_attr_leaf_lasthash(blk->bp,
1951                                                               NULL);
1952                         break;
1953                 case XFS_DIR2_LEAFN_MAGIC:
1954                 case XFS_DIR3_LEAFN_MAGIC:
1955                         blk->magic = XFS_DIR2_LEAFN_MAGIC;
1956                         ASSERT(level == path->active-1);
1957                         blk->index = 0;
1958                         blk->hashval = xfs_dir2_leafn_lasthash(blk->bp,
1959                                                                NULL);
1960                         break;
1961                 default:
1962                         ASSERT(0);
1963                         break;
1964                 }
1965         }
1966         *result = 0;
1967         return 0;
1968 }
1969
1970
1971 /*========================================================================
1972  * Utility routines.
1973  *========================================================================*/
1974
1975 /*
1976  * Implement a simple hash on a character string.
1977  * Rotate the hash value by 7 bits, then XOR each character in.
1978  * This is implemented with some source-level loop unrolling.
1979  */
1980 xfs_dahash_t
1981 xfs_da_hashname(const __uint8_t *name, int namelen)
1982 {
1983         xfs_dahash_t hash;
1984
1985         /*
1986          * Do four characters at a time as long as we can.
1987          */
1988         for (hash = 0; namelen >= 4; namelen -= 4, name += 4)
1989                 hash = (name[0] << 21) ^ (name[1] << 14) ^ (name[2] << 7) ^
1990                        (name[3] << 0) ^ rol32(hash, 7 * 4);
1991
1992         /*
1993          * Now do the rest of the characters.
1994          */
1995         switch (namelen) {
1996         case 3:
1997                 return (name[0] << 14) ^ (name[1] << 7) ^ (name[2] << 0) ^
1998                        rol32(hash, 7 * 3);
1999         case 2:
2000                 return (name[0] << 7) ^ (name[1] << 0) ^ rol32(hash, 7 * 2);
2001         case 1:
2002                 return (name[0] << 0) ^ rol32(hash, 7 * 1);
2003         default: /* case 0: */
2004                 return hash;
2005         }
2006 }
2007
2008 enum xfs_dacmp
2009 xfs_da_compname(
2010         struct xfs_da_args *args,
2011         const unsigned char *name,
2012         int             len)
2013 {
2014         return (args->namelen == len && memcmp(args->name, name, len) == 0) ?
2015                                         XFS_CMP_EXACT : XFS_CMP_DIFFERENT;
2016 }
2017
2018 static xfs_dahash_t
2019 xfs_default_hashname(
2020         struct xfs_name *name)
2021 {
2022         return xfs_da_hashname(name->name, name->len);
2023 }
2024
2025 const struct xfs_nameops xfs_default_nameops = {
2026         .hashname       = xfs_default_hashname,
2027         .compname       = xfs_da_compname
2028 };
2029
2030 int
2031 xfs_da_grow_inode_int(
2032         struct xfs_da_args      *args,
2033         xfs_fileoff_t           *bno,
2034         int                     count)
2035 {
2036         struct xfs_trans        *tp = args->trans;
2037         struct xfs_inode        *dp = args->dp;
2038         int                     w = args->whichfork;
2039         xfs_drfsbno_t           nblks = dp->i_d.di_nblocks;
2040         struct xfs_bmbt_irec    map, *mapp;
2041         int                     nmap, error, got, i, mapi;
2042
2043         /*
2044          * Find a spot in the file space to put the new block.
2045          */
2046         error = xfs_bmap_first_unused(tp, dp, count, bno, w);
2047         if (error)
2048                 return error;
2049
2050         /*
2051          * Try mapping it in one filesystem block.
2052          */
2053         nmap = 1;
2054         ASSERT(args->firstblock != NULL);
2055         error = xfs_bmapi_write(tp, dp, *bno, count,
2056                         xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA|XFS_BMAPI_CONTIG,
2057                         args->firstblock, args->total, &map, &nmap,
2058                         args->flist);
2059         if (error)
2060                 return error;
2061
2062         ASSERT(nmap <= 1);
2063         if (nmap == 1) {
2064                 mapp = &map;
2065                 mapi = 1;
2066         } else if (nmap == 0 && count > 1) {
2067                 xfs_fileoff_t           b;
2068                 int                     c;
2069
2070                 /*
2071                  * If we didn't get it and the block might work if fragmented,
2072                  * try without the CONTIG flag.  Loop until we get it all.
2073                  */
2074                 mapp = kmem_alloc(sizeof(*mapp) * count, KM_SLEEP);
2075                 for (b = *bno, mapi = 0; b < *bno + count; ) {
2076                         nmap = MIN(XFS_BMAP_MAX_NMAP, count);
2077                         c = (int)(*bno + count - b);
2078                         error = xfs_bmapi_write(tp, dp, b, c,
2079                                         xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA,
2080                                         args->firstblock, args->total,
2081                                         &mapp[mapi], &nmap, args->flist);
2082                         if (error)
2083                                 goto out_free_map;
2084                         if (nmap < 1)
2085                                 break;
2086                         mapi += nmap;
2087                         b = mapp[mapi - 1].br_startoff +
2088                             mapp[mapi - 1].br_blockcount;
2089                 }
2090         } else {
2091                 mapi = 0;
2092                 mapp = NULL;
2093         }
2094
2095         /*
2096          * Count the blocks we got, make sure it matches the total.
2097          */
2098         for (i = 0, got = 0; i < mapi; i++)
2099                 got += mapp[i].br_blockcount;
2100         if (got != count || mapp[0].br_startoff != *bno ||
2101             mapp[mapi - 1].br_startoff + mapp[mapi - 1].br_blockcount !=
2102             *bno + count) {
2103                 error = XFS_ERROR(ENOSPC);
2104                 goto out_free_map;
2105         }
2106
2107         /* account for newly allocated blocks in reserved blocks total */
2108         args->total -= dp->i_d.di_nblocks - nblks;
2109
2110 out_free_map:
2111         if (mapp != &map)
2112                 kmem_free(mapp);
2113         return error;
2114 }
2115
2116 /*
2117  * Add a block to the btree ahead of the file.
2118  * Return the new block number to the caller.
2119  */
2120 int
2121 xfs_da_grow_inode(
2122         struct xfs_da_args      *args,
2123         xfs_dablk_t             *new_blkno)
2124 {
2125         xfs_fileoff_t           bno;
2126         int                     count;
2127         int                     error;
2128
2129         trace_xfs_da_grow_inode(args);
2130
2131         if (args->whichfork == XFS_DATA_FORK) {
2132                 bno = args->dp->i_mount->m_dirleafblk;
2133                 count = args->dp->i_mount->m_dirblkfsbs;
2134         } else {
2135                 bno = 0;
2136                 count = 1;
2137         }
2138
2139         error = xfs_da_grow_inode_int(args, &bno, count);
2140         if (!error)
2141                 *new_blkno = (xfs_dablk_t)bno;
2142         return error;
2143 }
2144
2145 /*
2146  * Ick.  We need to always be able to remove a btree block, even
2147  * if there's no space reservation because the filesystem is full.
2148  * This is called if xfs_bunmapi on a btree block fails due to ENOSPC.
2149  * It swaps the target block with the last block in the file.  The
2150  * last block in the file can always be removed since it can't cause
2151  * a bmap btree split to do that.
2152  */
2153 STATIC int
2154 xfs_da3_swap_lastblock(
2155         struct xfs_da_args      *args,
2156         xfs_dablk_t             *dead_blknop,
2157         struct xfs_buf          **dead_bufp)
2158 {
2159         struct xfs_da_blkinfo   *dead_info;
2160         struct xfs_da_blkinfo   *sib_info;
2161         struct xfs_da_intnode   *par_node;
2162         struct xfs_da_intnode   *dead_node;
2163         struct xfs_dir2_leaf    *dead_leaf2;
2164         struct xfs_da_node_entry *btree;
2165         struct xfs_da3_icnode_hdr par_hdr;
2166         struct xfs_inode        *ip;
2167         struct xfs_trans        *tp;
2168         struct xfs_mount        *mp;
2169         struct xfs_buf          *dead_buf;
2170         struct xfs_buf          *last_buf;
2171         struct xfs_buf          *sib_buf;
2172         struct xfs_buf          *par_buf;
2173         xfs_dahash_t            dead_hash;
2174         xfs_fileoff_t           lastoff;
2175         xfs_dablk_t             dead_blkno;
2176         xfs_dablk_t             last_blkno;
2177         xfs_dablk_t             sib_blkno;
2178         xfs_dablk_t             par_blkno;
2179         int                     error;
2180         int                     w;
2181         int                     entno;
2182         int                     level;
2183         int                     dead_level;
2184
2185         trace_xfs_da_swap_lastblock(args);
2186
2187         dead_buf = *dead_bufp;
2188         dead_blkno = *dead_blknop;
2189         tp = args->trans;
2190         ip = args->dp;
2191         w = args->whichfork;
2192         ASSERT(w == XFS_DATA_FORK);
2193         mp = ip->i_mount;
2194         lastoff = mp->m_dirfreeblk;
2195         error = xfs_bmap_last_before(tp, ip, &lastoff, w);
2196         if (error)
2197                 return error;
2198         if (unlikely(lastoff == 0)) {
2199                 XFS_ERROR_REPORT("xfs_da_swap_lastblock(1)", XFS_ERRLEVEL_LOW,
2200                                  mp);
2201                 return XFS_ERROR(EFSCORRUPTED);
2202         }
2203         /*
2204          * Read the last block in the btree space.
2205          */
2206         last_blkno = (xfs_dablk_t)lastoff - mp->m_dirblkfsbs;
2207         error = xfs_da3_node_read(tp, ip, last_blkno, -1, &last_buf, w);
2208         if (error)
2209                 return error;
2210         /*
2211          * Copy the last block into the dead buffer and log it.
2212          */
2213         memcpy(dead_buf->b_addr, last_buf->b_addr, mp->m_dirblksize);
2214         xfs_trans_log_buf(tp, dead_buf, 0, mp->m_dirblksize - 1);
2215         dead_info = dead_buf->b_addr;
2216         /*
2217          * Get values from the moved block.
2218          */
2219         if (dead_info->magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
2220             dead_info->magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) {
2221                 struct xfs_dir3_icleaf_hdr leafhdr;
2222                 struct xfs_dir2_leaf_entry *ents;
2223
2224                 dead_leaf2 = (xfs_dir2_leaf_t *)dead_info;
2225                 xfs_dir3_leaf_hdr_from_disk(&leafhdr, dead_leaf2);
2226                 ents = xfs_dir3_leaf_ents_p(dead_leaf2);
2227                 dead_level = 0;
2228                 dead_hash = be32_to_cpu(ents[leafhdr.count - 1].hashval);
2229         } else {
2230                 struct xfs_da3_icnode_hdr deadhdr;
2231
2232                 dead_node = (xfs_da_intnode_t *)dead_info;
2233                 xfs_da3_node_hdr_from_disk(&deadhdr, dead_node);
2234                 btree = xfs_da3_node_tree_p(dead_node);
2235                 dead_level = deadhdr.level;
2236                 dead_hash = be32_to_cpu(btree[deadhdr.count - 1].hashval);
2237         }
2238         sib_buf = par_buf = NULL;
2239         /*
2240          * If the moved block has a left sibling, fix up the pointers.
2241          */
2242         if ((sib_blkno = be32_to_cpu(dead_info->back))) {
2243                 error = xfs_da3_node_read(tp, ip, sib_blkno, -1, &sib_buf, w);
2244                 if (error)
2245                         goto done;
2246                 sib_info = sib_buf->b_addr;
2247                 if (unlikely(
2248                     be32_to_cpu(sib_info->forw) != last_blkno ||
2249                     sib_info->magic != dead_info->magic)) {
2250                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(2)",
2251                                          XFS_ERRLEVEL_LOW, mp);
2252                         error = XFS_ERROR(EFSCORRUPTED);
2253                         goto done;
2254                 }
2255                 sib_info->forw = cpu_to_be32(dead_blkno);
2256                 xfs_trans_log_buf(tp, sib_buf,
2257                         XFS_DA_LOGRANGE(sib_info, &sib_info->forw,
2258                                         sizeof(sib_info->forw)));
2259                 sib_buf = NULL;
2260         }
2261         /*
2262          * If the moved block has a right sibling, fix up the pointers.
2263          */
2264         if ((sib_blkno = be32_to_cpu(dead_info->forw))) {
2265                 error = xfs_da3_node_read(tp, ip, sib_blkno, -1, &sib_buf, w);
2266                 if (error)
2267                         goto done;
2268                 sib_info = sib_buf->b_addr;
2269                 if (unlikely(
2270                        be32_to_cpu(sib_info->back) != last_blkno ||
2271                        sib_info->magic != dead_info->magic)) {
2272                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(3)",
2273                                          XFS_ERRLEVEL_LOW, mp);
2274                         error = XFS_ERROR(EFSCORRUPTED);
2275                         goto done;
2276                 }
2277                 sib_info->back = cpu_to_be32(dead_blkno);
2278                 xfs_trans_log_buf(tp, sib_buf,
2279                         XFS_DA_LOGRANGE(sib_info, &sib_info->back,
2280                                         sizeof(sib_info->back)));
2281                 sib_buf = NULL;
2282         }
2283         par_blkno = mp->m_dirleafblk;
2284         level = -1;
2285         /*
2286          * Walk down the tree looking for the parent of the moved block.
2287          */
2288         for (;;) {
2289                 error = xfs_da3_node_read(tp, ip, par_blkno, -1, &par_buf, w);
2290                 if (error)
2291                         goto done;
2292                 par_node = par_buf->b_addr;
2293                 xfs_da3_node_hdr_from_disk(&par_hdr, par_node);
2294                 if (level >= 0 && level != par_hdr.level + 1) {
2295                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(4)",
2296                                          XFS_ERRLEVEL_LOW, mp);
2297                         error = XFS_ERROR(EFSCORRUPTED);
2298                         goto done;
2299                 }
2300                 level = par_hdr.level;
2301                 btree = xfs_da3_node_tree_p(par_node);
2302                 for (entno = 0;
2303                      entno < par_hdr.count &&
2304                      be32_to_cpu(btree[entno].hashval) < dead_hash;
2305                      entno++)
2306                         continue;
2307                 if (entno == par_hdr.count) {
2308                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(5)",
2309                                          XFS_ERRLEVEL_LOW, mp);
2310                         error = XFS_ERROR(EFSCORRUPTED);
2311                         goto done;
2312                 }
2313                 par_blkno = be32_to_cpu(btree[entno].before);
2314                 if (level == dead_level + 1)
2315                         break;
2316                 xfs_trans_brelse(tp, par_buf);
2317                 par_buf = NULL;
2318         }
2319         /*
2320          * We're in the right parent block.
2321          * Look for the right entry.
2322          */
2323         for (;;) {
2324                 for (;
2325                      entno < par_hdr.count &&
2326                      be32_to_cpu(btree[entno].before) != last_blkno;
2327                      entno++)
2328                         continue;
2329                 if (entno < par_hdr.count)
2330                         break;
2331                 par_blkno = par_hdr.forw;
2332                 xfs_trans_brelse(tp, par_buf);
2333                 par_buf = NULL;
2334                 if (unlikely(par_blkno == 0)) {
2335                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(6)",
2336                                          XFS_ERRLEVEL_LOW, mp);
2337                         error = XFS_ERROR(EFSCORRUPTED);
2338                         goto done;
2339                 }
2340                 error = xfs_da3_node_read(tp, ip, par_blkno, -1, &par_buf, w);
2341                 if (error)
2342                         goto done;
2343                 par_node = par_buf->b_addr;
2344                 xfs_da3_node_hdr_from_disk(&par_hdr, par_node);
2345                 if (par_hdr.level != level) {
2346                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(7)",
2347                                          XFS_ERRLEVEL_LOW, mp);
2348                         error = XFS_ERROR(EFSCORRUPTED);
2349                         goto done;
2350                 }
2351                 btree = xfs_da3_node_tree_p(par_node);
2352                 entno = 0;
2353         }
2354         /*
2355          * Update the parent entry pointing to the moved block.
2356          */
2357         btree[entno].before = cpu_to_be32(dead_blkno);
2358         xfs_trans_log_buf(tp, par_buf,
2359                 XFS_DA_LOGRANGE(par_node, &btree[entno].before,
2360                                 sizeof(btree[entno].before)));
2361         *dead_blknop = last_blkno;
2362         *dead_bufp = last_buf;
2363         return 0;
2364 done:
2365         if (par_buf)
2366                 xfs_trans_brelse(tp, par_buf);
2367         if (sib_buf)
2368                 xfs_trans_brelse(tp, sib_buf);
2369         xfs_trans_brelse(tp, last_buf);
2370         return error;
2371 }
2372
2373 /*
2374  * Remove a btree block from a directory or attribute.
2375  */
2376 int
2377 xfs_da_shrink_inode(
2378         xfs_da_args_t   *args,
2379         xfs_dablk_t     dead_blkno,
2380         struct xfs_buf  *dead_buf)
2381 {
2382         xfs_inode_t *dp;
2383         int done, error, w, count;
2384         xfs_trans_t *tp;
2385         xfs_mount_t *mp;
2386
2387         trace_xfs_da_shrink_inode(args);
2388
2389         dp = args->dp;
2390         w = args->whichfork;
2391         tp = args->trans;
2392         mp = dp->i_mount;
2393         if (w == XFS_DATA_FORK)
2394                 count = mp->m_dirblkfsbs;
2395         else
2396                 count = 1;
2397         for (;;) {
2398                 /*
2399                  * Remove extents.  If we get ENOSPC for a dir we have to move
2400                  * the last block to the place we want to kill.
2401                  */
2402                 error = xfs_bunmapi(tp, dp, dead_blkno, count,
2403                                     xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA,
2404                                     0, args->firstblock, args->flist, &done);
2405                 if (error == ENOSPC) {
2406                         if (w != XFS_DATA_FORK)
2407                                 break;
2408                         error = xfs_da3_swap_lastblock(args, &dead_blkno,
2409                                                       &dead_buf);
2410                         if (error)
2411                                 break;
2412                 } else {
2413                         break;
2414                 }
2415         }
2416         xfs_trans_binval(tp, dead_buf);
2417         return error;
2418 }
2419
2420 /*
2421  * See if the mapping(s) for this btree block are valid, i.e.
2422  * don't contain holes, are logically contiguous, and cover the whole range.
2423  */
2424 STATIC int
2425 xfs_da_map_covers_blocks(
2426         int             nmap,
2427         xfs_bmbt_irec_t *mapp,
2428         xfs_dablk_t     bno,
2429         int             count)
2430 {
2431         int             i;
2432         xfs_fileoff_t   off;
2433
2434         for (i = 0, off = bno; i < nmap; i++) {
2435                 if (mapp[i].br_startblock == HOLESTARTBLOCK ||
2436                     mapp[i].br_startblock == DELAYSTARTBLOCK) {
2437                         return 0;
2438                 }
2439                 if (off != mapp[i].br_startoff) {
2440                         return 0;
2441                 }
2442                 off += mapp[i].br_blockcount;
2443         }
2444         return off == bno + count;
2445 }
2446
2447 /*
2448  * Convert a struct xfs_bmbt_irec to a struct xfs_buf_map.
2449  *
2450  * For the single map case, it is assumed that the caller has provided a pointer
2451  * to a valid xfs_buf_map.  For the multiple map case, this function will
2452  * allocate the xfs_buf_map to hold all the maps and replace the caller's single
2453  * map pointer with the allocated map.
2454  */
2455 static int
2456 xfs_buf_map_from_irec(
2457         struct xfs_mount        *mp,
2458         struct xfs_buf_map      **mapp,
2459         int                     *nmaps,
2460         struct xfs_bmbt_irec    *irecs,
2461         int                     nirecs)
2462 {
2463         struct xfs_buf_map      *map;
2464         int                     i;
2465
2466         ASSERT(*nmaps == 1);
2467         ASSERT(nirecs >= 1);
2468
2469         if (nirecs > 1) {
2470                 map = kmem_zalloc(nirecs * sizeof(struct xfs_buf_map),
2471                                   KM_SLEEP | KM_NOFS);
2472                 if (!map)
2473                         return ENOMEM;
2474                 *mapp = map;
2475         }
2476
2477         *nmaps = nirecs;
2478         map = *mapp;
2479         for (i = 0; i < *nmaps; i++) {
2480                 ASSERT(irecs[i].br_startblock != DELAYSTARTBLOCK &&
2481                        irecs[i].br_startblock != HOLESTARTBLOCK);
2482                 map[i].bm_bn = XFS_FSB_TO_DADDR(mp, irecs[i].br_startblock);
2483                 map[i].bm_len = XFS_FSB_TO_BB(mp, irecs[i].br_blockcount);
2484         }
2485         return 0;
2486 }
2487
2488 /*
2489  * Map the block we are given ready for reading. There are three possible return
2490  * values:
2491  *      -1 - will be returned if we land in a hole and mappedbno == -2 so the
2492  *           caller knows not to execute a subsequent read.
2493  *       0 - if we mapped the block successfully
2494  *      >0 - positive error number if there was an error.
2495  */
2496 static int
2497 xfs_dabuf_map(
2498         struct xfs_trans        *trans,
2499         struct xfs_inode        *dp,
2500         xfs_dablk_t             bno,
2501         xfs_daddr_t             mappedbno,
2502         int                     whichfork,
2503         struct xfs_buf_map      **map,
2504         int                     *nmaps)
2505 {
2506         struct xfs_mount        *mp = dp->i_mount;
2507         int                     nfsb;
2508         int                     error = 0;
2509         struct xfs_bmbt_irec    irec;
2510         struct xfs_bmbt_irec    *irecs = &irec;
2511         int                     nirecs;
2512
2513         ASSERT(map && *map);
2514         ASSERT(*nmaps == 1);
2515
2516         nfsb = (whichfork == XFS_DATA_FORK) ? mp->m_dirblkfsbs : 1;
2517
2518         /*
2519          * Caller doesn't have a mapping.  -2 means don't complain
2520          * if we land in a hole.
2521          */
2522         if (mappedbno == -1 || mappedbno == -2) {
2523                 /*
2524                  * Optimize the one-block case.
2525                  */
2526                 if (nfsb != 1)
2527                         irecs = kmem_zalloc(sizeof(irec) * nfsb,
2528                                             KM_SLEEP | KM_NOFS);
2529
2530                 nirecs = nfsb;
2531                 error = xfs_bmapi_read(dp, (xfs_fileoff_t)bno, nfsb, irecs,
2532                                        &nirecs, xfs_bmapi_aflag(whichfork));
2533                 if (error)
2534                         goto out;
2535         } else {
2536                 irecs->br_startblock = XFS_DADDR_TO_FSB(mp, mappedbno);
2537                 irecs->br_startoff = (xfs_fileoff_t)bno;
2538                 irecs->br_blockcount = nfsb;
2539                 irecs->br_state = 0;
2540                 nirecs = 1;
2541         }
2542
2543         if (!xfs_da_map_covers_blocks(nirecs, irecs, bno, nfsb)) {
2544                 error = mappedbno == -2 ? -1 : XFS_ERROR(EFSCORRUPTED);
2545                 if (unlikely(error == EFSCORRUPTED)) {
2546                         if (xfs_error_level >= XFS_ERRLEVEL_LOW) {
2547                                 int i;
2548                                 xfs_alert(mp, "%s: bno %lld dir: inode %lld",
2549                                         __func__, (long long)bno,
2550                                         (long long)dp->i_ino);
2551                                 for (i = 0; i < *nmaps; i++) {
2552                                         xfs_alert(mp,
2553 "[%02d] br_startoff %lld br_startblock %lld br_blockcount %lld br_state %d",
2554                                                 i,
2555                                                 (long long)irecs[i].br_startoff,
2556                                                 (long long)irecs[i].br_startblock,
2557                                                 (long long)irecs[i].br_blockcount,
2558                                                 irecs[i].br_state);
2559                                 }
2560                         }
2561                         XFS_ERROR_REPORT("xfs_da_do_buf(1)",
2562                                          XFS_ERRLEVEL_LOW, mp);
2563                 }
2564                 goto out;
2565         }
2566         error = xfs_buf_map_from_irec(mp, map, nmaps, irecs, nirecs);
2567 out:
2568         if (irecs != &irec)
2569                 kmem_free(irecs);
2570         return error;
2571 }
2572
2573 /*
2574  * Get a buffer for the dir/attr block.
2575  */
2576 int
2577 xfs_da_get_buf(
2578         struct xfs_trans        *trans,
2579         struct xfs_inode        *dp,
2580         xfs_dablk_t             bno,
2581         xfs_daddr_t             mappedbno,
2582         struct xfs_buf          **bpp,
2583         int                     whichfork)
2584 {
2585         struct xfs_buf          *bp;
2586         struct xfs_buf_map      map;
2587         struct xfs_buf_map      *mapp;
2588         int                     nmap;
2589         int                     error;
2590
2591         *bpp = NULL;
2592         mapp = &map;
2593         nmap = 1;
2594         error = xfs_dabuf_map(trans, dp, bno, mappedbno, whichfork,
2595                                 &mapp, &nmap);
2596         if (error) {
2597                 /* mapping a hole is not an error, but we don't continue */
2598                 if (error == -1)
2599                         error = 0;
2600                 goto out_free;
2601         }
2602
2603         bp = xfs_trans_get_buf_map(trans, dp->i_mount->m_ddev_targp,
2604                                     mapp, nmap, 0);
2605         error = bp ? bp->b_error : XFS_ERROR(EIO);
2606         if (error) {
2607                 xfs_trans_brelse(trans, bp);
2608                 goto out_free;
2609         }
2610
2611         *bpp = bp;
2612
2613 out_free:
2614         if (mapp != &map)
2615                 kmem_free(mapp);
2616
2617         return error;
2618 }
2619
2620 /*
2621  * Get a buffer for the dir/attr block, fill in the contents.
2622  */
2623 int
2624 xfs_da_read_buf(
2625         struct xfs_trans        *trans,
2626         struct xfs_inode        *dp,
2627         xfs_dablk_t             bno,
2628         xfs_daddr_t             mappedbno,
2629         struct xfs_buf          **bpp,
2630         int                     whichfork,
2631         const struct xfs_buf_ops *ops)
2632 {
2633         struct xfs_buf          *bp;
2634         struct xfs_buf_map      map;
2635         struct xfs_buf_map      *mapp;
2636         int                     nmap;
2637         int                     error;
2638
2639         *bpp = NULL;
2640         mapp = &map;
2641         nmap = 1;
2642         error = xfs_dabuf_map(trans, dp, bno, mappedbno, whichfork,
2643                                 &mapp, &nmap);
2644         if (error) {
2645                 /* mapping a hole is not an error, but we don't continue */
2646                 if (error == -1)
2647                         error = 0;
2648                 goto out_free;
2649         }
2650
2651         error = xfs_trans_read_buf_map(dp->i_mount, trans,
2652                                         dp->i_mount->m_ddev_targp,
2653                                         mapp, nmap, 0, &bp, ops);
2654         if (error)
2655                 goto out_free;
2656
2657         if (whichfork == XFS_ATTR_FORK)
2658                 xfs_buf_set_ref(bp, XFS_ATTR_BTREE_REF);
2659         else
2660                 xfs_buf_set_ref(bp, XFS_DIR_BTREE_REF);
2661
2662         /*
2663          * This verification code will be moved to a CRC verification callback
2664          * function so just leave it here unchanged until then.
2665          */
2666         {
2667                 xfs_dir2_data_hdr_t     *hdr = bp->b_addr;
2668                 xfs_dir2_free_t         *free = bp->b_addr;
2669                 xfs_da_blkinfo_t        *info = bp->b_addr;
2670                 uint                    magic, magic1;
2671                 struct xfs_mount        *mp = dp->i_mount;
2672
2673                 magic = be16_to_cpu(info->magic);
2674                 magic1 = be32_to_cpu(hdr->magic);
2675                 if (unlikely(
2676                     XFS_TEST_ERROR((magic != XFS_DA_NODE_MAGIC) &&
2677                                    (magic != XFS_DA3_NODE_MAGIC) &&
2678                                    (magic != XFS_ATTR_LEAF_MAGIC) &&
2679                                    (magic != XFS_ATTR3_LEAF_MAGIC) &&
2680                                    (magic != XFS_DIR2_LEAF1_MAGIC) &&
2681                                    (magic != XFS_DIR3_LEAF1_MAGIC) &&
2682                                    (magic != XFS_DIR2_LEAFN_MAGIC) &&
2683                                    (magic != XFS_DIR3_LEAFN_MAGIC) &&
2684                                    (magic1 != XFS_DIR2_BLOCK_MAGIC) &&
2685                                    (magic1 != XFS_DIR3_BLOCK_MAGIC) &&
2686                                    (magic1 != XFS_DIR2_DATA_MAGIC) &&
2687                                    (magic1 != XFS_DIR3_DATA_MAGIC) &&
2688                                    (free->hdr.magic !=
2689                                         cpu_to_be32(XFS_DIR2_FREE_MAGIC)) &&
2690                                    (free->hdr.magic !=
2691                                         cpu_to_be32(XFS_DIR3_FREE_MAGIC)),
2692                                 mp, XFS_ERRTAG_DA_READ_BUF,
2693                                 XFS_RANDOM_DA_READ_BUF))) {
2694                         trace_xfs_da_btree_corrupt(bp, _RET_IP_);
2695                         XFS_CORRUPTION_ERROR("xfs_da_do_buf(2)",
2696                                              XFS_ERRLEVEL_LOW, mp, info);
2697                         error = XFS_ERROR(EFSCORRUPTED);
2698                         xfs_trans_brelse(trans, bp);
2699                         goto out_free;
2700                 }
2701         }
2702         *bpp = bp;
2703 out_free:
2704         if (mapp != &map)
2705                 kmem_free(mapp);
2706
2707         return error;
2708 }
2709
2710 /*
2711  * Readahead the dir/attr block.
2712  */
2713 xfs_daddr_t
2714 xfs_da_reada_buf(
2715         struct xfs_trans        *trans,
2716         struct xfs_inode        *dp,
2717         xfs_dablk_t             bno,
2718         xfs_daddr_t             mappedbno,
2719         int                     whichfork,
2720         const struct xfs_buf_ops *ops)
2721 {
2722         struct xfs_buf_map      map;
2723         struct xfs_buf_map      *mapp;
2724         int                     nmap;
2725         int                     error;
2726
2727         mapp = &map;
2728         nmap = 1;
2729         error = xfs_dabuf_map(trans, dp, bno, mappedbno, whichfork,
2730                                 &mapp, &nmap);
2731         if (error) {
2732                 /* mapping a hole is not an error, but we don't continue */
2733                 if (error == -1)
2734                         error = 0;
2735                 goto out_free;
2736         }
2737
2738         mappedbno = mapp[0].bm_bn;
2739         xfs_buf_readahead_map(dp->i_mount->m_ddev_targp, mapp, nmap, ops);
2740
2741 out_free:
2742         if (mapp != &map)
2743                 kmem_free(mapp);
2744
2745         if (error)
2746                 return -1;
2747         return mappedbno;
2748 }