sys/vfs/hammer/hammer_rebalance.c

   1 /*
   2  * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include "hammer.h"
  36
  37 static int rebalance_node(struct hammer_ioc_rebalance *rebal,
  38                         hammer_cursor_t cursor);
  39 static void rebalance_closeout(hammer_node_lock_t base_item, int base_count,
  40                         hammer_btree_elm_t elm);
  41 static void rebalance_parent_ptrs(hammer_node_lock_t base_item, int index,
  42                         hammer_node_lock_t item, hammer_node_lock_t chld_item);
  43
  44 /*
  45  * Iterate through the specified range of object ids and rebalance B-Tree
  46  * leaf and internal nodes we encounter.  A forwards iteration is used.
  47  *
  48  * All leafs are at the same depth.  We use the b-tree scan code loosely
  49  * to position ourselves and create degenerate cases to skip indices
  50  * that we have rebalanced in bulk.
  51  */
  52
  53 int
  54 hammer_ioc_rebalance(hammer_transaction_t trans, hammer_inode_t ip,
  55                  struct hammer_ioc_rebalance *rebal)
  56 {
  57         struct hammer_cursor cursor;
  58         hammer_btree_leaf_elm_t elm;
  59         int error;
  60         int seq;
  61
  62         if ((rebal->key_beg.localization | rebal->key_end.localization) &
  63             HAMMER_LOCALIZE_PSEUDOFS_MASK) {
  64                 return(EINVAL);
  65         }
  66         if (rebal->key_beg.localization > rebal->key_end.localization)
  67                 return(EINVAL);
  68         if (rebal->key_beg.localization == rebal->key_end.localization) {
  69                 if (rebal->key_beg.obj_id > rebal->key_end.obj_id)
  70                         return(EINVAL);
  71                 /* key-space limitations - no check needed */
  72         }
  73         if (rebal->saturation < HAMMER_BTREE_INT_ELMS / 2)
  74                 rebal->saturation = HAMMER_BTREE_INT_ELMS / 2;
  75         if (rebal->saturation > HAMMER_BTREE_INT_ELMS)
  76                 rebal->saturation = HAMMER_BTREE_INT_ELMS;
  77
  78         rebal->key_cur = rebal->key_beg;
  79         rebal->key_cur.localization &= HAMMER_LOCALIZE_MASK;
  80         rebal->key_cur.localization += ip->obj_localization;
  81
  82         seq = trans->hmp->flusher.act;
  83
  84         /*
  85          * Scan forwards.  Retries typically occur if a deadlock is detected.
  86          */
  87 retry:
  88         error = hammer_init_cursor(trans, &cursor, NULL, NULL);
  89         if (error) {
  90                 hammer_done_cursor(&cursor);
  91                 goto failed;
  92         }
  93         cursor.key_beg = rebal->key_cur;
  94         cursor.key_end = rebal->key_end;
  95         cursor.key_end.localization &= HAMMER_LOCALIZE_MASK;
  96         cursor.key_end.localization += ip->obj_localization;
  97         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE;
  98         cursor.flags |= HAMMER_CURSOR_BACKEND;
  99
 100         /*
 101          * Cause internal nodes to be returned on the way up.  Internal nodes
 102          * are not returned on the way down so we can create a degenerate
 103          * case to handle internal nodes as a trailing function of their
 104          * sub-trees.
 105          *
 106          * Note that by not setting INSERTING or PRUNING no boundary
 107          * corrections will be made and a sync lock is not needed for the
 108          * B-Tree scan itself.
 109          */
 110         cursor.flags |= HAMMER_CURSOR_REBLOCKING;
 111
 112         error = hammer_btree_first(&cursor);
 113
 114         while (error == 0) {
 115                 /*
 116                  * We only care about internal nodes visited for the last
 117                  * time on the way up... that is, a trailing scan of the
 118                  * internal node after all of its children have been recursed
 119                  * through.
 120                  */
 121                 if (cursor.node->ondisk->type == HAMMER_BTREE_TYPE_INTERNAL) {
 122                         /*
 123                          * Leave cursor.index alone, we want to recurse
 124                          * through all children of the internal node before
 125                          * visiting it.
 126                          *
 127                          * Process the internal node on the way up after
 128                          * the last child's sub-tree has been balanced.
 129                          */
 130                         if (cursor.index == cursor.node->ondisk->count - 1) {
 131                                 hammer_sync_lock_sh(trans);
 132                                 error = rebalance_node(rebal, &cursor);
 133                                 hammer_sync_unlock(trans);
 134                         }
 135                 } else {
 136                         /*
 137                          * We don't need to iterate through all the leaf
 138                          * elements, we only care about the parent (internal)
 139                          * node.
 140                          */
 141                         cursor.index = cursor.node->ondisk->count - 1;
 142                 }
 143                 if (error)
 144                         break;
 145
 146                 /*
 147                  * Update returned scan position and do a flush if
 148                  * necessary.
 149                  */
 150                 elm = &cursor.node->ondisk->elms[cursor.index].leaf;
 151                 rebal->key_cur = elm->base;
 152                 ++rebal->stat_ncount;
 153
 154                 while (hammer_flusher_meta_halflimit(trans->hmp) ||
 155                        hammer_flusher_undo_exhausted(trans, 2)) {
 156                         hammer_unlock_cursor(&cursor);
 157                         hammer_flusher_wait(trans->hmp, seq);
 158                         hammer_lock_cursor(&cursor);
 159                         seq = hammer_flusher_async_one(trans->hmp);
 160                 }
 161
 162                 /*
 163                  * Iterate, stop if a signal was received.
 164                  */
 165                 if ((error = hammer_signal_check(trans->hmp)) != 0)
 166                         break;
 167                 error = hammer_btree_iterate(&cursor);
 168         }
 169         if (error == ENOENT)
 170                 error = 0;
 171         hammer_done_cursor(&cursor);
 172         if (error == EDEADLK) {
 173                 ++rebal->stat_collisions;
 174                 goto retry;
 175         }
 176         if (error == EINTR) {
 177                 rebal->head.flags |= HAMMER_IOC_HEAD_INTR;
 178                 error = 0;
 179         }
 180 failed:
 181         rebal->key_cur.localization &= HAMMER_LOCALIZE_MASK;
 182         return(error);
 183 }
 184
 185 /*
 186  * Rebalance an internal node, called via a trailing upward recursion.
 187  * All the children have already been individually rebalanced.
 188  *
 189  * To rebalance we scan the elements in the children and pack them,
 190  * so we actually need to lock the children and the children's children.
 191  *
 192  *      INTERNAL_NODE
 193  *      / / | | | \ \
 194  *     C C  C C C  C C  children (first level) (internal or leaf nodes)
 195  *                      children's elements (second level)
 196  *
 197  *      <<<----------   pack children's elements, possibly remove excess
 198  *                      children after packing.
 199  *
 200  * NOTE: The mirror_tids, parent pointers, and child pointers must be updated.
 201  *       Any live tracked B-Tree nodes must be updated (we worm out of that
 202  *       by not allowing any).  And boundary elements must be preserved.
 203  *
 204  * NOTE: If the children are leaf nodes we may have a degenerate case
 205  *       case where there are no elements in the leafs.
 206  *
 207  * XXX live-tracked
 208  */
 209 static int
 210 rebalance_node(struct hammer_ioc_rebalance *rebal, hammer_cursor_t cursor)
 211 {
 212         struct hammer_node_lock lockroot;
 213         hammer_node_lock_t base_item;
 214         hammer_node_lock_t chld_item;
 215         hammer_node_lock_t item;
 216         hammer_btree_elm_t elm;
 217         hammer_node_t node;
 218         u_int8_t type1;
 219         int base_count;
 220         int root_count;
 221         int avg_elms;
 222         int count;
 223         int error;
 224         int i;
 225         int n;
 226
 227         /*
 228          * Lock the parent node via the cursor, collect and lock our
 229          * children and children's children.
 230          *
 231          * By the way, this is a LOT of locks.
 232          */
 233         hammer_node_lock_init(&lockroot, cursor->node);
 234         error = hammer_cursor_upgrade(cursor);
 235         if (error)
 236                 goto done;
 237         error = hammer_btree_lock_children(cursor, 2, &lockroot);
 238         if (error)
 239                 goto done;
 240
 241         /*
 242          * Make a copy of all the locked on-disk data to simplify the element
 243          * shifting we are going to have to do.  We will modify the copy
 244          * first.
 245          */
 246         hammer_btree_lock_copy(cursor, &lockroot);
 247
 248         /*
 249          * Look at the first child node.
 250          */
 251         if (TAILQ_FIRST(&lockroot.list) == NULL)
 252                 goto done;
 253         type1 = TAILQ_FIRST(&lockroot.list)->node->ondisk->type;
 254
 255         /*
 256          * Figure out the total number of children's children and
 257          * calculate the average number of elements per child.
 258          *
 259          * The minimum avg_elms is 1 when count > 0.  avg_elms * root_elms
 260          * is always greater or equal to count.
 261          *
 262          * If count == 0 we hit a degenerate case which will cause
 263          * avg_elms to also calculate as 0.
 264          */
 265         if (hammer_debug_general & 0x1000)
 266                 kprintf("lockroot %p count %d\n", &lockroot, lockroot.count);
 267         count = 0;
 268         TAILQ_FOREACH(item, &lockroot.list, entry) {
 269                 if (hammer_debug_general & 0x1000)
 270                         kprintf("add count %d\n", item->count);
 271                 count += item->count;
 272                 KKASSERT(item->node->ondisk->type == type1);
 273         }
 274         avg_elms = (count + (lockroot.count - 1)) / lockroot.count;
 275         KKASSERT(avg_elms >= 0);
 276
 277         /*
 278          * If the average number of elements per child is too low then
 279          * calculate the desired number of children (n) such that the
 280          * average number of elements is reasonable.
 281          *
 282          * If the desired number of children is 1 then avg_elms will
 283          * wind up being count, which may still be smaller then saturation
 284          * but that is ok.
 285          */
 286         if (count && avg_elms < rebal->saturation) {
 287                 n = (count + (rebal->saturation - 1)) / rebal->saturation;
 288                 avg_elms = (count + (n - 1)) / n;
 289         }
 290
 291         /*
 292          * Pack the elements in the children.  Elements for each item is
 293          * packed into base_item until avg_elms is reached, then base_item
 294          * iterates.
 295          *
 296          * hammer_cursor_moved_element() is called for each element moved
 297          * to update tracked cursors, including the index beyond the last
 298          * element (at count).
 299          */
 300         base_item = TAILQ_FIRST(&lockroot.list);
 301         base_count = 0;
 302         root_count = 0;
 303
 304         TAILQ_FOREACH(item, &lockroot.list, entry) {
 305                 node = item->node;
 306                 KKASSERT(item->count == node->ondisk->count);
 307                 chld_item = TAILQ_FIRST(&item->list);
 308                 for (i = 0; i < item->count; ++i) {
 309                         /*
 310                          * Closeout.  If the next element is at index 0
 311                          * just use the existing separator in the parent.
 312                          */
 313                         if (base_count == avg_elms) {
 314                                 if (i == 0) {
 315                                         elm = &lockroot.node->ondisk->elms[
 316                                                 item->index];
 317                                 } else {
 318                                         elm = &node->ondisk->elms[i];
 319                                 }
 320                                 rebalance_closeout(base_item, base_count, elm);
 321                                 base_item = TAILQ_NEXT(base_item, entry);
 322                                 KKASSERT(base_item);
 323                                 base_count = 0;
 324                                 ++root_count;
 325                         }
 326
 327                         /*
 328                          * Check degenerate no-work case.  Otherwise pack
 329                          * the element.
 330                          *
 331                          * All changes are made to the copy.
 332                          */
 333                         if (item == base_item && i == base_count) {
 334                                 ++base_count;
 335                                 if (chld_item)
 336                                         chld_item = TAILQ_NEXT(chld_item, entry);
 337                                 continue;
 338                         }
 339
 340                         /*
 341                          * Pack element.
 342                          */
 343                         elm = &base_item->copy->elms[base_count];
 344                         *elm = node->ondisk->elms[i];
 345                         base_item->flags |= HAMMER_NODE_LOCK_UPDATED;
 346
 347                         /*
 348                          * Adjust the mirror_tid of the target.  The parent
 349                          * node (lockroot.node) should already have an
 350                          * aggregate mirror_tid so we do not have to update
 351                          * that.
 352                          *
 353                          * However, it is possible for us to catch a
 354                          * hammer_btree_mirror_propagate() with its pants
 355                          * down.  Update the parent if necessary.
 356                          */
 357                         if (base_item->copy->mirror_tid <
 358                             node->ondisk->mirror_tid) {
 359                                 base_item->copy->mirror_tid =
 360                                         node->ondisk->mirror_tid;
 361                                 if (lockroot.copy->mirror_tid <
 362                                     node->ondisk->mirror_tid) {
 363                                         kprintf("HAMMER: Warning: rebalance "
 364                                                 "caught race against "
 365                                                 "propagate\n");
 366                                         lockroot.copy->mirror_tid =
 367                                                 node->ondisk->mirror_tid;
 368                                         lockroot.flags |=
 369                                                 HAMMER_NODE_LOCK_UPDATED;
 370                                 }
 371                                 base_item->flags |= HAMMER_NODE_LOCK_UPDATED;
 372                         }
 373
 374                         /*
 375                          * We moved elm.  The parent pointers for any
 376                          * children of elm must be repointed.
 377                          */
 378                         if (item != base_item &&
 379                             node->ondisk->type == HAMMER_BTREE_TYPE_INTERNAL) {
 380                                 KKASSERT(chld_item);
 381                                 rebalance_parent_ptrs(base_item, base_count,
 382                                                       item, chld_item);
 383                         }
 384                         hammer_cursor_moved_element(node, base_item->node,
 385                                                     i, base_count);
 386                         ++base_count;
 387                         if (chld_item)
 388                                 chld_item = TAILQ_NEXT(chld_item, entry);
 389                 }
 390
 391                 /*
 392                  * Always call at the end (i == number of elements) in
 393                  * case a cursor is sitting indexed there.
 394                  */
 395                 hammer_cursor_moved_element(node, base_item->node,
 396                                             i, base_count);
 397         }
 398
 399         /*
 400          * Packing complete, close-out base_item using the right-hand
 401          * boundary of the original parent.
 402          *
 403          * If we will be deleting nodes from the root shift the old
 404          * right-hand-boundary to the new ending index.
 405          */
 406         elm = &lockroot.node->ondisk->elms[lockroot.node->ondisk->count];
 407         rebalance_closeout(base_item, base_count, elm);
 408         ++root_count;
 409         if (lockroot.copy->count != root_count) {
 410                 lockroot.copy->count = root_count;
 411                 lockroot.copy->elms[root_count] = *elm;
 412                 lockroot.flags |= HAMMER_NODE_LOCK_UPDATED;
 413         }
 414
 415         /*
 416          * Any extra items beyond base_item are now completely empty and
 417          * can be destroyed.  Queue the destruction up in the copy.  Note
 418          * that none of the destroyed nodes are part of our cursor.
 419          *
 420          * The cursor is locked so it isn't on the tracking list.  It
 421          * should have been pointing at the boundary element (at root_count).
 422          * When deleting elements from the root (which is cursor.node), we
 423          * have to update the cursor.index manually to keep it in bounds.
 424          */
 425         while ((base_item = TAILQ_NEXT(base_item, entry)) != NULL) {
 426                 hammer_cursor_removed_node(base_item->node, lockroot.node,
 427                                            base_count);
 428                 hammer_cursor_deleted_element(lockroot.node, base_count);
 429                 base_item->copy->type = HAMMER_BTREE_TYPE_DELETED;
 430                 base_item->copy->count = 0;
 431                 base_item->flags |= HAMMER_NODE_LOCK_UPDATED;
 432                 if (cursor->index > lockroot.copy->count)
 433                         --cursor->index;
 434                 ++rebal->stat_deletions;
 435         }
 436
 437         /*
 438          * All done, sync the locked child tree to disk.  This will also
 439          * flush and delete deleted nodes.
 440          */
 441         rebal->stat_nrebal += hammer_btree_sync_copy(cursor, &lockroot);
 442 done:
 443         hammer_btree_unlock_children(cursor, &lockroot);
 444         hammer_cursor_downgrade(cursor);
 445         return (error);
 446 }
 447
 448 /*
 449  * Close-out the child base_item.  This node contains base_count
 450  * elements.
 451  *
 452  * If the node is an internal node the right-hand boundary must be
 453  * set to elm.
 454  */
 455 static
 456 void
 457 rebalance_closeout(hammer_node_lock_t base_item, int base_count,
 458                    hammer_btree_elm_t elm)
 459 {
 460         hammer_node_lock_t parent;
 461         hammer_btree_elm_t base_elm;
 462         hammer_btree_elm_t rbound_elm;
 463         u_int8_t save;
 464
 465         /*
 466          * Update the count.  NOTE:  base_count can be 0 for the
 467          * degenerate leaf case.
 468          */
 469         if (hammer_debug_general & 0x1000) {
 470                 kprintf("rebalance_closeout %016llx:",
 471                         (long long)base_item->node->node_offset);
 472         }
 473         if (base_item->copy->count != base_count) {
 474                 base_item->flags |= HAMMER_NODE_LOCK_UPDATED;
 475                 base_item->copy->count = base_count;
 476                 if (hammer_debug_general & 0x1000)
 477                         kprintf(" (count update)");
 478         }
 479
 480         /*
 481          * If we are closing out an internal node we must assign
 482          * a right-hand boundary.  Use the element contents as the
 483          * right-hand boundary.
 484          *
 485          * Internal nodes are required to have at least one child,
 486          * otherwise the left and right boundary would end up being
 487          * the same element.  Only leaf nodes can be empty.
 488          *
 489          * Rebalancing may cut-off an internal node such that the
 490          * new right hand boundary is the next element anyway, but
 491          * we still have to make sure that subtree_offset, btype,
 492          * and mirror_tid are all 0.
 493          */
 494         if (base_item->copy->type == HAMMER_BTREE_TYPE_INTERNAL) {
 495                 KKASSERT(base_count != 0);
 496                 base_elm = &base_item->copy->elms[base_count];
 497
 498                 if (bcmp(base_elm, elm, sizeof(*elm)) != 0 ||
 499                     elm->internal.subtree_offset ||
 500                     elm->internal.mirror_tid ||
 501                     elm->base.btype) {
 502                         *base_elm = *elm;
 503                         base_elm->internal.subtree_offset = 0;
 504                         base_elm->internal.mirror_tid = 0;
 505                         base_elm->base.btype = 0;
 506                         base_item->flags |= HAMMER_NODE_LOCK_UPDATED;
 507                         if (hammer_debug_general & 0x1000)
 508                                 kprintf(" (rhs update)");
 509                 } else {
 510                         if (hammer_debug_general & 0x1000)
 511                                 kprintf(" (rhs same)");
 512                 }
 513         }
 514
 515         /*
 516          * The parent's boundary must be updated.  Be careful to retain
 517          * the btype and non-base internal fields as that information is
 518          * unrelated.
 519          */
 520         parent = base_item->parent;
 521         rbound_elm = &parent->copy->elms[base_item->index + 1];
 522         if (bcmp(&rbound_elm->base, &elm->base, sizeof(elm->base)) != 0) {
 523                 save = rbound_elm->base.btype;
 524                 rbound_elm->base = elm->base;
 525                 rbound_elm->base.btype = save;
 526                 parent->flags |= HAMMER_NODE_LOCK_UPDATED;
 527                 if (hammer_debug_general & 0x1000) {
 528                         kprintf(" (parent bound update %d)",
 529                                 base_item->index + 1);
 530                 }
 531         }
 532         if (hammer_debug_general & 0x1000)
 533                 kprintf("\n");
 534 }
 535
 536 /*
 537  * An element in item has moved to base_item.  We must update the parent
 538  * pointer of the node the element points to (which is chld_item).
 539  */
 540 static
 541 void
 542 rebalance_parent_ptrs(hammer_node_lock_t base_item, int index,
 543                       hammer_node_lock_t item, hammer_node_lock_t chld_item)
 544 {
 545         KKASSERT(chld_item->node->ondisk->parent == item->node->node_offset);
 546         chld_item->copy->parent = base_item->node->node_offset;
 547         chld_item->flags |= HAMMER_NODE_LOCK_UPDATED;
 548         hammer_cursor_parent_changed(chld_item->node,
 549                                      item->node, base_item->node, index);
 550 }