drivers/md/persistent-data/dm-btree-remove.c

   1 /*
   2  * Copyright (C) 2011 Red Hat, Inc. All rights reserved.
   3  *
   4  * This file is released under the GPL.
   5  */
   6
   7 #include "dm-btree.h"
   8 #include "dm-btree-internal.h"
   9 #include "dm-transaction-manager.h"
  10
  11 #include <linux/export.h>
  12
  13 /*
  14  * Removing an entry from a btree
  15  * ==============================
  16  *
  17  * A very important constraint for our btree is that no node, except the
  18  * root, may have fewer than a certain number of entries.
  19  * (MIN_ENTRIES <= nr_entries <= MAX_ENTRIES).
  20  *
  21  * Ensuring this is complicated by the way we want to only ever hold the
  22  * locks on 2 nodes concurrently, and only change nodes in a top to bottom
  23  * fashion.
  24  *
  25  * Each node may have a left or right sibling.  When decending the spine,
  26  * if a node contains only MIN_ENTRIES then we try and increase this to at
  27  * least MIN_ENTRIES + 1.  We do this in the following ways:
  28  *
  29  * [A] No siblings => this can only happen if the node is the root, in which
  30  *     case we copy the childs contents over the root.
  31  *
  32  * [B] No left sibling
  33  *     ==> rebalance(node, right sibling)
  34  *
  35  * [C] No right sibling
  36  *     ==> rebalance(left sibling, node)
  37  *
  38  * [D] Both siblings, total_entries(left, node, right) <= DEL_THRESHOLD
  39  *     ==> delete node adding it's contents to left and right
  40  *
  41  * [E] Both siblings, total_entries(left, node, right) > DEL_THRESHOLD
  42  *     ==> rebalance(left, node, right)
  43  *
  44  * After these operations it's possible that the our original node no
  45  * longer contains the desired sub tree.  For this reason this rebalancing
  46  * is performed on the children of the current node.  This also avoids
  47  * having a special case for the root.
  48  *
  49  * Once this rebalancing has occurred we can then step into the child node
  50  * for internal nodes.  Or delete the entry for leaf nodes.
  51  */
  52
  53 /*
  54  * Some little utilities for moving node data around.
  55  */
  56 static void node_shift(struct node *n, int shift)
  57 {
  58         uint32_t nr_entries = le32_to_cpu(n->header.nr_entries);
  59
  60         if (shift < 0) {
  61                 shift = -shift;
  62                 memmove(key_ptr(n, 0),
  63                         key_ptr(n, shift),
  64                         (nr_entries - shift) * sizeof(__le64));
  65                 memmove(value_ptr(n, 0, sizeof(__le64)),
  66                         value_ptr(n, shift, sizeof(__le64)),
  67                         (nr_entries - shift) * sizeof(__le64));
  68         } else {
  69                 memmove(key_ptr(n, shift),
  70                         key_ptr(n, 0),
  71                         nr_entries * sizeof(__le64));
  72                 memmove(value_ptr(n, shift, sizeof(__le64)),
  73                         value_ptr(n, 0, sizeof(__le64)),
  74                         nr_entries * sizeof(__le64));
  75         }
  76 }
  77
  78 static void node_copy(struct node *left, struct node *right, int shift)
  79 {
  80         uint32_t nr_left = le32_to_cpu(left->header.nr_entries);
  81
  82         if (shift < 0) {
  83                 shift = -shift;
  84                 memcpy(key_ptr(left, nr_left),
  85                        key_ptr(right, 0),
  86                        shift * sizeof(__le64));
  87                 memcpy(value_ptr(left, nr_left, sizeof(__le64)),
  88                        value_ptr(right, 0, sizeof(__le64)),
  89                        shift * sizeof(__le64));
  90         } else {
  91                 memcpy(key_ptr(right, 0),
  92                        key_ptr(left, nr_left - shift),
  93                        shift * sizeof(__le64));
  94                 memcpy(value_ptr(right, 0, sizeof(__le64)),
  95                        value_ptr(left, nr_left - shift, sizeof(__le64)),
  96                        shift * sizeof(__le64));
  97         }
  98 }
  99
 100 /*
 101  * Delete a specific entry from a leaf node.
 102  */
 103 static void delete_at(struct node *n, unsigned index, size_t value_size)
 104 {
 105         unsigned nr_entries = le32_to_cpu(n->header.nr_entries);
 106         unsigned nr_to_copy = nr_entries - (index + 1);
 107
 108         if (nr_to_copy) {
 109                 memmove(key_ptr(n, index),
 110                         key_ptr(n, index + 1),
 111                         nr_to_copy * sizeof(__le64));
 112
 113                 memmove(value_ptr(n, index, value_size),
 114                         value_ptr(n, index + 1, value_size),
 115                         nr_to_copy * value_size);
 116         }
 117
 118         n->header.nr_entries = cpu_to_le32(nr_entries - 1);
 119 }
 120
 121 static unsigned del_threshold(struct node *n)
 122 {
 123         return le32_to_cpu(n->header.max_entries) / 3;
 124 }
 125
 126 static unsigned merge_threshold(struct node *n)
 127 {
 128         /*
 129          * The extra one is because we know we're potentially going to
 130          * delete an entry.
 131          */
 132         return 2 * (le32_to_cpu(n->header.max_entries) / 3) + 1;
 133 }
 134
 135 struct child {
 136         unsigned index;
 137         struct dm_block *block;
 138         struct node *n;
 139 };
 140
 141 static struct dm_btree_value_type le64_type = {
 142         .context = NULL,
 143         .size = sizeof(__le64),
 144         .inc = NULL,
 145         .dec = NULL,
 146         .equal = NULL
 147 };
 148
 149 static int init_child(struct dm_btree_info *info, struct node *parent,
 150                       unsigned index, struct child *result)
 151 {
 152         int r, inc;
 153         dm_block_t root;
 154
 155         result->index = index;
 156         root = value64(parent, index);
 157
 158         r = dm_tm_shadow_block(info->tm, root, &btree_node_validator,
 159                                &result->block, &inc);
 160         if (r)
 161                 return r;
 162
 163         result->n = dm_block_data(result->block);
 164
 165         if (inc)
 166                 inc_children(info->tm, result->n, &le64_type);
 167
 168         return 0;
 169 }
 170
 171 static int exit_child(struct dm_btree_info *info, struct child *c)
 172 {
 173         return dm_tm_unlock(info->tm, c->block);
 174 }
 175
 176 static void shift(struct node *left, struct node *right, int count)
 177 {
 178         if (!count)
 179                 return;
 180
 181         if (count > 0) {
 182                 node_shift(right, count);
 183                 node_copy(left, right, count);
 184         } else {
 185                 node_copy(left, right, count);
 186                 node_shift(right, count);
 187         }
 188
 189         left->header.nr_entries =
 190                 cpu_to_le32(le32_to_cpu(left->header.nr_entries) - count);
 191
 192         right->header.nr_entries =
 193                 cpu_to_le32(le32_to_cpu(right->header.nr_entries) + count);
 194 }
 195
 196 static void __rebalance2(struct dm_btree_info *info, struct node *parent,
 197                          struct child *l, struct child *r)
 198 {
 199         struct node *left = l->n;
 200         struct node *right = r->n;
 201         uint32_t nr_left = le32_to_cpu(left->header.nr_entries);
 202         uint32_t nr_right = le32_to_cpu(right->header.nr_entries);
 203
 204         if (nr_left + nr_right <= merge_threshold(left)) {
 205                 /*
 206                  * Merge
 207                  */
 208                 node_copy(left, right, -nr_right);
 209                 left->header.nr_entries = cpu_to_le32(nr_left + nr_right);
 210
 211                 *((__le64 *) value_ptr(parent, l->index, sizeof(__le64))) =
 212                         cpu_to_le64(dm_block_location(l->block));
 213                 delete_at(parent, r->index, sizeof(__le64));
 214
 215                 /*
 216                  * We need to decrement the right block, but not it's
 217                  * children, since they're still referenced by left.
 218                  */
 219                 dm_tm_dec(info->tm, dm_block_location(r->block));
 220         } else {
 221                 /*
 222                  * Rebalance.
 223                  */
 224                 unsigned target_left = (nr_left + nr_right) / 2;
 225
 226                 shift(left, right, nr_left - target_left);
 227                 *((__le64 *) value_ptr(parent, l->index, sizeof(__le64))) =
 228                         cpu_to_le64(dm_block_location(l->block));
 229                 *((__le64 *) value_ptr(parent, r->index, sizeof(__le64))) =
 230                         cpu_to_le64(dm_block_location(r->block));
 231                 *key_ptr(parent, r->index) = right->keys[0];
 232         }
 233 }
 234
 235 static int rebalance2(struct shadow_spine *s, struct dm_btree_info *info,
 236                       unsigned left_index)
 237 {
 238         int r;
 239         struct node *parent;
 240         struct child left, right;
 241
 242         parent = dm_block_data(shadow_current(s));
 243
 244         r = init_child(info, parent, left_index, &left);
 245         if (r)
 246                 return r;
 247
 248         r = init_child(info, parent, left_index + 1, &right);
 249         if (r) {
 250                 exit_child(info, &left);
 251                 return r;
 252         }
 253
 254         __rebalance2(info, parent, &left, &right);
 255
 256         r = exit_child(info, &left);
 257         if (r) {
 258                 exit_child(info, &right);
 259                 return r;
 260         }
 261
 262         r = exit_child(info, &right);
 263         if (r)
 264                 return r;
 265
 266         return 0;
 267 }
 268
 269 static void __rebalance3(struct dm_btree_info *info, struct node *parent,
 270                          struct child *l, struct child *c, struct child *r)
 271 {
 272         struct node *left = l->n;
 273         struct node *center = c->n;
 274         struct node *right = r->n;
 275
 276         uint32_t nr_left = le32_to_cpu(left->header.nr_entries);
 277         uint32_t nr_center = le32_to_cpu(center->header.nr_entries);
 278         uint32_t nr_right = le32_to_cpu(right->header.nr_entries);
 279         uint32_t max_entries = le32_to_cpu(left->header.max_entries);
 280
 281         unsigned target;
 282
 283         if (((nr_left + nr_center + nr_right) / 2) < merge_threshold(center)) {
 284                 /*
 285                  * Delete center node:
 286                  *
 287                  * We dump as many entries from center as possible into
 288                  * left, then the rest in right, then rebalance2.  This
 289                  * wastes some cpu, but I want something simple atm.
 290                  */
 291                 unsigned shift = min(max_entries - nr_left, nr_center);
 292
 293                 node_copy(left, center, -shift);
 294                 left->header.nr_entries = cpu_to_le32(nr_left + shift);
 295
 296                 if (shift != nr_center) {
 297                         shift = nr_center - shift;
 298                         node_shift(right, shift);
 299                         node_copy(center, right, shift);
 300                         right->header.nr_entries = cpu_to_le32(nr_right + shift);
 301                 }
 302
 303                 *((__le64 *) value_ptr(parent, l->index, sizeof(__le64))) =
 304                         cpu_to_le64(dm_block_location(l->block));
 305                 *((__le64 *) value_ptr(parent, r->index, sizeof(__le64))) =
 306                         cpu_to_le64(dm_block_location(r->block));
 307                 *key_ptr(parent, r->index) = right->keys[0];
 308
 309                 delete_at(parent, c->index, sizeof(__le64));
 310                 r->index--;
 311
 312                 dm_tm_dec(info->tm, dm_block_location(c->block));
 313                 __rebalance2(info, parent, l, r);
 314
 315                 return;
 316         }
 317
 318         /*
 319          * Rebalance
 320          */
 321         target = (nr_left + nr_center + nr_right) / 3;
 322         BUG_ON(target == nr_center);
 323
 324         /*
 325          * Adjust the left node
 326          */
 327         shift(left, center, nr_left - target);
 328
 329         /*
 330          * Adjust the right node
 331          */
 332         shift(center, right, target - nr_right);
 333
 334         *((__le64 *) value_ptr(parent, l->index, sizeof(__le64))) =
 335                 cpu_to_le64(dm_block_location(l->block));
 336         *((__le64 *) value_ptr(parent, c->index, sizeof(__le64))) =
 337                 cpu_to_le64(dm_block_location(c->block));
 338         *((__le64 *) value_ptr(parent, r->index, sizeof(__le64))) =
 339                 cpu_to_le64(dm_block_location(r->block));
 340
 341         *key_ptr(parent, c->index) = center->keys[0];
 342         *key_ptr(parent, r->index) = right->keys[0];
 343 }
 344
 345 static int rebalance3(struct shadow_spine *s, struct dm_btree_info *info,
 346                       unsigned left_index)
 347 {
 348         int r;
 349         struct node *parent = dm_block_data(shadow_current(s));
 350         struct child left, center, right;
 351
 352         /*
 353          * FIXME: fill out an array?
 354          */
 355         r = init_child(info, parent, left_index, &left);
 356         if (r)
 357                 return r;
 358
 359         r = init_child(info, parent, left_index + 1, &center);
 360         if (r) {
 361                 exit_child(info, &left);
 362                 return r;
 363         }
 364
 365         r = init_child(info, parent, left_index + 2, &right);
 366         if (r) {
 367                 exit_child(info, &left);
 368                 exit_child(info, &center);
 369                 return r;
 370         }
 371
 372         __rebalance3(info, parent, &left, &center, &right);
 373
 374         r = exit_child(info, &left);
 375         if (r) {
 376                 exit_child(info, &center);
 377                 exit_child(info, &right);
 378                 return r;
 379         }
 380
 381         r = exit_child(info, &center);
 382         if (r) {
 383                 exit_child(info, &right);
 384                 return r;
 385         }
 386
 387         r = exit_child(info, &right);
 388         if (r)
 389                 return r;
 390
 391         return 0;
 392 }
 393
 394 static int get_nr_entries(struct dm_transaction_manager *tm,
 395                           dm_block_t b, uint32_t *result)
 396 {
 397         int r;
 398         struct dm_block *block;
 399         struct node *n;
 400
 401         r = dm_tm_read_lock(tm, b, &btree_node_validator, &block);
 402         if (r)
 403                 return r;
 404
 405         n = dm_block_data(block);
 406         *result = le32_to_cpu(n->header.nr_entries);
 407
 408         return dm_tm_unlock(tm, block);
 409 }
 410
 411 static int rebalance_children(struct shadow_spine *s,
 412                               struct dm_btree_info *info, uint64_t key)
 413 {
 414         int i, r, has_left_sibling, has_right_sibling;
 415         uint32_t child_entries;
 416         struct node *n;
 417
 418         n = dm_block_data(shadow_current(s));
 419
 420         if (le32_to_cpu(n->header.nr_entries) == 1) {
 421                 struct dm_block *child;
 422                 dm_block_t b = value64(n, 0);
 423
 424                 r = dm_tm_read_lock(info->tm, b, &btree_node_validator, &child);
 425                 if (r)
 426                         return r;
 427
 428                 memcpy(n, dm_block_data(child),
 429                        dm_bm_block_size(dm_tm_get_bm(info->tm)));
 430                 r = dm_tm_unlock(info->tm, child);
 431                 dm_tm_dec(info->tm, dm_block_location(child));
 432
 433                 return r;
 434         }
 435
 436         i = lower_bound(n, key);
 437         if (i < 0)
 438                 return -ENODATA;
 439
 440         r = get_nr_entries(info->tm, value64(n, i), &child_entries);
 441         if (r)
 442                 return r;
 443
 444         if (child_entries > del_threshold(n))
 445                 return 0;
 446
 447         has_left_sibling = i > 0 ? 1 : 0;
 448         has_right_sibling =
 449                 (i >= (le32_to_cpu(n->header.nr_entries) - 1)) ? 0 : 1;
 450
 451         if (!has_left_sibling)
 452                 r = rebalance2(s, info, i);
 453
 454         else if (!has_right_sibling)
 455                 r = rebalance2(s, info, i - 1);
 456
 457         else
 458                 r = rebalance3(s, info, i - 1);
 459
 460         return r;
 461 }
 462
 463 static int do_leaf(struct node *n, uint64_t key, unsigned *index)
 464 {
 465         int i = lower_bound(n, key);
 466
 467         if ((i < 0) ||
 468             (i >= le32_to_cpu(n->header.nr_entries)) ||
 469             (le64_to_cpu(n->keys[i]) != key))
 470                 return -ENODATA;
 471
 472         *index = i;
 473
 474         return 0;
 475 }
 476
 477 /*
 478  * Prepares for removal from one level of the hierarchy.  The caller must
 479  * actually call delete_at() to remove the entry at index.
 480  */
 481 static int remove_raw(struct shadow_spine *s, struct dm_btree_info *info,
 482                       struct dm_btree_value_type *vt, dm_block_t root,
 483                       uint64_t key, unsigned *index)
 484 {
 485         int i = *index, inc, r;
 486         struct node *n;
 487
 488         for (;;) {
 489                 r = shadow_step(s, root, vt, &inc);
 490                 if (r < 0)
 491                         break;
 492
 493                 /*
 494                  * We have to patch up the parent node, ugly, but I don't
 495                  * see a way to do this automatically as part of the spine
 496                  * op.
 497                  */
 498                 if (shadow_has_parent(s)) {
 499                         __le64 location = cpu_to_le64(dm_block_location(shadow_current(s)));
 500                         memcpy(value_ptr(dm_block_data(shadow_parent(s)), i, sizeof(uint64_t)),
 501                                &location, sizeof(__le64));
 502                 }
 503
 504                 n = dm_block_data(shadow_current(s));
 505                 if (inc)
 506                         inc_children(info->tm, n, vt);
 507
 508                 if (le32_to_cpu(n->header.flags) & LEAF_NODE)
 509                         return do_leaf(n, key, index);
 510
 511                 r = rebalance_children(s, info, key);
 512                 if (r)
 513                         break;
 514
 515                 n = dm_block_data(shadow_current(s));
 516                 if (le32_to_cpu(n->header.flags) & LEAF_NODE)
 517                         return do_leaf(n, key, index);
 518
 519                 i = lower_bound(n, key);
 520
 521                 /*
 522                  * We know the key is present, or else
 523                  * rebalance_children would have returned
 524                  * -ENODATA
 525                  */
 526                 root = value64(n, i);
 527         }
 528
 529         return r;
 530 }
 531
 532 int dm_btree_remove(struct dm_btree_info *info, dm_block_t root,
 533                     uint64_t *keys, dm_block_t *new_root)
 534 {
 535         unsigned level, last_level = info->levels - 1;
 536         int index = 0, r = 0;
 537         struct shadow_spine spine;
 538         struct node *n;
 539
 540         init_shadow_spine(&spine, info);
 541         for (level = 0; level < info->levels; level++) {
 542                 r = remove_raw(&spine, info,
 543                                (level == last_level ?
 544                                 &info->value_type : &le64_type),
 545                                root, keys[level], (unsigned *)&index);
 546                 if (r < 0)
 547                         break;
 548
 549                 n = dm_block_data(shadow_current(&spine));
 550                 if (level != last_level) {
 551                         root = value64(n, index);
 552                         continue;
 553                 }
 554
 555                 BUG_ON(index < 0 || index >= le32_to_cpu(n->header.nr_entries));
 556
 557                 if (info->value_type.dec)
 558                         info->value_type.dec(info->value_type.context,
 559                                              value_ptr(n, index, info->value_type.size));
 560
 561                 delete_at(n, index, info->value_type.size);
 562
 563                 r = 0;
 564                 *new_root = shadow_root(&spine);
 565         }
 566
 567         exit_shadow_spine(&spine);
 568
 569         return r;
 570 }
 571 EXPORT_SYMBOL_GPL(dm_btree_remove);