2 * blkmap64_rb.c --- Simple rb-tree implementation for bitmaps
4 * (C)2010 Red Hat, Inc., Lukas Czerner <lczerner@redhat.com>
7 * This file may be redistributed under the terms of the GNU Public
23 #include <sys/types.h>
33 struct bmap_rb_extent {
39 struct ext2fs_rb_private {
41 struct bmap_rb_extent **wcursor;
42 struct bmap_rb_extent **rcursor;
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);
53 /* #define DEBUG_RB */
56 static void print_tree(struct rb_root *root)
58 struct rb_node *node = NULL;
59 struct bmap_rb_extent *ext;
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);
69 printf("\t\t\t=================================\n");
72 static int check_tree(struct rb_root *root, const char *msg)
74 struct rb_node *new_node, *node, *next;
75 struct bmap_rb_extent *ext, *old = NULL;
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);
87 printf("Tree Error: start is crazy\n");
88 printf("extent: %llu -> %llu (%u)\n", ext->start,
89 ext->start + ext->count, ext->count);
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,
99 printf("extent next: %llu -> %llu (%u)\n",
100 ext->start, ext->start + ext->count,
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,
109 printf("extent next: %llu -> %llu (%u)\n",
110 ext->start, ext->start + ext->count,
125 #define check_tree(root, msg) 0
126 #define print_tree(root, msg) 0
129 static void rb_get_new_extent(struct bmap_rb_extent **ext, __u64 start,
132 struct bmap_rb_extent *new_ext;
135 retval = ext2fs_get_mem(sizeof (struct bmap_rb_extent),
138 perror("ext2fs_get_mem");
142 new_ext->start = start;
143 new_ext->count = count;
148 static void rb_free_extent(struct ext2fs_rb_private *bp,
149 struct bmap_rb_extent *ext)
151 if (*bp->wcursor == ext)
153 if (*bp->rcursor == ext)
155 ext2fs_free_mem(&ext);
158 static errcode_t rb_alloc_private_data (ext2fs_generic_bitmap bitmap)
160 struct ext2fs_rb_private *bp;
163 retval = ext2fs_get_mem(sizeof (struct ext2fs_rb_private), &bp);
168 retval = ext2fs_get_mem(sizeof(struct bmap_rb_extent *), &bp->rcursor);
171 retval = ext2fs_get_mem(sizeof(struct bmap_rb_extent *), &bp->wcursor);
177 #ifdef BMAP_STATS_OPS
182 bitmap->private = (void *) bp;
186 static errcode_t rb_new_bmap(ext2_filsys fs EXT2FS_ATTR((unused)),
187 ext2fs_generic_bitmap bitmap)
191 retval = rb_alloc_private_data (bitmap);
198 static void rb_free_tree(struct rb_root *root)
200 struct bmap_rb_extent *ext;
201 struct rb_node *node, *next;
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);
211 static void rb_free_bmap(ext2fs_generic_bitmap bitmap)
213 struct ext2fs_rb_private *bp;
215 bp = (struct ext2fs_rb_private *) bitmap->private;
217 rb_free_tree(&bp->root);
218 ext2fs_free_mem(&bp->rcursor);
219 ext2fs_free_mem(&bp->wcursor);
220 ext2fs_free_mem(&bp);
224 static errcode_t rb_copy_bmap(ext2fs_generic_bitmap src,
225 ext2fs_generic_bitmap dest)
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;
232 retval = rb_alloc_private_data (dest);
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;
241 src_node = ext2fs_rb_first(&src_bp->root);
243 src_ext = ext2fs_rb_entry(src_node, struct bmap_rb_extent, node);
244 retval = ext2fs_get_mem(sizeof (struct bmap_rb_extent),
249 memcpy(dest_ext, src_ext, sizeof(struct bmap_rb_extent));
251 dest_node = &dest_ext->node;
252 n = &dest_bp->root.rb_node;
256 dest_last = ext2fs_rb_last(&dest_bp->root);
257 n = &(dest_last)->rb_right;
260 ext2fs_rb_link_node(dest_node, dest_last, n);
261 ext2fs_rb_insert_color(dest_node, &dest_bp->root);
263 src_node = ext2fs_rb_next(src_node);
269 static void rb_truncate(__u64 new_max, struct rb_root *root)
271 struct bmap_rb_extent *ext;
272 struct rb_node *node;
274 node = ext2fs_rb_last(root);
276 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
278 if ((ext->start + ext->count - 1) <= new_max)
280 else if (ext->start > new_max) {
281 ext2fs_rb_erase(node, root);
282 ext2fs_free_mem(&ext);
283 node = ext2fs_rb_last(root);
286 ext->count = new_max - ext->start + 1;
290 static errcode_t rb_resize_bmap(ext2fs_generic_bitmap bmap,
291 __u64 new_end, __u64 new_real_end)
293 struct ext2fs_rb_private *bp;
295 if (new_real_end >= bmap->real_end) {
297 bmap->real_end = new_real_end;
301 bp = (struct ext2fs_rb_private *) bmap->private;
305 /* truncate tree to new_real_end size */
306 rb_truncate(new_real_end, &bp->root);
309 bmap->real_end = new_real_end;
315 rb_test_bit(struct ext2fs_rb_private *bp, __u64 bit)
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;
322 rcursor = *bp->rcursor;
326 if (bit >= rcursor->start && bit < rcursor->start + rcursor->count) {
327 #ifdef BMAP_STATS_OPS
333 rcursor = *bp->wcursor;
337 if (bit >= rcursor->start && bit < rcursor->start + rcursor->count)
344 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
345 if (bit < ext->start)
347 else if (bit >= (ext->start + ext->count))
357 static int rb_insert_extent(__u64 start, __u64 count,
358 struct ext2fs_rb_private *bp)
360 struct rb_root *root = &bp->root;
361 struct rb_node *parent = NULL, **n = &root->rb_node;
362 struct rb_node *new_node, *node, *next;
363 struct bmap_rb_extent *new_ext;
364 struct bmap_rb_extent *ext;
369 if (start >= ext->start &&
370 start <= (ext->start + ext->count)) {
371 #ifdef BMAP_STATS_OPS
380 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
382 if (start < ext->start) {
384 } else if (start > (ext->start + ext->count)) {
388 if ((start + count) <= (ext->start + ext->count))
391 if ((ext->start + ext->count) == start)
396 count += (start - ext->start);
399 new_node = &ext->node;
405 rb_get_new_extent(&new_ext, start, count);
407 new_node = &new_ext->node;
408 ext2fs_rb_link_node(new_node, parent, n);
409 ext2fs_rb_insert_color(new_node, root);
410 *bp->wcursor = new_ext;
412 node = ext2fs_rb_prev(new_node);
414 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
415 if ((ext->start + ext->count) == start) {
418 ext2fs_rb_erase(node, root);
419 rb_free_extent(bp, ext);
424 /* See if we can merge extent to the right */
425 for (node = ext2fs_rb_next(new_node); node != NULL; node = next) {
426 next = ext2fs_rb_next(node);
427 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
429 if ((ext->start + ext->count) <= start)
432 /* No more merging */
433 if ((start + count) < ext->start)
436 /* ext is embedded in new_ext interval */
437 if ((start + count) >= (ext->start + ext->count)) {
438 ext2fs_rb_erase(node, root);
439 rb_free_extent(bp, ext);
442 /* merge ext with new_ext */
443 count += ((ext->start + ext->count) -
445 ext2fs_rb_erase(node, root);
446 rb_free_extent(bp, ext);
451 new_ext->start = start;
452 new_ext->count = count;
457 static int rb_remove_extent(__u64 start, __u64 count,
458 struct ext2fs_rb_private *bp)
460 struct rb_root *root = &bp->root;
461 struct rb_node *parent = NULL, **n = &root->rb_node;
462 struct rb_node *node;
463 struct bmap_rb_extent *ext;
464 __u64 new_start, new_count;
467 if (EXT2FS_RB_EMPTY_ROOT(root))
472 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
473 if (start < ext->start) {
476 } else if (start >= (ext->start + ext->count)) {
481 if ((start > ext->start) &&
482 (start + count) < (ext->start + ext->count)) {
483 /* We have to split extent into two */
484 new_start = start + count;
485 new_count = (ext->start + ext->count) - new_start;
487 ext->count = start - ext->start;
489 rb_insert_extent(new_start, new_count, bp);
493 if ((start + count) >= (ext->start + ext->count)) {
494 ext->count = start - ext->start;
498 if (0 == ext->count) {
499 parent = ext2fs_rb_next(&ext->node);
500 ext2fs_rb_erase(&ext->node, root);
501 rb_free_extent(bp, ext);
505 if (start == ext->start) {
512 /* See if we should delete or truncate extent on the right */
513 for (; parent != NULL; parent = node) {
514 node = ext2fs_rb_next(parent);
515 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
516 if ((ext->start + ext->count) <= start)
519 /* No more extents to be removed/truncated */
520 if ((start + count) < ext->start)
523 /* The entire extent is within the region to be removed */
524 if ((start + count) >= (ext->start + ext->count)) {
525 ext2fs_rb_erase(parent, root);
526 rb_free_extent(bp, ext);
530 /* modify the last extent in reigon to be removed */
531 ext->count -= ((start + count) - ext->start);
532 ext->start = start + count;
541 static int rb_mark_bmap(ext2fs_generic_bitmap bitmap, __u64 arg)
543 struct ext2fs_rb_private *bp;
545 bp = (struct ext2fs_rb_private *) bitmap->private;
546 arg -= bitmap->start;
548 return rb_insert_extent(arg, 1, bp);
551 static int rb_unmark_bmap(ext2fs_generic_bitmap bitmap, __u64 arg)
553 struct ext2fs_rb_private *bp;
556 bp = (struct ext2fs_rb_private *) bitmap->private;
557 arg -= bitmap->start;
559 retval = rb_remove_extent(arg, 1, bp);
560 check_tree(&bp->root, __func__);
566 static int rb_test_bmap(ext2fs_generic_bitmap bitmap, __u64 arg)
568 struct ext2fs_rb_private *bp;
570 bp = (struct ext2fs_rb_private *) bitmap->private;
571 arg -= bitmap->start;
573 return rb_test_bit(bp, arg);
576 static void rb_mark_bmap_extent(ext2fs_generic_bitmap bitmap, __u64 arg,
579 struct ext2fs_rb_private *bp;
581 bp = (struct ext2fs_rb_private *) bitmap->private;
582 arg -= bitmap->start;
584 rb_insert_extent(arg, num, bp);
587 static void rb_unmark_bmap_extent(ext2fs_generic_bitmap bitmap, __u64 arg,
590 struct ext2fs_rb_private *bp;
592 bp = (struct ext2fs_rb_private *) bitmap->private;
593 arg -= bitmap->start;
595 rb_remove_extent(arg, num, bp);
596 check_tree(&bp->root, __func__);
599 static int rb_test_clear_bmap_extent(ext2fs_generic_bitmap bitmap,
600 __u64 start, unsigned int len)
602 struct rb_node *parent = NULL, **n;
603 struct rb_node *node, *next;
604 struct ext2fs_rb_private *bp;
605 struct bmap_rb_extent *ext;
608 bp = (struct ext2fs_rb_private *) bitmap->private;
609 n = &bp->root.rb_node;
610 start -= bitmap->start;
612 if ((len == 0) || EXT2FS_RB_EMPTY_ROOT(&bp->root))
616 * If we find nothing, we should examine whole extent, but
617 * when we find match, the extent is not clean, thus be return
622 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
623 if (start < ext->start) {
625 } else if (start >= (ext->start + ext->count)) {
629 * We found extent int the tree -> extent is not
638 next = ext2fs_rb_next(node);
639 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
642 if ((ext->start + ext->count) <= start)
645 /* No more merging */
646 if ((start + len) <= ext->start)
655 static errcode_t rb_set_bmap_range(ext2fs_generic_bitmap bitmap,
656 __u64 start, size_t num, void *in)
658 struct ext2fs_rb_private *bp;
662 bp = (struct ext2fs_rb_private *) bitmap->private;
664 for (i = 0; i < num; i++) {
665 ret = ext2fs_test_bit(i, in);
667 rb_insert_extent(start + i - bitmap->start, 1, bp);
673 static errcode_t rb_get_bmap_range(ext2fs_generic_bitmap bitmap,
674 __u64 start, size_t num, void *out)
677 struct rb_node *parent = NULL, *next, **n;
678 struct ext2fs_rb_private *bp;
679 struct bmap_rb_extent *ext;
682 bp = (struct ext2fs_rb_private *) bitmap->private;
683 n = &bp->root.rb_node;
684 start -= bitmap->start;
686 if (EXT2FS_RB_EMPTY_ROOT(&bp->root))
691 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
692 if (start < ext->start) {
694 } else if (start >= (ext->start + ext->count)) {
701 for (; parent != NULL; parent = next) {
702 next = ext2fs_rb_next(parent);
703 ext = ext2fs_rb_entry(parent, struct bmap_rb_extent, node);
705 while (((pos - start) < num) &&
706 (pos < ext->start)) {
707 ext2fs_fast_clear_bit64((pos - start), out);
711 if ((pos - start) >= num)
714 while (((pos - start) < num) &&
715 (pos < (ext->start + ext->count))) {
716 ext2fs_fast_set_bit64((pos - start), out);
721 while ((pos - start) < num) {
722 ext2fs_fast_clear_bit64((pos - start), out);
729 static void rb_clear_bmap(ext2fs_generic_bitmap bitmap)
731 struct ext2fs_rb_private *bp;
733 bp = (struct ext2fs_rb_private *) bitmap->private;
735 rb_free_tree(&bp->root);
741 static void rb_print_stats(ext2fs_generic_bitmap bitmap)
743 struct ext2fs_rb_private *bp;
744 struct rb_node *node = NULL;
745 struct bmap_rb_extent *ext;
748 __u64 min_size = ULONG_MAX;
749 __u64 size = 0, avg_size = 0;
751 #ifdef BMAP_STATS_OPS
752 __u64 mark_all, test_all;
753 double m_hit = 0.0, t_hit = 0.0;
756 bp = (struct ext2fs_rb_private *) bitmap->private;
758 node = ext2fs_rb_first(&bp->root);
759 for (node = ext2fs_rb_first(&bp->root); node != NULL;
760 node = ext2fs_rb_next(node)) {
761 ext = ext2fs_rb_entry(node, struct bmap_rb_extent, node);
763 if (ext->count > max_size)
764 max_size = ext->count;
765 if (ext->count < min_size)
766 min_size = ext->count;
771 avg_size = size / count;
772 if (min_size == ULONG_MAX)
774 eff = (double)((count * sizeof(struct bmap_rb_extent)) << 3) /
775 (bitmap->real_end - bitmap->start);
776 #ifdef BMAP_STATS_OPS
777 mark_all = bitmap->stats.mark_count + bitmap->stats.mark_ext_count;
778 test_all = bitmap->stats.test_count + bitmap->stats.test_ext_count;
780 m_hit = ((double)bp->mark_hit / mark_all) * 100;
782 t_hit = ((double)bp->test_hit / test_all) * 100;
784 fprintf(stderr, "%16llu cache hits on test (%.2f%%)\n"
785 "%16llu cache hits on mark (%.2f%%)\n",
786 bp->test_hit, t_hit, bp->mark_hit, m_hit);
788 fprintf(stderr, "%16llu extents (%llu bytes)\n",
789 count, ((count * sizeof(struct bmap_rb_extent)) +
790 sizeof(struct ext2fs_rb_private)));
791 fprintf(stderr, "%16llu bits minimum size\n",
793 fprintf(stderr, "%16llu bits maximum size\n"
794 "%16llu bits average size\n",
796 fprintf(stderr, "%16llu bits set in bitmap (out of %llu)\n", size,
797 bitmap->real_end - bitmap->start);
799 "%16.4lf memory / bitmap bit memory ratio (bitarray = 1)\n",
803 static void rb_print_stats(ext2fs_generic_bitmap bitmap){}
806 struct ext2_bitmap_ops ext2fs_blkmap64_rbtree = {
807 .type = EXT2FS_BMAP64_RBTREE,
808 .new_bmap = rb_new_bmap,
809 .free_bmap = rb_free_bmap,
810 .copy_bmap = rb_copy_bmap,
811 .resize_bmap = rb_resize_bmap,
812 .mark_bmap = rb_mark_bmap,
813 .unmark_bmap = rb_unmark_bmap,
814 .test_bmap = rb_test_bmap,
815 .test_clear_bmap_extent = rb_test_clear_bmap_extent,
816 .mark_bmap_extent = rb_mark_bmap_extent,
817 .unmark_bmap_extent = rb_unmark_bmap_extent,
818 .set_bmap_range = rb_set_bmap_range,
819 .get_bmap_range = rb_get_bmap_range,
820 .clear_bmap = rb_clear_bmap,
821 .print_stats = rb_print_stats,