[Ocfs2-tools-commits] jlbec commits r352 - in trunk: fsck.ocfs2
libocfs2 libocfs2/include
svn-commits at oss.oracle.com
svn-commits at oss.oracle.com
Thu Oct 28 20:26:05 CDT 2004
Author: jlbec
Date: 2004-10-28 20:26:03 -0500 (Thu, 28 Oct 2004)
New Revision: 352
Modified:
trunk/fsck.ocfs2/pass0.c
trunk/fsck.ocfs2/pass4.c
trunk/libocfs2/bitmap.c
trunk/libocfs2/include/bitmap.h
trunk/libocfs2/include/ocfs2.h
Log:
o Change sparse bitmaps to align on bytes, not blocks or clusters.
o Add find_next_clear.
Modified: trunk/fsck.ocfs2/pass0.c
===================================================================
--- trunk/fsck.ocfs2/pass0.c 2004-10-29 00:46:38 UTC (rev 351)
+++ trunk/fsck.ocfs2/pass0.c 2004-10-29 01:26:03 UTC (rev 352)
@@ -449,8 +449,6 @@
if (ret)
exit(FSCK_ERROR);
- if (di)
- ocfs2_free(&di);
if (blocks)
ocfs2_free(&blocks);
Modified: trunk/fsck.ocfs2/pass4.c
===================================================================
--- trunk/fsck.ocfs2/pass4.c 2004-10-29 00:46:38 UTC (rev 351)
+++ trunk/fsck.ocfs2/pass4.c 2004-10-29 01:26:03 UTC (rev 352)
@@ -45,7 +45,7 @@
printf("Pass 4: Checking inodes link counts.\n");
for (ino = 0;
- ocfs2_bitmap_find_next_set(ost->ost_used_inodes, ino, &ino) != 0;
+ ocfs2_bitmap_find_next_set(ost->ost_used_inodes, ino, &ino) == 0;
ino++) {
/*
* XXX e2fsck skips some inodes by their presence in other
Modified: trunk/libocfs2/bitmap.c
===================================================================
--- trunk/libocfs2/bitmap.c 2004-10-29 00:46:38 UTC (rev 351)
+++ trunk/libocfs2/bitmap.c 2004-10-29 01:26:03 UTC (rev 352)
@@ -43,20 +43,20 @@
void ocfs2_bitmap_free(ocfs2_bitmap *bitmap)
{
struct rb_node *node;
- struct ocfs2_bitmap_cluster *bc;
+ struct ocfs2_bitmap_region *br;
if (bitmap->b_ops->destroy_notify)
(*bitmap->b_ops->destroy_notify)(bitmap);
/*
- * If the bitmap needs to do extra cleanup of clusters,
+ * If the bitmap needs to do extra cleanup of region,
* it should have done it in destroy_notify
*/
- while ((node = rb_first(&bitmap->b_clusters)) != NULL) {
- bc = rb_entry(node, struct ocfs2_bitmap_cluster, bc_node);
+ while ((node = rb_first(&bitmap->b_regions)) != NULL) {
+ br = rb_entry(node, struct ocfs2_bitmap_region, br_node);
- rb_erase(&bc->bc_node, &bitmap->b_clusters);
- ocfs2_bitmap_free_cluster(bc);
+ rb_erase(&br->br_node, &bitmap->b_regions);
+ ocfs2_bitmap_free_region(br);
}
ocfs2_free(&bitmap->b_description);
@@ -118,12 +118,26 @@
return ret;
}
-int ocfs2_bitmap_find_next_set(ocfs2_bitmap *bitmap, uint64_t start,
- uint64_t *found)
+errcode_t ocfs2_bitmap_find_next_set(ocfs2_bitmap *bitmap,
+ uint64_t start,
+ uint64_t *found)
{
+ if (start >= bitmap->b_total_bits)
+ return OCFS2_ET_INVALID_BIT;
+
return (*bitmap->b_ops->find_next_set)(bitmap, start, found);
}
+errcode_t ocfs2_bitmap_find_next_clear(ocfs2_bitmap *bitmap,
+ uint64_t start,
+ uint64_t *found)
+{
+ if (start >= bitmap->b_total_bits)
+ return OCFS2_ET_INVALID_BIT;
+
+ return (*bitmap->b_ops->find_next_clear)(bitmap, start, found);
+}
+
uint64_t ocfs2_bitmap_get_set_bits(ocfs2_bitmap *bitmap)
{
return bitmap->b_set_bits;
@@ -158,7 +172,7 @@
bitmap->b_fs = fs;
bitmap->b_total_bits = total_bits;
bitmap->b_ops = ops;
- bitmap->b_clusters = RB_ROOT;
+ bitmap->b_regions = RB_ROOT;
bitmap->b_private = private_data;
if (description) {
ret = ocfs2_malloc0(sizeof(char) *
@@ -179,162 +193,156 @@
return ret;
}
-static uint64_t ocfs2_bits_to_clusters(ocfs2_bitmap *bitmap,
- int num_bits)
+static void ocfs2_region_align(uint64_t *start_bit, int *total_bits)
{
- uint64_t bpos;
- int bpc;
- uint32_t cpos;
+ uint64_t byte_mask = ~7ULL;
- bpc = bitmap->b_fs->fs_clustersize * 8;
- cpos = ((unsigned int)num_bits + (bpc - 1)) / bpc;
- bpos = (uint64_t)cpos * bpc;
+ if (start_bit)
+ *start_bit &= byte_mask;
- return bpos;
+ if (total_bits) {
+ *total_bits += 7;
+ *total_bits &= (int)byte_mask;
+ }
+
}
-errcode_t ocfs2_bitmap_alloc_cluster(ocfs2_bitmap *bitmap,
- uint64_t start_bit,
- int total_bits,
- struct ocfs2_bitmap_cluster **ret_bc)
+errcode_t ocfs2_bitmap_alloc_region(ocfs2_bitmap *bitmap,
+ uint64_t start_bit,
+ int total_bits,
+ struct ocfs2_bitmap_region **ret_br)
{
errcode_t ret;
- struct ocfs2_bitmap_cluster *bc;
- uint64_t real_bits;
+ struct ocfs2_bitmap_region *br;
if (total_bits < 0)
return OCFS2_ET_INVALID_BIT;
- real_bits = ocfs2_bits_to_clusters(bitmap, total_bits);
- if (real_bits > INT_MAX)
- return OCFS2_ET_INVALID_BIT;
+ ocfs2_region_align(&start_bit, &total_bits);
- ret = ocfs2_malloc0(sizeof(struct ocfs2_bitmap_cluster), &bc);
+ ret = ocfs2_malloc0(sizeof(struct ocfs2_bitmap_region), &br);
if (ret)
return ret;
- start_bit &= ~((bitmap->b_fs->fs_clustersize * 8) - 1);
- bc->bc_start_bit = ocfs2_bits_to_clusters(bitmap, start_bit);
- bc->bc_total_bits = real_bits;
+ br->br_start_bit = start_bit;
+ br->br_total_bits = total_bits;
- ret = ocfs2_malloc0((size_t)real_bits / 8, &bc->bc_bitmap);
+ ret = ocfs2_malloc0(br->br_total_bits / 8, &br->br_bitmap);
if (ret)
- ocfs2_free(&bc);
+ ocfs2_free(&br);
else
- *ret_bc = bc;
+ *ret_br = br;
return ret;
}
-void ocfs2_bitmap_free_cluster(struct ocfs2_bitmap_cluster *bc)
+void ocfs2_bitmap_free_region(struct ocfs2_bitmap_region *br)
{
- if (bc->bc_bitmap)
- ocfs2_free(&bc->bc_bitmap);
- ocfs2_free(&bc);
+ if (br->br_bitmap)
+ ocfs2_free(&br->br_bitmap);
+ ocfs2_free(&br);
}
-errcode_t ocfs2_bitmap_realloc_cluster(ocfs2_bitmap *bitmap,
- struct ocfs2_bitmap_cluster *bc,
- int total_bits)
+errcode_t ocfs2_bitmap_realloc_region(ocfs2_bitmap *bitmap,
+ struct ocfs2_bitmap_region *br,
+ int total_bits)
{
errcode_t ret;
- uint64_t real_bits;
- if ((bc->bc_start_bit + total_bits) > bitmap->b_total_bits)
+ if ((br->br_start_bit + total_bits) > bitmap->b_total_bits)
return OCFS2_ET_INVALID_BIT;
- real_bits = ocfs2_bits_to_clusters(bitmap, total_bits);
- if (real_bits > INT_MAX)
- return OCFS2_ET_INVALID_BIT;
+ ocfs2_region_align(NULL, &total_bits);
- if (real_bits > bc->bc_total_bits) {
- ret = ocfs2_realloc0((size_t)real_bits / 8,
- &bc->bc_bitmap,
- bc->bc_total_bits / 8);
+ if (total_bits > br->br_total_bits) {
+ ret = ocfs2_realloc0(total_bits / 8,
+ &br->br_bitmap,
+ br->br_total_bits / 8);
if (ret)
return ret;
- bc->bc_total_bits = (int)real_bits;
+ br->br_total_bits = total_bits;
}
return 0;
}
/*
- * Attempt to merge two clusters. If the merge is successful, 0 will
- * be returned and prev will be the only valid cluster. Next will
+ * Attempt to merge two regions. If the merge is successful, 0 will
+ * be returned and prev will be the only valid region. Next will
* be freed.
*/
-static errcode_t ocfs2_bitmap_merge_cluster(ocfs2_bitmap *bitmap,
- struct ocfs2_bitmap_cluster *prev,
- struct ocfs2_bitmap_cluster *next)
+static errcode_t ocfs2_bitmap_merge_region(ocfs2_bitmap *bitmap,
+ struct ocfs2_bitmap_region *prev,
+ struct ocfs2_bitmap_region *next)
{
errcode_t ret;
uint64_t new_bits;
int prev_bits;
- if ((prev->bc_start_bit + prev->bc_total_bits) !=
- next->bc_start_bit)
+ if ((prev->br_start_bit + prev->br_total_bits) !=
+ next->br_start_bit)
return OCFS2_ET_INVALID_BIT;
- if (bitmap->b_ops->merge_cluster &&
- !(*bitmap->b_ops->merge_cluster)(bitmap, prev, next))
+ if (bitmap->b_ops->merge_region &&
+ !(*bitmap->b_ops->merge_region)(bitmap, prev, next))
return OCFS2_ET_INVALID_BIT;
- new_bits = (uint64_t)(prev->bc_total_bits) +
- (uint64_t)(next->bc_total_bits);
+ new_bits = (uint64_t)(prev->br_total_bits) +
+ (uint64_t)(next->br_total_bits);
if (new_bits > INT_MAX)
return OCFS2_ET_INVALID_BIT;
- prev_bits = prev->bc_total_bits;
- ret = ocfs2_bitmap_realloc_cluster(bitmap, prev, new_bits);
+ prev_bits = prev->br_total_bits;
+ ret = ocfs2_bitmap_realloc_region(bitmap, prev, (int)new_bits);
if (ret)
return ret;
- memcpy(prev->bc_bitmap + (prev_bits / 8), next->bc_bitmap,
- next->bc_total_bits / 8);
+ memcpy(prev->br_bitmap + (prev_bits / 8), next->br_bitmap,
+ next->br_total_bits / 8);
+ prev->br_set_bits = prev->br_set_bits + next->br_set_bits;
- rb_erase(&next->bc_node, &bitmap->b_clusters);
- ocfs2_bitmap_free_cluster(next);
+ rb_erase(&next->br_node, &bitmap->b_regions);
+ ocfs2_bitmap_free_region(next);
return 0;
}
/*
- * Find a bitmap cluster in the tree that intersects the bit region
+ * Find a bitmap_region in the tree that intersects the bit region
* that is passed in.
*
* _p and _parent are set so that callers can use rb_link_node and
* rb_insert_color to insert a node after finding that their bit
* wasn't found.
*
- * _next is only used if a bitmap_cluster isn't found. it is set
+ * _next is only used if a bitmap_region isn't found. it is set
* to the next node in the tree greater than the bitmap range
* that was searched.
*/
static
-struct ocfs2_bitmap_cluster *ocfs2_bitmap_lookup(ocfs2_bitmap *bitmap,
- uint64_t bitno,
- uint64_t total_bits,
- struct rb_node ***ret_p,
- struct rb_node **ret_parent,
- struct rb_node **ret_next)
+struct ocfs2_bitmap_region *ocfs2_bitmap_lookup(ocfs2_bitmap *bitmap,
+ uint64_t bitno,
+ uint64_t total_bits,
+ struct rb_node ***ret_p,
+ struct rb_node **ret_parent,
+ struct rb_node **ret_next)
{
- struct rb_node **p = &bitmap->b_clusters.rb_node;
+ struct rb_node **p = &bitmap->b_regions.rb_node;
struct rb_node *parent = NULL, *last_left = NULL;
- struct ocfs2_bitmap_cluster *bc = NULL;
+ struct ocfs2_bitmap_region *br = NULL;
while (*p)
{
parent = *p;
- bc = rb_entry(parent, struct ocfs2_bitmap_cluster, bc_node);
+ br = rb_entry(parent, struct ocfs2_bitmap_region, br_node);
- if (bitno + total_bits <= bc->bc_start_bit) {
+ if (bitno + total_bits <= br->br_start_bit) {
p = &(*p)->rb_left;
last_left = *p;
- bc = NULL;
- } else if (bitno >= (bc->bc_start_bit + bc->bc_total_bits)) {
+ br = NULL;
+ } else if (bitno >= (br->br_start_bit + br->br_total_bits)) {
p = &(*p)->rb_right;
- bc = NULL;
+ br = NULL;
} else
break;
}
@@ -342,41 +350,42 @@
*ret_p = p;
if (ret_parent != NULL)
*ret_parent = parent;
- if (bc == NULL && ret_next != NULL)
+ if (br == NULL && ret_next != NULL)
*ret_next = last_left;
- return bc;
+ return br;
}
-errcode_t ocfs2_bitmap_insert_cluster(ocfs2_bitmap *bitmap,
- struct ocfs2_bitmap_cluster *bc)
+errcode_t ocfs2_bitmap_insert_region(ocfs2_bitmap *bitmap,
+ struct ocfs2_bitmap_region *br)
{
- struct ocfs2_bitmap_cluster *bc_tmp;
+ struct ocfs2_bitmap_region *br_tmp;
struct rb_node **p, *parent, *node;
- if (bc->bc_start_bit > bitmap->b_total_bits)
+ if (br->br_start_bit > bitmap->b_total_bits)
return OCFS2_ET_INVALID_BIT;
- /* we shouldn't find an existing cluster that intersects our new one */
- bc_tmp = ocfs2_bitmap_lookup(bitmap, bc->bc_start_bit,
- bc->bc_total_bits, &p, &parent, NULL);
- if (bc_tmp)
+ /* we shouldn't find an existing region that intersects our new one */
+ br_tmp = ocfs2_bitmap_lookup(bitmap, br->br_start_bit,
+ br->br_total_bits, &p, &parent, NULL);
+ if (br_tmp)
return OCFS2_ET_INVALID_BIT;
- rb_link_node(&bc->bc_node, parent, p);
- rb_insert_color(&bc->bc_node, &bitmap->b_clusters);
+ rb_link_node(&br->br_node, parent, p);
+ rb_insert_color(&br->br_node, &bitmap->b_regions);
/* try to merge our new extent with its neighbours in the tree */
- node = rb_prev(&bc->bc_node);
+ node = rb_prev(&br->br_node);
if (node) {
- bc_tmp = rb_entry(node, struct ocfs2_bitmap_cluster, bc_node);
- ocfs2_bitmap_merge_cluster(bitmap, bc_tmp, bc);
+ br_tmp = rb_entry(node, struct ocfs2_bitmap_region, br_node);
+ ocfs2_bitmap_merge_region(bitmap, br_tmp, br);
+ br = br_tmp;
}
- node = rb_next(&bc->bc_node);
+ node = rb_next(&br->br_node);
if (node != NULL) {
- bc_tmp = rb_entry(node, struct ocfs2_bitmap_cluster, bc_node);
- ocfs2_bitmap_merge_cluster(bitmap, bc, bc_tmp);
+ br_tmp = rb_entry(node, struct ocfs2_bitmap_region, br_node);
+ ocfs2_bitmap_merge_region(bitmap, br, br_tmp);
}
return 0;
@@ -390,20 +399,20 @@
errcode_t ocfs2_bitmap_set_generic(ocfs2_bitmap *bitmap, uint64_t bitno,
int *oldval)
{
- struct ocfs2_bitmap_cluster *bc;
+ struct ocfs2_bitmap_region *br;
int old_tmp;
- bc = ocfs2_bitmap_lookup(bitmap, bitno, 1, NULL, NULL, NULL);
- if (!bc)
+ br = ocfs2_bitmap_lookup(bitmap, bitno, 1, NULL, NULL, NULL);
+ if (!br)
return OCFS2_ET_INVALID_BIT;
- old_tmp = ocfs2_set_bit(bitno - bc->bc_start_bit,
- bc->bc_bitmap);
+ old_tmp = ocfs2_set_bit(bitno - br->br_start_bit,
+ br->br_bitmap);
if (oldval)
*oldval = old_tmp;
if (!old_tmp)
- bc->bc_set_bits++;
+ br->br_set_bits++;
return 0;
}
@@ -411,20 +420,20 @@
errcode_t ocfs2_bitmap_clear_generic(ocfs2_bitmap *bitmap,
uint64_t bitno, int *oldval)
{
- struct ocfs2_bitmap_cluster *bc;
+ struct ocfs2_bitmap_region *br;
int old_tmp;
- bc = ocfs2_bitmap_lookup(bitmap, bitno, 1, NULL, NULL, NULL);
- if (!bc)
+ br = ocfs2_bitmap_lookup(bitmap, bitno, 1, NULL, NULL, NULL);
+ if (!br)
return OCFS2_ET_INVALID_BIT;
- old_tmp = ocfs2_clear_bit(bitno - bc->bc_start_bit,
- bc->bc_bitmap);
+ old_tmp = ocfs2_clear_bit(bitno - br->br_start_bit,
+ br->br_bitmap);
if (oldval)
*oldval = old_tmp;
if (old_tmp)
- bc->bc_set_bits--;
+ br->br_set_bits--;
return 0;
}
@@ -432,47 +441,97 @@
errcode_t ocfs2_bitmap_test_generic(ocfs2_bitmap *bitmap,
uint64_t bitno, int *val)
{
- struct ocfs2_bitmap_cluster *bc;
+ struct ocfs2_bitmap_region *br;
- bc = ocfs2_bitmap_lookup(bitmap, bitno, 1, NULL, NULL, NULL);
- if (!bc)
+ br = ocfs2_bitmap_lookup(bitmap, bitno, 1, NULL, NULL, NULL);
+ if (!br)
return OCFS2_ET_INVALID_BIT;
- *val = ocfs2_test_bit(bitno - bc->bc_start_bit,
- bc->bc_bitmap) ? 1 : 0;
+ *val = ocfs2_test_bit(bitno - br->br_start_bit,
+ br->br_bitmap) ? 1 : 0;
return 0;
}
-static int ocfs2_bitmap_find_next_set_generic(ocfs2_bitmap *bitmap,
- uint64_t start, uint64_t *found)
+static errcode_t ocfs2_bitmap_find_next_set_generic(ocfs2_bitmap *bitmap,
+ uint64_t start,
+ uint64_t *found)
{
- struct ocfs2_bitmap_cluster *bc;
+ struct ocfs2_bitmap_region *br;
struct rb_node *node = NULL;
int offset, ret;
- /* start from either the node whose's bc contains the bit or
+ /* start from either the node whose's br contains the bit or
* the next greatest node in the tree */
- bc = ocfs2_bitmap_lookup(bitmap, start, 1, NULL, NULL, &node);
- if (bc)
- node = &bc->bc_node;
+ br = ocfs2_bitmap_lookup(bitmap, start, 1, NULL, NULL, &node);
+ if (br)
+ node = &br->br_node;
for (; node != NULL; node = rb_next(node)) {
- bc = rb_entry(node, struct ocfs2_bitmap_cluster, bc_node);
+ br = rb_entry(node, struct ocfs2_bitmap_region, br_node);
- if (start > bc->bc_start_bit)
- offset = start - bc->bc_start_bit;
+ if (start > br->br_start_bit)
+ offset = start - br->br_start_bit;
else
offset = 0;
- ret = ocfs2_find_next_bit_set(bc->bc_bitmap, bc->bc_total_bits,
+ ret = ocfs2_find_next_bit_set(br->br_bitmap,
+ br->br_total_bits,
+ offset);
+ if (ret != br->br_total_bits) {
+ *found = br->br_start_bit + ret;
+ return 0;
+ }
+ }
+
+ return OCFS2_ET_BIT_NOT_FOUND;
+}
+
+static errcode_t ocfs2_bitmap_find_next_clear_generic(ocfs2_bitmap *bitmap,
+ uint64_t start,
+ uint64_t *found)
+{
+ struct ocfs2_bitmap_region *br;
+ struct rb_node *node = NULL;
+ uint64_t seen;
+ int offset, ret;
+
+ /* start from either the node whose's br contains the bit or
+ * the next greatest node in the tree */
+ br = ocfs2_bitmap_lookup(bitmap, start, 1, NULL, NULL, &node);
+ if (br)
+ node = &br->br_node;
+ else if (!node) {
+ /* There was nothing past start */
+ *found = start;
+ return 0;
+ }
+
+ seen = start;
+ for (; node != NULL; node = rb_next(node)) {
+ br = rb_entry(node, struct ocfs2_bitmap_region, br_node);
+
+ /* Did we find a hole? */
+ if (seen < br->br_start_bit) {
+ *found = seen;
+ return 0;
+ }
+
+ if (start > br->br_start_bit)
+ offset = start - br->br_start_bit;
+ else
+ offset = 0;
+
+ ret = ocfs2_find_next_bit_clear(br->br_bitmap,
+ br->br_total_bits,
offset);
- if (ret != bc->bc_total_bits) {
- *found = bc->bc_start_bit + ret;
- return 1;
+ if (ret != br->br_total_bits) {
+ *found = br->br_start_bit + ret;
+ return 0;
}
+ seen = br->br_start_bit + br->br_total_bits;
}
- return 0;
+ return OCFS2_ET_BIT_NOT_FOUND;
}
/*
@@ -483,16 +542,16 @@
uint64_t bitno, int *oldval)
{
errcode_t ret;
- struct ocfs2_bitmap_cluster *bc;
+ struct ocfs2_bitmap_region *br;
if (!ocfs2_bitmap_set_generic(bitmap, bitno, oldval))
return 0;
- ret = ocfs2_bitmap_alloc_cluster(bitmap, bitno, 1, &bc);
+ ret = ocfs2_bitmap_alloc_region(bitmap, bitno, 1, &br);
if (ret)
return ret;
- ret = ocfs2_bitmap_insert_cluster(bitmap, bc);
+ ret = ocfs2_bitmap_insert_region(bitmap, br);
if (ret)
return ret;
@@ -503,16 +562,16 @@
uint64_t bitno, int *oldval)
{
errcode_t ret;
- struct ocfs2_bitmap_cluster *bc;
+ struct ocfs2_bitmap_region *br;
if (!ocfs2_bitmap_clear_generic(bitmap, bitno, oldval))
return 0;
- ret = ocfs2_bitmap_alloc_cluster(bitmap, bitno, 1, &bc);
+ ret = ocfs2_bitmap_alloc_region(bitmap, bitno, 1, &br);
if (ret)
return ret;
- ret = ocfs2_bitmap_insert_cluster(bitmap, bc);
+ ret = ocfs2_bitmap_insert_region(bitmap, br);
return ret;
}
@@ -526,17 +585,27 @@
return 0;
}
-static int ocfs2_bitmap_find_next_set_holes(ocfs2_bitmap *bitmap,
- uint64_t start, uint64_t *found)
+static errcode_t ocfs2_bitmap_find_next_set_holes(ocfs2_bitmap *bitmap,
+ uint64_t start,
+ uint64_t *found)
{
return ocfs2_bitmap_find_next_set_generic(bitmap, start, found);
}
+static errcode_t ocfs2_bitmap_find_next_clear_holes(ocfs2_bitmap *bitmap,
+ uint64_t start,
+ uint64_t *found)
+{
+ return ocfs2_bitmap_find_next_clear_generic(bitmap, start,
+ found);
+}
+
static struct ocfs2_bitmap_operations global_cluster_ops = {
- .set_bit = ocfs2_bitmap_set_generic,
- .clear_bit = ocfs2_bitmap_clear_generic,
- .test_bit = ocfs2_bitmap_test_generic,
- .find_next_set = ocfs2_bitmap_find_next_set_generic,
+ .set_bit = ocfs2_bitmap_set_generic,
+ .clear_bit = ocfs2_bitmap_clear_generic,
+ .test_bit = ocfs2_bitmap_test_generic,
+ .find_next_set = ocfs2_bitmap_find_next_set_generic,
+ .find_next_clear = ocfs2_bitmap_find_next_clear_generic,
};
errcode_t ocfs2_cluster_bitmap_new(ocfs2_filesys *fs,
@@ -546,7 +615,7 @@
errcode_t ret;
ocfs2_bitmap *bitmap;
uint64_t max_bits, num_bits, bitoff, alloc_bits;
- struct ocfs2_bitmap_cluster *bc;
+ struct ocfs2_bitmap_region *br;
num_bits = fs->fs_clusters;
ret = ocfs2_bitmap_new(fs,
@@ -562,21 +631,19 @@
bitoff = 0;
max_bits = INT_MAX - (fs->fs_clustersize - 1);
while (bitoff < num_bits) {
- alloc_bits = ocfs2_bits_to_clusters(bitmap,
- num_bits);
+ alloc_bits = num_bits;
if (num_bits > max_bits)
alloc_bits = max_bits;
-
- ret = ocfs2_bitmap_alloc_cluster(bitmap, bitoff,
- alloc_bits, &bc);
+ ret = ocfs2_bitmap_alloc_region(bitmap, bitoff,
+ alloc_bits, &br);
if (ret) {
ocfs2_bitmap_free(bitmap);
return ret;
}
- ret = ocfs2_bitmap_insert_cluster(bitmap, bc);
+ ret = ocfs2_bitmap_insert_region(bitmap, br);
if (ret) {
- ocfs2_bitmap_free_cluster(bc);
+ ocfs2_bitmap_free_region(br);
ocfs2_bitmap_free(bitmap);
return ret;
}
@@ -591,10 +658,11 @@
static struct ocfs2_bitmap_operations global_block_ops = {
- .set_bit = ocfs2_bitmap_set_holes,
- .clear_bit = ocfs2_bitmap_clear_holes,
- .test_bit = ocfs2_bitmap_test_holes,
- .find_next_set = ocfs2_bitmap_find_next_set_holes,
+ .set_bit = ocfs2_bitmap_set_holes,
+ .clear_bit = ocfs2_bitmap_clear_holes,
+ .test_bit = ocfs2_bitmap_test_holes,
+ .find_next_set = ocfs2_bitmap_find_next_set_holes,
+ .find_next_clear = ocfs2_bitmap_find_next_clear_holes,
};
errcode_t ocfs2_block_bitmap_new(ocfs2_filesys *fs,
@@ -639,28 +707,29 @@
static void print_usage(void)
{
- fprintf(stderr, "bitmap [-n <num_bits>] [-a] <filename>\n");
+ fprintf(stderr,
+ "debug_bitmap [-a] <filename>\n");
}
extern int opterr, optind;
extern char *optarg;
-static void dump_clusters(ocfs2_bitmap *bitmap)
+static void dump_regions(ocfs2_bitmap *bitmap)
{
- struct ocfs2_bitmap_cluster *bc;
+ struct ocfs2_bitmap_region *br;
struct rb_node *node;
fprintf(stdout, "Bitmap \"%s\": total = %"PRIu64", set = %"PRIu64"\n",
bitmap->b_description, bitmap->b_total_bits,
bitmap->b_set_bits);
- for (node = rb_first(&bitmap->b_clusters);node; node = rb_next(node)) {
- bc = rb_entry(node, struct ocfs2_bitmap_cluster, bc_node);
+ for (node = rb_first(&bitmap->b_regions);node; node = rb_next(node)) {
+ br = rb_entry(node, struct ocfs2_bitmap_region, br_node);
fprintf(stdout,
"(start: %"PRIu64", n: %d, set: %d)\n",
- bc->bc_start_bit, bc->bc_total_bits,
- bc->bc_set_bits);
+ br->br_start_bit, br->br_total_bits,
+ br->br_set_bits);
}
}
@@ -746,11 +815,49 @@
return 0;
}
+static int try_op64(ocfs2_bitmap *bitmap,
+ errcode_t (*func)(ocfs2_bitmap *bitmap,
+ uint64_t bitno,
+ uint64_t *val),
+ char *bit_val, uint64_t *ret_val)
+{
+ errcode_t ret;
+ uint64_t bitno;
+ char *ptr;
+ if (!bit_val) {
+ fprintf(stderr, "You must provide a bit offset\n");
+ return 1;
+ }
+
+ bitno = read_number(bit_val);
+ if (!bitno) {
+ for (ptr = bit_val; *ptr; ptr++) {
+ if (*ptr != '0')
+ break;
+ }
+ if ((ptr == bit_val) || *ptr) {
+ fprintf(stderr, "Invalid bit offset: %s\n",
+ bit_val);
+ return 1;
+ }
+ }
+
+ ret = (*func)(bitmap, bitno, ret_val);
+ if (ret) {
+ com_err("try_op64", ret, "while setting bit %"PRIu64"\n", bitno);
+ return 1;
+ }
+
+ return 0;
+}
+
+
static void run_test(ocfs2_bitmap *bitmap)
{
char buf[256];
char *ptr, *cmd;
+ uint64_t val64;
int val;
while (1) {
@@ -785,10 +892,24 @@
fprintf(stdout, "Bit %s is %s\n",
ptr, val ? "set" : "clear");
}
+ } else if (!strcmp(cmd, "fns")) {
+ if (!try_op64(bitmap,
+ ocfs2_bitmap_find_next_set,
+ ptr, &val64)) {
+ fprintf(stdout, "Found %"PRIu64"\n",
+ val64);
+ }
+ } else if (!strcmp(cmd, "fnc")) {
+ if (!try_op64(bitmap,
+ ocfs2_bitmap_find_next_clear,
+ ptr, &val64)) {
+ fprintf(stdout, "Found %"PRIu64"\n",
+ val64);
+ }
} else if (!strcmp(cmd, "print")) {
print_bitmap(bitmap);
} else if (!strcmp(cmd, "dump")) {
- dump_clusters(bitmap);
+ dump_regions(bitmap);
} else if (!strcmp(cmd, "quit")) {
break;
} else {
Modified: trunk/libocfs2/include/bitmap.h
===================================================================
--- trunk/libocfs2/include/bitmap.h 2004-10-29 00:46:38 UTC (rev 351)
+++ trunk/libocfs2/include/bitmap.h 2004-10-29 01:26:03 UTC (rev 352)
@@ -29,18 +29,17 @@
#include "kernel-rbtree.h"
-struct ocfs2_bitmap_cluster {
- struct rb_node bc_node;
- uint64_t bc_start_bit; /* Bit offset. Must be
- aligned on
- (clustersize * 8) */
- int bc_total_bits; /* set_bit() and friends can't
+
+struct ocfs2_bitmap_region {
+ struct rb_node br_node;
+ uint64_t br_start_bit; /* Bit offset. Must be
+ byte-aligned */
+ int br_total_bits; /* set_bit() and friends can't
handle bitmaps larger than
int offsets */
- int bc_set_bits;
- char *bc_bitmap;
-
- void *bc_private;
+ int br_set_bits;
+ char *br_bitmap;
+ void *br_private;
};
struct ocfs2_bitmap_operations {
@@ -50,11 +49,13 @@
int *oldval);
errcode_t (*test_bit)(ocfs2_bitmap *bm, uint64_t bit,
int *val);
- int (*find_next_set)(ocfs2_bitmap *bm, uint64_t start,
- uint64_t *found);
- errcode_t (*merge_cluster)(ocfs2_bitmap *bm,
- struct ocfs2_bitmap_cluster *prev,
- struct ocfs2_bitmap_cluster *next);
+ errcode_t (*find_next_set)(ocfs2_bitmap *bm, uint64_t start,
+ uint64_t *found);
+ errcode_t (*find_next_clear)(ocfs2_bitmap *bm, uint64_t start,
+ uint64_t *found);
+ errcode_t (*merge_region)(ocfs2_bitmap *bm,
+ struct ocfs2_bitmap_region *prev,
+ struct ocfs2_bitmap_region *next);
errcode_t (*read_bitmap)(ocfs2_bitmap *bm);
errcode_t (*write_bitmap)(ocfs2_bitmap *bm);
void (*destroy_notify)(ocfs2_bitmap *bm);
@@ -71,7 +72,7 @@
from if it is a
physical bitmap
inode */
- struct rb_root b_clusters;
+ struct rb_root b_regions;
void *b_private;
};
@@ -82,16 +83,16 @@
struct ocfs2_bitmap_operations *ops,
void *private_data,
ocfs2_bitmap **ret_bitmap);
-errcode_t ocfs2_bitmap_alloc_cluster(ocfs2_bitmap *bitmap,
- uint64_t start_bit,
- int total_bits,
- struct ocfs2_bitmap_cluster **ret_bc);
-void ocfs2_bitmap_free_cluster(struct ocfs2_bitmap_cluster *bc);
-errcode_t ocfs2_bitmap_realloc_cluster(ocfs2_bitmap *bitmap,
- struct ocfs2_bitmap_cluster *bc,
- int total_bits);
-errcode_t ocfs2_bitmap_insert_cluster(ocfs2_bitmap *bitmap,
- struct ocfs2_bitmap_cluster *bc);
+errcode_t ocfs2_bitmap_alloc_region(ocfs2_bitmap *bitmap,
+ uint64_t start_bit,
+ int total_bits,
+ struct ocfs2_bitmap_region **ret_br);
+void ocfs2_bitmap_free_region(struct ocfs2_bitmap_region *br);
+errcode_t ocfs2_bitmap_realloc_region(ocfs2_bitmap *bitmap,
+ struct ocfs2_bitmap_region *br,
+ int total_bits);
+errcode_t ocfs2_bitmap_insert_region(ocfs2_bitmap *bitmap,
+ struct ocfs2_bitmap_region *br);
errcode_t ocfs2_bitmap_set_generic(ocfs2_bitmap *bitmap,
uint64_t bitno, int *oldval);
errcode_t ocfs2_bitmap_clear_generic(ocfs2_bitmap *bitmap,
Modified: trunk/libocfs2/include/ocfs2.h
===================================================================
--- trunk/libocfs2/include/ocfs2.h 2004-10-29 00:46:38 UTC (rev 351)
+++ trunk/libocfs2/include/ocfs2.h 2004-10-29 01:26:03 UTC (rev 352)
@@ -365,8 +365,10 @@
int *oldval);
errcode_t ocfs2_bitmap_test(ocfs2_bitmap *bitmap, uint64_t bitno,
int *val);
-int ocfs2_bitmap_find_next_set(ocfs2_bitmap *bitmap, uint64_t start,
- uint64_t *found);
+errcode_t ocfs2_bitmap_find_next_set(ocfs2_bitmap *bitmap,
+ uint64_t start, uint64_t *found);
+errcode_t ocfs2_bitmap_find_next_clear(ocfs2_bitmap *bitmap,
+ uint64_t start, uint64_t *found);
uint64_t ocfs2_bitmap_get_set_bits(ocfs2_bitmap *bitmap);
errcode_t ocfs2_get_device_size(const char *file, int blocksize,
More information about the Ocfs2-tools-commits
mailing list