lib/ext2fs/blkmap64_rb.c

   1 /*
   2  * blkmap64_rb.c --- Simple rb-tree implementation for bitmaps
   3  *
   4  * (C)2010 Red Hat, Inc., Lukas Czerner <lczerner@redhat.com>
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU Public
   8  * License.
   9  * %End-Header%
  10  */
  11
  12 #include <stdio.h>
  13 #include <string.h>
  14 #if HAVE_UNISTD_H
  15 #include <unistd.h>
  16 #endif
  17 #include <fcntl.h>
  18 #include <time.h>
  19 #if HAVE_SYS_STAT_H
  20 #include <sys/stat.h>
  21 #endif
  22 #if HAVE_SYS_TYPES_H
  23 #include <sys/types.h>
  24 #endif
  25
  26 #include "ext2_fs.h"
  27 #include "ext2fsP.h"
  28 #include "bmap64.h"
  29 #include "rbtree.h"
  30
  31 #include <limits.h>
  32
  33 struct bmap_rb_extent {
  34         struct rb_node node;
  35         __u64 start;
  36         __u32 count;
  37 };
  38
  39 struct ext2fs_rb_private {
  40         struct rb_root root;
  41         struct bmap_rb_extent **wcursor;
  42         struct bmap_rb_extent **rcursor;
  43 #ifdef BMAP_STATS_OPS
  44         __u64 mark_hit;
  45         __u64 test_hit;
  46 #endif
  47 };
  48
  49 static int rb_insert_extent(__u64 start, __u64 count,
  50                             struct ext2fs_rb_private *);
  51 static void rb_get_new_extent(struct bmap_rb_extent **, __u64, __u64);
  52
  53 /* #define DEBUG_RB */
  54
  55 #ifdef DEBUG_RB
  56 static void print_tree(struct rb_root *root)
  57 {
  58         struct rb_node *node = NULL;
  59         struct bmap_rb_extent *ext;
  60
  61         printf("\t\t\t=================================\n");
  62         node = ext2fs_rb_first(root);
  63         for (node = ext2fs_rb_first(root); node != NULL;
  64              node = ext2fs_rb_next(node)) {
  65                 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
  66                 printf("\t\t\t--> (%llu -> %llu)\n",
  67                         ext->start, ext->start + ext->count);
  68         }
  69         printf("\t\t\t=================================\n");
  70 }
  71
  72 static int check_tree(struct rb_root *root, const char *msg)
  73 {
  74         struct rb_node *new_node, *node, *next;
  75         struct bmap_rb_extent *ext, *old = NULL;
  76
  77         for (node = ext2fs_rb_first(root); node;
  78              node = ext2fs_rb_next(node)) {
  79                 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
  80                 if (ext->count <= 0) {
  81                         printf("Tree Error: count is crazy\n");
  82                         printf("extent: %llu -> %llu (%u)\n", ext->start,
  83                                 ext->start + ext->count, ext->count);
  84                         goto err_out;
  85                 }
  86                 if (ext->start < 0) {
  87                         printf("Tree Error: start is crazy\n");
  88                         printf("extent: %llu -> %llu (%u)\n", ext->start,
  89                                 ext->start + ext->count, ext->count);
  90                         goto err_out;
  91                 }
  92
  93                 if (old) {
  94                         if (old->start > ext->start) {
  95                                 printf("Tree Error: start is crazy\n");
  96                                 printf("extent: %llu -> %llu (%u)\n",
  97                                         old->start, old->start + old->count,
  98                                         old->count);
  99                                 printf("extent next: %llu -> %llu (%u)\n",
 100                                         ext->start, ext->start + ext->count,
 101                                         ext->count);
 102                                 goto err_out;
 103                         }
 104                         if ((old->start + old->count) >= ext->start) {
 105                                 printf("Tree Error: extent is crazy\n");
 106                                 printf("extent: %llu -> %llu (%u)\n",
 107                                         old->start, old->start + old->count,
 108                                         old->count);
 109                                 printf("extent next: %llu -> %llu (%u)\n",
 110                                         ext->start, ext->start + ext->count,
 111                                         ext->count);
 112                                 goto err_out;
 113                         }
 114                 }
 115                 old = ext;
 116         }
 117         return 0;
 118
 119 err_out:
 120         printf("%s\n", msg);
 121         print_tree(root);
 122         exit(1);
 123 }
 124 #else
 125 #define check_tree(root, msg) 0
 126 #define print_tree(root, msg) 0
 127 #endif
 128
 129 static void rb_get_new_extent(struct bmap_rb_extent **ext, __u64 start,
 130                              __u64 count)
 131 {
 132         struct bmap_rb_extent *new_ext;
 133         int retval;
 134
 135         retval = ext2fs_get_mem(sizeof (struct bmap_rb_extent),
 136                                 &new_ext);
 137         if (retval) {
 138                 perror("ext2fs_get_mem");
 139                 exit(1);
 140         }
 141
 142         new_ext->start = start;
 143         new_ext->count = count;
 144         *ext = new_ext;
 145 }
 146
 147 inline
 148 static void rb_free_extent(struct ext2fs_rb_private *bp,
 149                            struct bmap_rb_extent *ext)
 150 {
 151         if (*bp->wcursor == ext)
 152                 *bp->wcursor = NULL;
 153         if (*bp->rcursor == ext)
 154                 *bp->rcursor = NULL;
 155         ext2fs_free_mem(&ext);
 156 }
 157
 158 static errcode_t rb_alloc_private_data (ext2fs_generic_bitmap bitmap)
 159 {
 160         struct ext2fs_rb_private *bp;
 161         errcode_t       retval;
 162
 163         retval = ext2fs_get_mem(sizeof (struct ext2fs_rb_private), &bp);
 164         if (retval)
 165                 return retval;
 166
 167         bp->root = RB_ROOT;
 168         retval = ext2fs_get_mem(sizeof(struct bmap_rb_extent *), &bp->rcursor);
 169         if (retval)
 170                 return retval;
 171         retval = ext2fs_get_mem(sizeof(struct bmap_rb_extent *), &bp->wcursor);
 172         if (retval)
 173                 return retval;
 174         *bp->rcursor = NULL;
 175         *bp->wcursor = NULL;
 176
 177 #ifdef BMAP_STATS_OPS
 178         bp->test_hit = 0;
 179         bp->mark_hit = 0;
 180 #endif
 181
 182         bitmap->private = (void *) bp;
 183         return 0;
 184 }
 185
 186 static errcode_t rb_new_bmap(ext2_filsys fs EXT2FS_ATTR((unused)),
 187                              ext2fs_generic_bitmap bitmap)
 188 {
 189         errcode_t       retval;
 190
 191         retval = rb_alloc_private_data (bitmap);
 192         if (retval)
 193                 return retval;
 194
 195         return 0;
 196 }
 197
 198 static void rb_free_tree(struct rb_root *root)
 199 {
 200         struct bmap_rb_extent *ext;
 201         struct rb_node *node, *next;
 202
 203         for (node = ext2fs_rb_first(root); node; node = next) {
 204                 next = ext2fs_rb_next(node);
 205                 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
 206                 ext2fs_rb_erase(node, root);
 207                 ext2fs_free_mem(&ext);
 208         }
 209 }
 210
 211 static void rb_free_bmap(ext2fs_generic_bitmap bitmap)
 212 {
 213         struct ext2fs_rb_private *bp;
 214
 215         bp = (struct ext2fs_rb_private *) bitmap->private;
 216
 217         rb_free_tree(&bp->root);
 218         ext2fs_free_mem(&bp->rcursor);
 219         ext2fs_free_mem(&bp->wcursor);
 220         ext2fs_free_mem(&bp);
 221         bp = 0;
 222 }
 223
 224 static errcode_t rb_copy_bmap(ext2fs_generic_bitmap src,
 225                               ext2fs_generic_bitmap dest)
 226 {
 227         struct ext2fs_rb_private *src_bp, *dest_bp;
 228         struct bmap_rb_extent *src_ext, *dest_ext;
 229         struct rb_node *dest_node, *src_node, *dest_last, **n;
 230         errcode_t retval = 0;
 231
 232         retval = rb_alloc_private_data (dest);
 233         if (retval)
 234                 return retval;
 235
 236         src_bp = (struct ext2fs_rb_private *) src->private;
 237         dest_bp = (struct ext2fs_rb_private *) dest->private;
 238         *src_bp->rcursor = NULL;
 239         *dest_bp->rcursor = NULL;
 240
 241         src_node = ext2fs_rb_first(&src_bp->root);
 242         while (src_node) {
 243                 src_ext = ext2fs_rb_entry(src_node, struct bmap_rb_extent, node);
 244                 retval = ext2fs_get_mem(sizeof (struct bmap_rb_extent),
 245                                         &dest_ext);
 246                 if (retval)
 247                         break;
 248
 249                 memcpy(dest_ext, src_ext, sizeof(struct bmap_rb_extent));
 250
 251                 dest_node = &dest_ext->node;
 252                 n = &dest_bp->root.rb_node;
 253
 254                 dest_last = NULL;
 255                 if (*n) {
 256                         dest_last = ext2fs_rb_last(&dest_bp->root);
 257                         n = &(dest_last)->rb_right;
 258                 }
 259
 260                 ext2fs_rb_link_node(dest_node, dest_last, n);
 261                 ext2fs_rb_insert_color(dest_node, &dest_bp->root);
 262
 263                 src_node = ext2fs_rb_next(src_node);
 264         }
 265
 266         return retval;
 267 }
 268
 269 static void rb_truncate(__u64 new_max, struct rb_root *root)
 270 {
 271         struct bmap_rb_extent *ext;
 272         struct rb_node *node;
 273
 274         node = ext2fs_rb_last(root);
 275         while (node) {
 276                 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
 277
 278                 if ((ext->start + ext->count - 1) <= new_max)
 279                         break;
 280                 else if (ext->start > new_max) {
 281                         ext2fs_rb_erase(node, root);
 282                         ext2fs_free_mem(&ext);
 283                         node = ext2fs_rb_last(root);
 284                         continue;
 285                 } else
 286                         ext->count = new_max - ext->start + 1;
 287         }
 288 }
 289
 290 static errcode_t rb_resize_bmap(ext2fs_generic_bitmap bmap,
 291                                 __u64 new_end, __u64 new_real_end)
 292 {
 293         struct ext2fs_rb_private *bp;
 294
 295         if (new_real_end >= bmap->real_end) {
 296                 bmap->end = new_end;
 297                 bmap->real_end = new_real_end;
 298                 return 0;
 299         }
 300
 301         bp = (struct ext2fs_rb_private *) bmap->private;
 302         *bp->rcursor = NULL;
 303         *bp->wcursor = NULL;
 304
 305         /* truncate tree to new_real_end size */
 306         rb_truncate(new_real_end, &bp->root);
 307
 308         bmap->end = new_end;
 309         bmap->real_end = new_real_end;
 310         return 0;
 311
 312 }
 313
 314 inline static int
 315 rb_test_bit(struct ext2fs_rb_private *bp, __u64 bit)
 316 {
 317         struct bmap_rb_extent *rcursor;
 318         struct rb_node *parent = NULL;
 319         struct rb_node **n = &bp->root.rb_node;
 320         struct bmap_rb_extent *ext;
 321         int i=0;
 322
 323         rcursor = *bp->rcursor;
 324         if (!rcursor)
 325                 goto search_tree;
 326
 327         if (bit >= rcursor->start && bit < rcursor->start + rcursor->count) {
 328 #ifdef BMAP_STATS_OPS
 329                 bp->test_hit++;
 330 #endif
 331                 return 1;
 332         }
 333
 334         rcursor = *bp->wcursor;
 335         if (!rcursor)
 336                 goto search_tree;
 337
 338         if (bit >= rcursor->start && bit < rcursor->start + rcursor->count)
 339                 return 1;
 340
 341 search_tree:
 342
 343         while (*n) {
 344                 parent = *n;
 345                 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
 346                 if (bit < ext->start)
 347                         n = &(*n)->rb_left;
 348                 else if (bit >= (ext->start + ext->count))
 349                         n = &(*n)->rb_right;
 350                 else {
 351                         *bp->rcursor = ext;
 352                         return 1;
 353                 }
 354         }
 355         return 0;
 356 }
 357
 358 static int rb_insert_extent(__u64 start, __u64 count,
 359                             struct ext2fs_rb_private *bp)
 360 {
 361         struct rb_root *root = &bp->root;
 362         struct rb_node *parent = NULL, **n = &root->rb_node;
 363         struct rb_node *new_node, *node, *next;
 364         struct bmap_rb_extent *new_ext;
 365         struct bmap_rb_extent *ext;
 366         int retval = 0;
 367
 368         ext = *bp->wcursor;
 369         if (ext) {
 370                 if (start >= ext->start &&
 371                     start <= (ext->start + ext->count)) {
 372 #ifdef BMAP_STATS_OPS
 373                         bp->mark_hit++;
 374 #endif
 375                         goto got_extent;
 376                 }
 377         }
 378
 379         while (*n) {
 380                 parent = *n;
 381                 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
 382
 383                 if (start < ext->start) {
 384                         n = &(*n)->rb_left;
 385                 } else if (start > (ext->start + ext->count)) {
 386                         n = &(*n)->rb_right;
 387                 } else {
 388 got_extent:
 389                         if ((start + count) <= (ext->start + ext->count))
 390                                 return 1;
 391
 392                         if ((ext->start + ext->count) == start)
 393                                 retval = 0;
 394                         else
 395                                 retval = 1;
 396
 397                         count += (start - ext->start);
 398                         start = ext->start;
 399                         new_ext = ext;
 400                         new_node = &ext->node;
 401
 402                         goto skip_insert;
 403                 }
 404         }
 405
 406         rb_get_new_extent(&new_ext, start, count);
 407
 408         new_node = &new_ext->node;
 409         ext2fs_rb_link_node(new_node, parent, n);
 410         ext2fs_rb_insert_color(new_node, root);
 411         *bp->wcursor = new_ext;
 412
 413         node = ext2fs_rb_prev(new_node);
 414         if (node) {
 415                 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
 416                 if ((ext->start + ext->count) == start) {
 417                         start = ext->start;
 418                         count += ext->count;
 419                         ext2fs_rb_erase(node, root);
 420                         rb_free_extent(bp, ext);
 421                 }
 422         }
 423
 424 skip_insert:
 425         /* See if we can merge extent to the right */
 426         for (node = ext2fs_rb_next(new_node); node != NULL; node = next) {
 427                 next = ext2fs_rb_next(node);
 428                 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
 429
 430                 if ((ext->start + ext->count) <= start)
 431                         continue;
 432
 433                 /* No more merging */
 434                 if ((start + count) < ext->start)
 435                         break;
 436
 437                 /* ext is embedded in new_ext interval */
 438                 if ((start + count) >= (ext->start + ext->count)) {
 439                         ext2fs_rb_erase(node, root);
 440                         rb_free_extent(bp, ext);
 441                         continue;
 442                 } else {
 443                 /* merge ext with new_ext */
 444                         count += ((ext->start + ext->count) -
 445                                   (start + count));
 446                         ext2fs_rb_erase(node, root);
 447                         rb_free_extent(bp, ext);
 448                         break;
 449                 }
 450         }
 451
 452         new_ext->start = start;
 453         new_ext->count = count;
 454
 455         return retval;
 456 }
 457
 458 static int rb_remove_extent(__u64 start, __u64 count,
 459                             struct ext2fs_rb_private *bp)
 460 {
 461         struct rb_root *root = &bp->root;
 462         struct rb_node *parent = NULL, **n = &root->rb_node;
 463         struct rb_node *node;
 464         struct bmap_rb_extent *ext;
 465         __u64 new_start, new_count;
 466         int retval = 0;
 467
 468         if (EXT2FS_RB_EMPTY_ROOT(root))
 469                 return 0;
 470
 471         while (*n) {
 472                 parent = *n;
 473                 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
 474                 if (start < ext->start) {
 475                         n = &(*n)->rb_left;
 476                         continue;
 477                 } else if (start >= (ext->start + ext->count)) {
 478                         n = &(*n)->rb_right;
 479                         continue;
 480                 }
 481
 482                 if ((start > ext->start) &&
 483                     (start + count) < (ext->start + ext->count)) {
 484                         /* We have to split extent into two */
 485                         new_start = start + count;
 486                         new_count = (ext->start + ext->count) - new_start;
 487
 488                         ext->count = start - ext->start;
 489
 490                         rb_insert_extent(new_start, new_count, bp);
 491                         return 1;
 492                 }
 493
 494                 if ((start + count) >= (ext->start + ext->count)) {
 495                         ext->count = start - ext->start;
 496                         retval = 1;
 497                 }
 498
 499                 if (0 == ext->count) {
 500                         parent = ext2fs_rb_next(&ext->node);
 501                         ext2fs_rb_erase(&ext->node, root);
 502                         rb_free_extent(bp, ext);
 503                         break;
 504                 }
 505
 506                 if (start == ext->start) {
 507                         ext->start += count;
 508                         ext->count -= count;
 509                         return 1;
 510                 }
 511         }
 512
 513         /* See if we should delete or truncate extent on the right */
 514         for (; parent != NULL; parent = node) {
 515                 node = ext2fs_rb_next(parent);
 516                 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
 517                 if ((ext->start + ext->count) <= start)
 518                         continue;
 519
 520                 /* No more extents to be removed/truncated */
 521                 if ((start + count) < ext->start)
 522                         break;
 523
 524                 /* The entire extent is within the region to be removed */
 525                 if ((start + count) >= (ext->start + ext->count)) {
 526                         ext2fs_rb_erase(parent, root);
 527                         rb_free_extent(bp, ext);
 528                         retval = 1;
 529                         continue;
 530                 } else {
 531                         /* modify the last extent in reigon to be removed */
 532                         ext->count -= ((start + count) - ext->start);
 533                         ext->start = start + count;
 534                         retval = 1;
 535                         break;
 536                 }
 537         }
 538
 539         return retval;
 540 }
 541
 542 static int rb_mark_bmap(ext2fs_generic_bitmap bitmap, __u64 arg)
 543 {
 544         struct ext2fs_rb_private *bp;
 545         int i;
 546
 547
 548         bp = (struct ext2fs_rb_private *) bitmap->private;
 549         arg -= bitmap->start;
 550
 551         return rb_insert_extent(arg, 1, bp);
 552 }
 553
 554 static int rb_unmark_bmap(ext2fs_generic_bitmap bitmap, __u64 arg)
 555 {
 556         struct ext2fs_rb_private *bp;
 557         int retval;
 558
 559         bp = (struct ext2fs_rb_private *) bitmap->private;
 560         arg -= bitmap->start;
 561
 562         retval = rb_remove_extent(arg, 1, bp);
 563         check_tree(&bp->root, __func__);
 564
 565         return retval;
 566 }
 567
 568 inline
 569 static int rb_test_bmap(ext2fs_generic_bitmap bitmap, __u64 arg)
 570 {
 571         struct ext2fs_rb_private *bp;
 572
 573         bp = (struct ext2fs_rb_private *) bitmap->private;
 574         arg -= bitmap->start;
 575
 576         return rb_test_bit(bp, arg);
 577 }
 578
 579 static void rb_mark_bmap_extent(ext2fs_generic_bitmap bitmap, __u64 arg,
 580                                 unsigned int num)
 581 {
 582         struct ext2fs_rb_private *bp;
 583         struct bmap_rb_extent *new_ext;
 584
 585         bp = (struct ext2fs_rb_private *) bitmap->private;
 586         arg -= bitmap->start;
 587
 588         rb_insert_extent(arg, num, bp);
 589 }
 590
 591 static void rb_unmark_bmap_extent(ext2fs_generic_bitmap bitmap, __u64 arg,
 592                                   unsigned int num)
 593 {
 594         struct ext2fs_rb_private *bp;
 595         int ret;
 596
 597         bp = (struct ext2fs_rb_private *) bitmap->private;
 598         arg -= bitmap->start;
 599
 600         rb_remove_extent(arg, num, bp);
 601         check_tree(&bp->root, __func__);
 602 }
 603
 604 static int rb_test_clear_bmap_extent(ext2fs_generic_bitmap bitmap,
 605                                      __u64 start, unsigned int len)
 606 {
 607         struct rb_node *parent = NULL, **n;
 608         struct rb_node *node, *next;
 609         struct ext2fs_rb_private *bp;
 610         struct bmap_rb_extent *ext;
 611         int retval = 1;
 612
 613         bp = (struct ext2fs_rb_private *) bitmap->private;
 614         n = &bp->root.rb_node;
 615         start -= bitmap->start;
 616
 617         if ((len == 0) || EXT2FS_RB_EMPTY_ROOT(&bp->root))
 618                 return 1;
 619
 620         /*
 621          * If we find nothing, we should examine whole extent, but
 622          * when we find match, the extent is not clean, thus be return
 623          * false.
 624          */
 625         while (*n) {
 626                 parent = *n;
 627                 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
 628                 if (start < ext->start) {
 629                         n = &(*n)->rb_left;
 630                 } else if (start >= (ext->start + ext->count)) {
 631                         n = &(*n)->rb_right;
 632                 } else {
 633                         /*
 634                          * We found extent int the tree -> extent is not
 635                          * clean
 636                          */
 637                         return 0;
 638                 }
 639         }
 640
 641         node = parent;
 642         while (node) {
 643                 next = ext2fs_rb_next(node);
 644                 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
 645                 node = next;
 646
 647                 if ((ext->start + ext->count) <= start)
 648                         continue;
 649
 650                 /* No more merging */
 651                 if ((start + len) <= ext->start)
 652                         break;
 653
 654                 retval = 0;
 655                 break;
 656         }
 657         return retval;
 658 }
 659
 660 static errcode_t rb_set_bmap_range(ext2fs_generic_bitmap bitmap,
 661                                      __u64 start, size_t num, void *in)
 662 {
 663         struct ext2fs_rb_private *bp;
 664         size_t i;
 665         int ret;
 666
 667         bp = (struct ext2fs_rb_private *) bitmap->private;
 668
 669         for (i = 0; i < num; i++) {
 670                 ret = ext2fs_test_bit(i, in);
 671                 if (ret)
 672                         rb_insert_extent(start + i - bitmap->start, 1, bp);
 673         }
 674
 675         return 0;
 676 }
 677
 678 static errcode_t rb_get_bmap_range(ext2fs_generic_bitmap bitmap,
 679                                      __u64 start, size_t num, void *out)
 680 {
 681
 682         struct rb_node *parent = NULL, *next, **n;
 683         struct ext2fs_rb_private *bp;
 684         struct bmap_rb_extent *ext;
 685         __u64 pos;
 686
 687         bp = (struct ext2fs_rb_private *) bitmap->private;
 688         n = &bp->root.rb_node;
 689         start -= bitmap->start;
 690
 691         if (EXT2FS_RB_EMPTY_ROOT(&bp->root))
 692                 return 0;
 693
 694         while (*n) {
 695                 parent = *n;
 696                 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
 697                 if (start < ext->start) {
 698                         n = &(*n)->rb_left;
 699                 } else if (start >= (ext->start + ext->count)) {
 700                         n = &(*n)->rb_right;
 701                 } else
 702                         break;
 703         }
 704
 705         pos = start;
 706         for (; parent != NULL; parent = next) {
 707                 next = ext2fs_rb_next(parent);
 708                 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
 709
 710                 while (((pos - start) < num) &&
 711                         (pos < ext->start)) {
 712                         ext2fs_fast_clear_bit64((pos - start), out);
 713                         pos++;
 714                 }
 715
 716                 if ((pos - start) >= num)
 717                         return 0;
 718
 719                 while (((pos - start) < num) &&
 720                         (pos < (ext->start + ext->count))) {
 721                         ext2fs_fast_set_bit64((pos - start), out);
 722                         pos++;
 723                 }
 724         }
 725
 726         while ((pos - start) < num) {
 727                 ext2fs_fast_clear_bit64((pos - start), out);
 728                 pos++;
 729         }
 730
 731         return 0;
 732 }
 733
 734 static void rb_clear_bmap(ext2fs_generic_bitmap bitmap)
 735 {
 736         struct ext2fs_rb_private *bp;
 737
 738         bp = (struct ext2fs_rb_private *) bitmap->private;
 739
 740         rb_free_tree(&bp->root);
 741         *bp->rcursor = NULL;
 742         *bp->wcursor = NULL;
 743 }
 744
 745 #ifdef BMAP_STATS
 746 static void rb_print_stats(ext2fs_generic_bitmap bitmap)
 747 {
 748         struct ext2fs_rb_private *bp;
 749         struct rb_node *node = NULL;
 750         struct bmap_rb_extent *ext;
 751         __u64 count = 0;
 752         __u64 max_size = 0;
 753         __u64 min_size = ULONG_MAX;
 754         __u64 size = 0, avg_size = 0;
 755         __u64 mark_all, test_all;
 756         double eff, m_hit = 0.0, t_hit = 0.0;
 757
 758         bp = (struct ext2fs_rb_private *) bitmap->private;
 759
 760         node = ext2fs_rb_first(&bp->root);
 761         for (node = ext2fs_rb_first(&bp->root); node != NULL;
 762              node = ext2fs_rb_next(node)) {
 763                 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
 764                 count++;
 765                 if (ext->count > max_size)
 766                         max_size = ext->count;
 767                 if (ext->count < min_size)
 768                         min_size = ext->count;
 769                 size += ext->count;
 770         }
 771
 772         if (count)
 773                 avg_size = size / count;
 774         if (min_size == ULONG_MAX)
 775                 min_size = 0;
 776         eff = (double)((count * sizeof(struct bmap_rb_extent)) << 3) /
 777               (bitmap->real_end - bitmap->start);
 778 #ifdef BMAP_STATS_OPS
 779         mark_all = bitmap->stats.mark_count + bitmap->stats.mark_ext_count;
 780         test_all = bitmap->stats.test_count + bitmap->stats.test_ext_count;
 781         if (mark_all)
 782                 m_hit = ((double)bp->mark_hit / mark_all) * 100;
 783         if (test_all)
 784                 t_hit = ((double)bp->test_hit / test_all) * 100;
 785
 786         fprintf(stderr, "%16llu cache hits on test (%.2f%%)\n"
 787                 "%16llu cache hits on mark (%.2f%%)\n",
 788                 bp->test_hit, t_hit, bp->mark_hit, m_hit);
 789 #endif
 790         fprintf(stderr, "%16llu extents (%llu bytes)\n",
 791                 count, ((count * sizeof(struct bmap_rb_extent)) +
 792                         sizeof(struct ext2fs_rb_private)));
 793         fprintf(stderr, "%16llu bits minimum size\n",
 794                 min_size);
 795         fprintf(stderr, "%16llu bits maximum size\n"
 796                 "%16llu bits average size\n",
 797                 max_size, avg_size);
 798         fprintf(stderr, "%16llu bits set in bitmap (out of %llu)\n", size,
 799                 bitmap->real_end - bitmap->start);
 800         fprintf(stderr,
 801                 "%16.4lf memory / bitmap bit memory ratio (bitarray = 1)\n",
 802                 eff);
 803 }
 804 #else
 805 static void rb_print_stats(ext2fs_generic_bitmap bitmap){}
 806 #endif
 807
 808 struct ext2_bitmap_ops ext2fs_blkmap64_rbtree = {
 809         .type = EXT2FS_BMAP64_RBTREE,
 810         .new_bmap = rb_new_bmap,
 811         .free_bmap = rb_free_bmap,
 812         .copy_bmap = rb_copy_bmap,
 813         .resize_bmap = rb_resize_bmap,
 814         .mark_bmap = rb_mark_bmap,
 815         .unmark_bmap = rb_unmark_bmap,
 816         .test_bmap = rb_test_bmap,
 817         .test_clear_bmap_extent = rb_test_clear_bmap_extent,
 818         .mark_bmap_extent = rb_mark_bmap_extent,
 819         .unmark_bmap_extent = rb_unmark_bmap_extent,
 820         .set_bmap_range = rb_set_bmap_range,
 821         .get_bmap_range = rb_get_bmap_range,
 822         .clear_bmap = rb_clear_bmap,
 823         .print_stats = rb_print_stats,
 824 };