radix_tree: api change

Instead of using 'key state & key end' uint8_t* switch to use
void* key, & size_t keylen.  This allows easier adaptation with
lvm code base with way too much casting with every use of function.

Also correctly mark const buffers to avoid compiled warnings and
casting.

Adapt the only bcache user ATM for API change.

Adapt unit test to match changed API.

diff --git a/base/data-struct/radix-tree-adaptive.c b/base/data-struct/radix-tree-adaptive.c
index 944ae18d3c43e0e8e8ea64bf4867bfbe24cbb5c1..f03c00f27af55858fedd3f9b49f706fa927092a4 100644 (file)
--- a/base/data-struct/radix-tree-adaptive.c
+++ b/base/data-struct/radix-tree-adaptive.c
@@ -178,9 +178,9 @@ unsigned radix_tree_size(struct radix_tree *rt)
        return rt->nr_entries;
 }
 
-static bool _insert(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv);
+static bool _insert(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv);
 
-static bool _insert_unset(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
+static bool _insert_unset(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
 {
        unsigned len = ke - kb;
 
@@ -207,7 +207,7 @@ static bool _insert_unset(struct radix_tree *rt, struct value *v, uint8_t *kb, u
        return true;
 }
 
-static bool _insert_value(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
+static bool _insert_value(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
 {
        unsigned len = ke - kb;
 
@@ -234,7 +234,7 @@ static bool _insert_value(struct radix_tree *rt, struct value *v, uint8_t *kb, u
        return true;
 }
 
-static bool _insert_value_chain(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
+static bool _insert_value_chain(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
 {
        struct value_chain *vc = v->value.ptr;
        return _insert(rt, &vc->child, kb, ke, rv);
@@ -248,7 +248,7 @@ static unsigned min(unsigned lhs, unsigned rhs)
                return rhs;
 }
 
-static bool _insert_prefix_chain(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
+static bool _insert_prefix_chain(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
 {
        struct prefix_chain *pc = v->value.ptr;
 
@@ -313,7 +313,7 @@ static bool _insert_prefix_chain(struct radix_tree *rt, struct value *v, uint8_t
        return true;
 }
 
-static bool _insert_node4(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
+static bool _insert_node4(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
 {
        struct node4 *n4 = v->value.ptr;
        if (n4->nr_entries == 4) {
@@ -343,7 +343,7 @@ static bool _insert_node4(struct radix_tree *rt, struct value *v, uint8_t *kb, u
        return true;
 }
 
-static bool _insert_node16(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
+static bool _insert_node16(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
 {
        struct node16 *n16 = v->value.ptr;
 
@@ -382,7 +382,7 @@ static bool _insert_node16(struct radix_tree *rt, struct value *v, uint8_t *kb,
        return true;
 }
 
-static bool _insert_node48(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
+static bool _insert_node48(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
 {
        struct node48 *n48 = v->value.ptr;
        if (n48->nr_entries == 48) {
@@ -417,7 +417,7 @@ static bool _insert_node48(struct radix_tree *rt, struct value *v, uint8_t *kb,
        return true;
 }
 
-static bool _insert_node256(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
+static bool _insert_node256(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
 {
        struct node256 *n256 = v->value.ptr;
        bool r, was_unset = n256->values[*kb].type == UNSET;
@@ -430,7 +430,7 @@ static bool _insert_node256(struct radix_tree *rt, struct value *v, uint8_t *kb,
 }
 
 // FIXME: the tree should not be touched if insert fails (eg, OOM)
-static bool _insert(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t *ke, union radix_value rv)
+static bool _insert(struct radix_tree *rt, struct value *v, const uint8_t *kb, const uint8_t *ke, union radix_value rv)
 {
        if (kb == ke) {
                if (v->type == UNSET) {
@@ -487,10 +487,10 @@ static bool _insert(struct radix_tree *rt, struct value *v, uint8_t *kb, uint8_t
 
 struct lookup_result {
        struct value *v;
-       uint8_t *kb;
+       const uint8_t *kb;
 };
 
-static struct lookup_result _lookup_prefix(struct value *v, uint8_t *kb, uint8_t *ke)
+static struct lookup_result _lookup_prefix(struct value *v, const uint8_t *kb, const uint8_t *ke)
 {
        unsigned i;
        struct value_chain *vc;
@@ -555,8 +555,10 @@ static struct lookup_result _lookup_prefix(struct value *v, uint8_t *kb, uint8_t
        return (struct lookup_result) {.v = v, .kb = kb};
 }
 
-bool radix_tree_insert(struct radix_tree *rt, uint8_t *kb, uint8_t *ke, union radix_value rv)
+bool radix_tree_insert(struct radix_tree *rt, const void *key, size_t keylen, union radix_value rv)
 {
+       const uint8_t *kb = key;
+       const uint8_t *ke = kb + keylen;
        struct lookup_result lr = _lookup_prefix(&rt->root, kb, ke);
        return _insert(rt, lr.v, lr.kb, ke, rv);
 }
@@ -639,7 +641,7 @@ static void _erase_elt(void *array, size_t obj_size, unsigned count, unsigned id
        memset(((uint8_t *) array) + (count - 1) * obj_size, 0, obj_size);
 }
 
-static bool _remove(struct radix_tree *rt, struct value *root, uint8_t *kb, uint8_t *ke)
+static bool _remove(struct radix_tree *rt, struct value *root, const uint8_t *kb, const uint8_t *ke)
 {
        bool r;
        unsigned i, j;
@@ -775,9 +777,12 @@ static bool _remove(struct radix_tree *rt, struct value *root, uint8_t *kb, uint
        return false;
 }
 
-bool radix_tree_remove(struct radix_tree *rt, uint8_t *key_begin, uint8_t *key_end)
+bool radix_tree_remove(struct radix_tree *rt, const void *key, size_t keylen)
 {
-       if (_remove(rt, &rt->root, key_begin, key_end)) {
+       const uint8_t *kb = key;
+       const uint8_t *ke = kb + keylen;
+
+       if (_remove(rt, &rt->root, kb, ke)) {
                rt->nr_entries--;
                return true;
        }
@@ -787,13 +792,13 @@ bool radix_tree_remove(struct radix_tree *rt, uint8_t *key_begin, uint8_t *key_e
 
 //----------------------------------------------------------------
 
-static bool _prefix_chain_matches(struct lookup_result *lr, uint8_t *ke)
+static bool _prefix_chain_matches(const struct lookup_result *lr, const uint8_t *ke)
 {
        // It's possible the top node is a prefix chain, and
        // the remaining key matches part of it.
        if (lr->v->type == PREFIX_CHAIN) {
                unsigned i, rlen = ke - lr->kb;
-               struct prefix_chain *pc = lr->v->value.ptr;
+               const struct prefix_chain *pc = lr->v->value.ptr;
                if (rlen < pc->len) {
                        for (i = 0; i < rlen; i++)
                                if (pc->prefix[i] != lr->kb[i])
@@ -805,7 +810,7 @@ static bool _prefix_chain_matches(struct lookup_result *lr, uint8_t *ke)
        return false;
 }
 
-static bool _remove_subtree(struct radix_tree *rt, struct value *root, uint8_t *kb, uint8_t *ke, unsigned *count)
+static bool _remove_subtree(struct radix_tree *rt, struct value *root, const uint8_t *kb, const uint8_t *ke, unsigned *count)
 {
        bool r;
        unsigned i, j, len;
@@ -931,8 +936,10 @@ static bool _remove_subtree(struct radix_tree *rt, struct value *root, uint8_t *
        return false;
 }
 
-unsigned radix_tree_remove_prefix(struct radix_tree *rt, uint8_t *kb, uint8_t *ke)
+unsigned radix_tree_remove_prefix(struct radix_tree *rt, const void *prefix, size_t prefix_len)
 {
+       const uint8_t *kb = prefix;
+       const uint8_t *ke = kb + prefix_len;
        unsigned count = 0;
 
        if (_remove_subtree(rt, &rt->root, kb, ke, &count))
@@ -943,9 +950,11 @@ unsigned radix_tree_remove_prefix(struct radix_tree *rt, uint8_t *kb, uint8_t *k
 
 //----------------------------------------------------------------
 
-bool radix_tree_lookup(struct radix_tree *rt,
-                      uint8_t *kb, uint8_t *ke, union radix_value *result)
+bool radix_tree_lookup(struct radix_tree *rt, const void *key, size_t keylen,
+                      union radix_value *result)
 {
+       const uint8_t *kb = key;
+       const uint8_t *ke = kb + keylen;
        struct value_chain *vc;
        struct lookup_result lr = _lookup_prefix(&rt->root, kb, ke);
        if (lr.kb == ke) {
@@ -984,11 +993,11 @@ static bool _iterate(struct value *v, struct radix_tree_iterator *it)
                break;
 
        case VALUE:
-               return it->visit(it, NULL, NULL, v->value);
+               return it->visit(it, NULL, 0, v->value);
 
        case VALUE_CHAIN:
                vc = v->value.ptr;
-               return it->visit(it, NULL, NULL, vc->value) && _iterate(&vc->child, it);
+               return it->visit(it, NULL, 0, vc->value) && _iterate(&vc->child, it);
 
        case PREFIX_CHAIN:
                pc = v->value.ptr;
@@ -1027,9 +1036,11 @@ static bool _iterate(struct value *v, struct radix_tree_iterator *it)
        return false;
 }
 
-void radix_tree_iterate(struct radix_tree *rt, uint8_t *kb, uint8_t *ke,
+void radix_tree_iterate(struct radix_tree *rt, const void *key, size_t keylen,
                        struct radix_tree_iterator *it)
 {
+       const uint8_t *kb = key;
+       const uint8_t *ke = kb + keylen;
        struct lookup_result lr = _lookup_prefix(&rt->root, kb, ke);
        if (lr.kb == ke || _prefix_chain_matches(&lr, ke))
                (void) _iterate(lr.v, it);

diff --git a/base/data-struct/radix-tree-simple.c b/base/data-struct/radix-tree-simple.c
index 5a55c9b4529163ce9abdda4196d1048dbe15a8fb..d2dc0ee18e5be8d218eb7c068d195c8192eaa4da 100644 (file)
--- a/base/data-struct/radix-tree-simple.c
+++ b/base/data-struct/radix-tree-simple.c
@@ -104,7 +104,7 @@ unsigned radix_tree_size(struct radix_tree *rt)
        return _count(rt->root);
 }
 
-static struct node **_lookup(struct node **pn, uint8_t *kb, uint8_t *ke)
+static struct node **_lookup(struct node **pn, const uint8_t *kb, const uint8_t *ke)
 {
        struct node *n = *pn;
 
@@ -121,7 +121,7 @@ static struct node **_lookup(struct node **pn, uint8_t *kb, uint8_t *ke)
                return _lookup(&n->center, kb + 1, ke);
 }
 
-static bool _insert(struct node **pn, uint8_t *kb, uint8_t *ke, union radix_value v)
+static bool _insert(struct node **pn, const uint8_t *kb, const uint8_t *ke, union radix_value v)
 {
        struct node *n = *pn;
 
@@ -150,14 +150,19 @@ static bool _insert(struct node **pn, uint8_t *kb, uint8_t *ke, union radix_valu
                return _insert(&n->center, kb + 1, ke, v);
 }
 
-bool radix_tree_insert(struct radix_tree *rt, uint8_t *kb, uint8_t *ke,
+bool radix_tree_insert(struct radix_tree *rt, const void *key, size_t keylen,
                       union radix_value v)
 {
+       const uint8_t *kb = key;
+       const uint8_t *ke = kb + keylen;
+
        return _insert(&rt->root, kb, ke, v);
 }
 
-bool radix_tree_remove(struct radix_tree *rt, uint8_t *kb, uint8_t *ke)
+bool radix_tree_remove(struct radix_tree *rt, const void *key, size_t keylen)
 {
+       const uint8_t *kb = key;
+       const uint8_t *ke = kb + keylen;
        struct node **pn = _lookup(&rt->root, kb, ke);
        struct node *n = *pn;
 
@@ -180,8 +185,10 @@ bool radix_tree_remove(struct radix_tree *rt, uint8_t *kb, uint8_t *ke)
        return true;
 }
 
-unsigned radix_tree_remove_prefix(struct radix_tree *rt, uint8_t *kb, uint8_t *ke)
+unsigned radix_tree_remove_prefix(struct radix_tree *rt, const void *key, size_t keylen)
 {
+       const uint8_t *kb = key;
+       const uint8_t *ke = kb + keylen;
        struct node **pn;
        unsigned count;
 
@@ -195,9 +202,11 @@ unsigned radix_tree_remove_prefix(struct radix_tree *rt, uint8_t *kb, uint8_t *k
        return count;
 }
 
-bool radix_tree_lookup(struct radix_tree *rt, uint8_t *kb, uint8_t *ke,
+bool radix_tree_lookup(struct radix_tree *rt, const void *key, size_t keylen,
                       union radix_value *result)
 {
+       const uint8_t *kb = key;
+       const uint8_t *ke = kb + keylen;
        struct node **pn = _lookup(&rt->root, kb, ke);
        struct node *n = *pn;
 
@@ -218,15 +227,18 @@ static void _iterate(struct node *n, struct radix_tree_iterator *it)
 
        if (n->has_value)
                // FIXME: fill out the key
-               it->visit(it, NULL, NULL, n->value);
+               it->visit(it, NULL, 0, n->value);
 
        _iterate(n->center, it);
        _iterate(n->right, it);
 }
 
-void radix_tree_iterate(struct radix_tree *rt, uint8_t *kb, uint8_t *ke,
+void radix_tree_iterate(struct radix_tree *rt, const void *key, size_t keylen,
                         struct radix_tree_iterator *it)
 {
+       const uint8_t *kb = key;
+       const uint8_t *ke = kb + keylen;
+
        if (kb == ke)
                _iterate(rt->root, it);
 
@@ -236,7 +248,7 @@ void radix_tree_iterate(struct radix_tree *rt, uint8_t *kb, uint8_t *ke,
 
                if (n) {
                        if (n->has_value)
-                               it->visit(it, NULL, NULL, n->value);
+                               it->visit(it, NULL, 0, n->value);
                        _iterate(n->center, it);
                }
        }

diff --git a/base/data-struct/radix-tree.h b/base/data-struct/radix-tree.h
index cf0c526ed57d423b0c59a4537fc9b61a1a7a6a8d..bfc2a0d0cca82769e81e50ca7d87ef7f1d1d7c0b 100644 (file)
--- a/base/data-struct/radix-tree.h
+++ b/base/data-struct/radix-tree.h
@@ -33,14 +33,14 @@ struct radix_tree *radix_tree_create(radix_value_dtr dtr, void *dtr_context);
 void radix_tree_destroy(struct radix_tree *rt);
 
 unsigned radix_tree_size(struct radix_tree *rt);
-bool radix_tree_insert(struct radix_tree *rt, uint8_t *kb, uint8_t *ke, union radix_value v);
-bool radix_tree_remove(struct radix_tree *rt, uint8_t *kb, uint8_t *ke);
+bool radix_tree_insert(struct radix_tree *rt, const void *key, size_t keylen, union radix_value v);
+bool radix_tree_remove(struct radix_tree *rt, const void *key, size_t keylen);
 
 // Returns the number of values removed
-unsigned radix_tree_remove_prefix(struct radix_tree *rt, uint8_t *prefix_b, uint8_t *prefix_e);
+unsigned radix_tree_remove_prefix(struct radix_tree *rt, const void *prefix, size_t prefix_len);
 
-bool radix_tree_lookup(struct radix_tree *rt,
-                      uint8_t *kb, uint8_t *ke, union radix_value *result);
+bool radix_tree_lookup(struct radix_tree *rt, const void *key, size_t keylen,
+                      union radix_value *result);
 
 // The radix tree stores entries in lexicographical order.  Which means
 // we can iterate entries, in order.  Or iterate entries with a particular
@@ -48,10 +48,10 @@ bool radix_tree_lookup(struct radix_tree *rt,
 struct radix_tree_iterator {
        // Returns false if the iteration should end.
        bool (*visit)(struct radix_tree_iterator *it,
-                      uint8_t *kb, uint8_t *ke, union radix_value v);
+                     const void *key, size_t keylen, union radix_value v);
 };
 
-void radix_tree_iterate(struct radix_tree *rt, uint8_t *kb, uint8_t *ke,
+void radix_tree_iterate(struct radix_tree *rt, const void *key, size_t keylen,
                        struct radix_tree_iterator *it);
 
 // Checks that some constraints on the shape of the tree are

diff --git a/lib/device/bcache.c b/lib/device/bcache.c
index 62a0b6870888beab26ba93aeaa3ca25bb4680938..a458958e1c2604dae76855f75d0cbcf3add7755e 100644 (file)
--- a/lib/device/bcache.c
+++ b/lib/device/bcache.c
@@ -711,7 +711,7 @@ static struct block *_block_lookup(struct bcache *cache, int di, uint64_t i)
        k.parts.di = di;
        k.parts.b = i;
 
-       if (radix_tree_lookup(cache->rtree, k.bytes, k.bytes + sizeof(k.bytes), &v))
+       if (radix_tree_lookup(cache->rtree, k.bytes, sizeof(k.bytes), &v))
                return v.ptr;
 
        return NULL;
@@ -726,7 +726,7 @@ static bool _block_insert(struct block *b)
         k.parts.b = b->index;
         v.ptr = b;
 
-       return radix_tree_insert(b->cache->rtree, k.bytes, k.bytes + sizeof(k.bytes), v);
+       return radix_tree_insert(b->cache->rtree, k.bytes, sizeof(k.bytes), v);
 }
 
 static void _block_remove(struct block *b)
@@ -736,7 +736,7 @@ static void _block_remove(struct block *b)
         k.parts.di = b->di;
         k.parts.b = b->index;
 
-       (void) radix_tree_remove(b->cache->rtree, k.bytes, k.bytes + sizeof(k.bytes));
+       (void) radix_tree_remove(b->cache->rtree, k.bytes, sizeof(k.bytes));
 }
 
 //----------------------------------------------------------------
@@ -1353,7 +1353,7 @@ struct invalidate_iterator {
 };
 
 static bool _writeback_v(struct radix_tree_iterator *it,
-                         uint8_t *kb, uint8_t *ke, union radix_value v)
+                         const void *kb, size_t keylen, union radix_value v)
 {
        struct block *b = v.ptr;
 
@@ -1364,7 +1364,7 @@ static bool _writeback_v(struct radix_tree_iterator *it,
 }
 
 static bool _invalidate_v(struct radix_tree_iterator *it,
-                          uint8_t *kb, uint8_t *ke, union radix_value v)
+                          const void *kb, size_t keylen, union radix_value v)
 {
        struct block *b = v.ptr;
        struct invalidate_iterator *iit = container_of(it, struct invalidate_iterator, it);
@@ -1399,16 +1399,16 @@ bool bcache_invalidate_di(struct bcache *cache, int di)
        k.parts.di = di;
 
        it.it.visit = _writeback_v;
-       radix_tree_iterate(cache->rtree, k.bytes, k.bytes + sizeof(k.parts.di), &it.it);
+       radix_tree_iterate(cache->rtree, k.bytes, sizeof(k.parts.di), &it.it);
 
        _wait_all(cache);
 
        it.success = true;
        it.it.visit = _invalidate_v;
-       radix_tree_iterate(cache->rtree, k.bytes, k.bytes + sizeof(k.parts.di), &it.it);
+       radix_tree_iterate(cache->rtree, k.bytes, sizeof(k.parts.di), &it.it);
 
        if (it.success)
-               (void) radix_tree_remove_prefix(cache->rtree, k.bytes, k.bytes + sizeof(k.parts.di));
+               (void) radix_tree_remove_prefix(cache->rtree, k.bytes, sizeof(k.parts.di));
 
        return it.success;
 }
@@ -1416,7 +1416,7 @@ bool bcache_invalidate_di(struct bcache *cache, int di)
 //----------------------------------------------------------------
 
 static bool _abort_v(struct radix_tree_iterator *it,
-                     uint8_t *kb, uint8_t *ke, union radix_value v)
+                     const void *kb, size_t keylen, union radix_value v)
 {
        struct block *b = v.ptr;
 
@@ -1442,8 +1442,8 @@ void bcache_abort_di(struct bcache *cache, int di)
        k.parts.di = di;
 
        it.visit = _abort_v;
-       radix_tree_iterate(cache->rtree, k.bytes, k.bytes + sizeof(k.parts.di), &it);
-       (void) radix_tree_remove_prefix(cache->rtree, k.bytes, k.bytes + sizeof(k.parts.di));
+       radix_tree_iterate(cache->rtree, k.bytes, sizeof(k.parts.di), &it);
+       (void) radix_tree_remove_prefix(cache->rtree, k.bytes, sizeof(k.parts.di));
 }
 
 //----------------------------------------------------------------

diff --git a/test/unit/radix_tree_t.c b/test/unit/radix_tree_t.c
index b80e4f8ab68e7f83d1e1ddc184453baf40a8c366..ea033c7d2d8c5609cdd35800b971f5a456897a97 100644 (file)
--- a/test/unit/radix_tree_t.c
+++ b/test/unit/radix_tree_t.c
@@ -43,10 +43,10 @@ static void test_insert_one(void *fixture)
        union radix_value v;
        unsigned char k = 'a';
        v.n = 65;
-       T_ASSERT(radix_tree_insert(rt, &k, &k + 1, v));
+       T_ASSERT(radix_tree_insert(rt, &k, 1, v));
        T_ASSERT(radix_tree_is_well_formed(rt));
        v.n = 0;
-       T_ASSERT(radix_tree_lookup(rt, &k, &k + 1, &v));
+       T_ASSERT(radix_tree_lookup(rt, &k, 1, &v));
        T_ASSERT_EQUAL(v.n, 65);
 }
 
@@ -60,14 +60,14 @@ static void test_single_byte_keys(void *fixture)
        for (i = 0; i < count; i++) {
                k = i;
                v.n = 100 + i;
-               T_ASSERT(radix_tree_insert(rt, &k, &k + 1, v));
+               T_ASSERT(radix_tree_insert(rt, &k, 1, v));
        }
 
        T_ASSERT(radix_tree_is_well_formed(rt));
 
        for (i = 0; i < count; i++) {
                k = i;
-               T_ASSERT(radix_tree_lookup(rt, &k, &k + 1, &v));
+               T_ASSERT(radix_tree_lookup(rt, &k, 1, &v));
                T_ASSERT_EQUAL(v.n, 100 + i);
        }
 }
@@ -82,7 +82,7 @@ static void test_overwrite_single_byte_keys(void *fixture)
        for (i = 0; i < count; i++) {
                k = i;
                v.n = 100 + i;
-               T_ASSERT(radix_tree_insert(rt, &k, &k + 1, v));
+               T_ASSERT(radix_tree_insert(rt, &k, 1, v));
        }
 
        T_ASSERT(radix_tree_is_well_formed(rt));
@@ -90,14 +90,14 @@ static void test_overwrite_single_byte_keys(void *fixture)
        for (i = 0; i < count; i++) {
                k = i;
                v.n = 1000 + i;
-               T_ASSERT(radix_tree_insert(rt, &k, &k + 1, v));
+               T_ASSERT(radix_tree_insert(rt, &k, 1, v));
        }
 
        T_ASSERT(radix_tree_is_well_formed(rt));
 
        for (i = 0; i < count; i++) {
                k = i;
-               T_ASSERT(radix_tree_lookup(rt, &k, &k + 1, &v));
+               T_ASSERT(radix_tree_lookup(rt, &k, 1, &v));
                T_ASSERT_EQUAL(v.n, 1000 + i);
        }
 }
@@ -113,7 +113,7 @@ static void test_16_bit_keys(void *fixture)
                k[0] = i / 256;
                k[1] = i % 256;
                v.n = 100 + i;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        }
 
        T_ASSERT(radix_tree_is_well_formed(rt));
@@ -121,7 +121,7 @@ static void test_16_bit_keys(void *fixture)
        for (i = 0; i < count; i++) {
                k[0] = i / 256;
                k[1] = i % 256;
-               T_ASSERT(radix_tree_lookup(rt, k, k + sizeof(k), &v));
+               T_ASSERT(radix_tree_lookup(rt, k, sizeof(k), &v));
                T_ASSERT_EQUAL(v.n, 100 + i);
        }
 }
@@ -135,14 +135,14 @@ static void test_prefix_keys(void *fixture)
        k[0] = 100;
        k[1] = 200;
        v.n = 1024;
-       T_ASSERT(radix_tree_insert(rt, k, k + 1, v));
+       T_ASSERT(radix_tree_insert(rt, k, 1, v));
        T_ASSERT(radix_tree_is_well_formed(rt));
        v.n = 2345;
-       T_ASSERT(radix_tree_insert(rt, k, k + 2, v));
+       T_ASSERT(radix_tree_insert(rt, k, 2, v));
        T_ASSERT(radix_tree_is_well_formed(rt));
-       T_ASSERT(radix_tree_lookup(rt, k, k + 1, &v));
+       T_ASSERT(radix_tree_lookup(rt, k, 1, &v));
        T_ASSERT_EQUAL(v.n, 1024);
-       T_ASSERT(radix_tree_lookup(rt, k, k + 2, &v));
+       T_ASSERT(radix_tree_lookup(rt, k, 2, &v));
        T_ASSERT_EQUAL(v.n, 2345);
 }
 
@@ -155,14 +155,14 @@ static void test_prefix_keys_reversed(void *fixture)
        k[0] = 100;
        k[1] = 200;
        v.n = 1024;
-       T_ASSERT(radix_tree_insert(rt, k, k + 2, v));
+       T_ASSERT(radix_tree_insert(rt, k, 2, v));
        T_ASSERT(radix_tree_is_well_formed(rt));
        v.n = 2345;
-       T_ASSERT(radix_tree_insert(rt, k, k + 1, v));
+       T_ASSERT(radix_tree_insert(rt, k, 1, v));
        T_ASSERT(radix_tree_is_well_formed(rt));
-       T_ASSERT(radix_tree_lookup(rt, k, k + 2, &v));
+       T_ASSERT(radix_tree_lookup(rt, k, 2, &v));
        T_ASSERT_EQUAL(v.n, 1024);
-       T_ASSERT(radix_tree_lookup(rt, k, k + 1, &v));
+       T_ASSERT(radix_tree_lookup(rt, k, 1, &v));
        T_ASSERT_EQUAL(v.n, 2345);
 }
 
@@ -183,7 +183,7 @@ static void test_sparse_keys(void *fixture)
        for (n = 0; n < 100000; n++) {
                _gen_key(k, k + sizeof(k));
                v.n = 1234;
-               T_ASSERT(radix_tree_insert(rt, k, k + 32, v));
+               T_ASSERT(radix_tree_insert(rt, k, 32, v));
                // FIXME: remove
                //T_ASSERT(radix_tree_is_well_formed(rt));
        }
@@ -198,11 +198,11 @@ static void test_remove_one(void *fixture)
 
        _gen_key(k, k + sizeof(k));
        v.n = 1234;
-       T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+       T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        T_ASSERT(radix_tree_is_well_formed(rt));
-       T_ASSERT(radix_tree_remove(rt, k, k + sizeof(k)));
+       T_ASSERT(radix_tree_remove(rt, k, sizeof(k)));
        T_ASSERT(radix_tree_is_well_formed(rt));
-       T_ASSERT(!radix_tree_lookup(rt, k, k + sizeof(k), &v));
+       T_ASSERT(!radix_tree_lookup(rt, k, sizeof(k), &v));
 }
 
 static void test_remove_one_byte_keys(void *fixture)
@@ -215,18 +215,18 @@ static void test_remove_one_byte_keys(void *fixture)
        for (i = 0; i < 256; i++) {
                k[0] = i;
                v.n = i + 1000;
-               T_ASSERT(radix_tree_insert(rt, k, k + 1, v));
+               T_ASSERT(radix_tree_insert(rt, k, 1, v));
        }
 
        T_ASSERT(radix_tree_is_well_formed(rt));
        for (i = 0; i < 256; i++) {
                k[0] = i;
-               T_ASSERT(radix_tree_remove(rt, k, k + 1));
+               T_ASSERT(radix_tree_remove(rt, k, 1));
                T_ASSERT(radix_tree_is_well_formed(rt));
 
                for (j = i + 1; j < 256; j++) {
                        k[0] = j;
-                       T_ASSERT(radix_tree_lookup(rt, k, k + 1, &v));
+                       T_ASSERT(radix_tree_lookup(rt, k, 1, &v));
                        if (v.n != j + 1000)
                                test_fail("v.n (%u) != j + 1000 (%u)\n",
                                           (unsigned) v.n,
@@ -236,7 +236,7 @@ static void test_remove_one_byte_keys(void *fixture)
 
        for (i = 0; i < 256; i++) {
                k[0] = i;
-               T_ASSERT(!radix_tree_lookup(rt, k, k + 1, &v));
+               T_ASSERT(!radix_tree_lookup(rt, k, 1, &v));
        }
 }
 
@@ -250,18 +250,18 @@ static void test_remove_one_byte_keys_reversed(void *fixture)
        for (i = 0; i < 256; i++) {
                k[0] = i;
                v.n = i + 1000;
-               T_ASSERT(radix_tree_insert(rt, k, k + 1, v));
+               T_ASSERT(radix_tree_insert(rt, k, 1, v));
        }
 
        T_ASSERT(radix_tree_is_well_formed(rt));
        for (i = 256; i; i--) {
                k[0] = i - 1;
-               T_ASSERT(radix_tree_remove(rt, k, k + 1));
+               T_ASSERT(radix_tree_remove(rt, k, 1));
                T_ASSERT(radix_tree_is_well_formed(rt));
 
                for (j = 0; j < i - 1; j++) {
                        k[0] = j;
-                       T_ASSERT(radix_tree_lookup(rt, k, k + 1, &v));
+                       T_ASSERT(radix_tree_lookup(rt, k, 1, &v));
                        if (v.n != j + 1000)
                                test_fail("v.n (%u) != j + 1000 (%u)\n",
                                           (unsigned) v.n,
@@ -271,7 +271,7 @@ static void test_remove_one_byte_keys_reversed(void *fixture)
 
        for (i = 0; i < 256; i++) {
                k[0] = i;
-               T_ASSERT(!radix_tree_lookup(rt, k, k + 1, &v));
+               T_ASSERT(!radix_tree_lookup(rt, k, 1, &v));
        }
 }
 static void test_remove_prefix_keys(void *fixture)
@@ -285,21 +285,21 @@ static void test_remove_prefix_keys(void *fixture)
 
        for (i = 0; i < 32; i++) {
                v.n = i;
-               T_ASSERT(radix_tree_insert(rt, k, k + i, v));
+               T_ASSERT(radix_tree_insert(rt, k, i, v));
        }
 
        T_ASSERT(radix_tree_is_well_formed(rt));
        for (i = 0; i < 32; i++) {
-               T_ASSERT(radix_tree_remove(rt, k, k + i));
+               T_ASSERT(radix_tree_remove(rt, k, i));
                T_ASSERT(radix_tree_is_well_formed(rt));
                for (j = i + 1; j < 32; j++) {
-                       T_ASSERT(radix_tree_lookup(rt, k, k + j, &v));
+                       T_ASSERT(radix_tree_lookup(rt, k, j, &v));
                        T_ASSERT_EQUAL(v.n, j);
                }
        }
 
         for (i = 0; i < 32; i++)
-                T_ASSERT(!radix_tree_lookup(rt, k, k + i, &v));
+                T_ASSERT(!radix_tree_lookup(rt, k, i, &v));
 }
 
 static void test_remove_prefix_keys_reversed(void *fixture)
@@ -313,21 +313,21 @@ static void test_remove_prefix_keys_reversed(void *fixture)
 
        for (i = 0; i < 32; i++) {
                v.n = i;
-               T_ASSERT(radix_tree_insert(rt, k, k + i, v));
+               T_ASSERT(radix_tree_insert(rt, k, i, v));
        }
 
        T_ASSERT(radix_tree_is_well_formed(rt));
        for (i = 0; i < 32; i++) {
-               T_ASSERT(radix_tree_remove(rt, k, k + (31 - i)));
+               T_ASSERT(radix_tree_remove(rt, k, (31 - i)));
                T_ASSERT(radix_tree_is_well_formed(rt));
                for (j = 0; j < 31 - i; j++) {
-                       T_ASSERT(radix_tree_lookup(rt, k, k + j, &v));
+                       T_ASSERT(radix_tree_lookup(rt, k, j, &v));
                        T_ASSERT_EQUAL(v.n, j);
                }
        }
 
         for (i = 0; i < 32; i++)
-                T_ASSERT(!radix_tree_lookup(rt, k, k + i, &v));
+                T_ASSERT(!radix_tree_lookup(rt, k, i, &v));
 }
 
 static void test_remove_prefix(void *fixture)
@@ -343,14 +343,14 @@ static void test_remove_prefix(void *fixture)
                if (k[0] == 21)
                        count++;
                v.n = i;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        }
 
        T_ASSERT(radix_tree_is_well_formed(rt));
 
        // remove keys in a sub range 
        k[0] = 21;
-       T_ASSERT_EQUAL(radix_tree_remove_prefix(rt, k, k + 1), count);
+       T_ASSERT_EQUAL(radix_tree_remove_prefix(rt, k, 1), count);
        T_ASSERT(radix_tree_is_well_formed(rt));
 }
 
@@ -362,9 +362,9 @@ static void test_remove_prefix_single(void *fixture)
 
        _gen_key(k, k + sizeof(k));
        v.n = 1234;
-       T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+       T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        T_ASSERT(radix_tree_is_well_formed(rt));
-       T_ASSERT_EQUAL(radix_tree_remove_prefix(rt, k, k + 2), 1);
+       T_ASSERT_EQUAL(radix_tree_remove_prefix(rt, k, 2), 1);
        T_ASSERT(radix_tree_is_well_formed(rt));
 }
 
@@ -378,10 +378,10 @@ static void test_size(void *fixture)
        // populate some random 16bit keys
        for (i = 0; i < 10000; i++) {
                _gen_key(k, k + sizeof(k));
-               if (radix_tree_lookup(rt, k, k + sizeof(k), &v))
+               if (radix_tree_lookup(rt, k, sizeof(k), &v))
                        dup_count++;
                v.n = i;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        }
 
        T_ASSERT_EQUAL(radix_tree_size(rt), 10000 - dup_count);
@@ -394,7 +394,7 @@ struct visitor {
 };
 
 static bool _visit(struct radix_tree_iterator *it,
-                   uint8_t *kb, uint8_t *ke, union radix_value v)
+                   const void *key, size_t keylen, union radix_value v)
 {
        struct visitor *vt = container_of(it, struct visitor, it);
        vt->count++;
@@ -413,13 +413,13 @@ static void test_iterate_all(void *fixture)
        for (i = 0; i < 100000; i++) {
                _gen_key(k, k + sizeof(k));
                v.n = i;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        }
 
        T_ASSERT(radix_tree_is_well_formed(rt));
        vt.count = 0;
        vt.it.visit = _visit;
-       radix_tree_iterate(rt, NULL, NULL, &vt.it);
+       radix_tree_iterate(rt, NULL, 0, &vt.it);
        T_ASSERT_EQUAL(vt.count, radix_tree_size(rt));
 }
 
@@ -437,7 +437,7 @@ static void test_iterate_subset(void *fixture)
                if (k[0] == 21 && k[1] == 12)
                        subset_count++;
                v.n = i;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        }
 
        T_ASSERT(radix_tree_is_well_formed(rt));
@@ -445,7 +445,7 @@ static void test_iterate_subset(void *fixture)
        vt.it.visit = _visit;
        k[0] = 21;
        k[1] = 12;
-       radix_tree_iterate(rt, k, k + 2, &vt.it);
+       radix_tree_iterate(rt, k, 2, &vt.it);
        T_ASSERT_EQUAL(vt.count, subset_count);
 }
 
@@ -458,12 +458,12 @@ static void test_iterate_single(void *fixture)
 
        _gen_key(k, k + sizeof(k));
        v.n = 1234;
-       T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+       T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
 
        T_ASSERT(radix_tree_is_well_formed(rt));
        vt.count = 0;
        vt.it.visit = _visit;
-       radix_tree_iterate(rt, k, k + 3, &vt.it);
+       radix_tree_iterate(rt, k, 3, &vt.it);
        T_ASSERT_EQUAL(vt.count, 1);
 }
 
@@ -479,7 +479,7 @@ static void test_iterate_vary_middle(void *fixture)
        for (i = 0; i < 16; i++) {
                k[3] = i;
                v.n = i;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        }
 
        T_ASSERT(radix_tree_is_well_formed(rt));
@@ -487,7 +487,7 @@ static void test_iterate_vary_middle(void *fixture)
        for (i = 0; i < 16; i++) {
                vt.count = 0;
                k[3] = i;
-               radix_tree_iterate(rt, k, k + 4, &vt.it);
+               radix_tree_iterate(rt, k, 4, &vt.it);
                T_ASSERT_EQUAL(vt.count, 1);
        }
 }
@@ -533,8 +533,8 @@ static void test_remove_calls_dtr(void *fixture)
                                v.n = i;
                                uint8_t *k = keys + (i * 3);
                                _gen_key(k, k + 3);
-                               if (!radix_tree_lookup(rt, k, k + 3, &v)) {
-                                       T_ASSERT(radix_tree_insert(rt, k, k + 3, v));
+                               if (!radix_tree_lookup(rt, k, 3, &v)) {
+                                       T_ASSERT(radix_tree_insert(rt, k, 3, v));
                                        found = true;
                                }
 
@@ -546,13 +546,13 @@ static void test_remove_calls_dtr(void *fixture)
                // double check
                for (i = 0; i < DTR_COUNT; i++) {
                        uint8_t *k = keys + (i * 3);
-                       T_ASSERT(radix_tree_lookup(rt, k, k + 3, &v));
+                       T_ASSERT(radix_tree_lookup(rt, k, 3, &v));
                }
 
                for (i = 0; i < DTR_COUNT; i++) {
                        uint8_t *k = keys + (i * 3);
                        // FIXME: check the values get passed to the dtr
-                       T_ASSERT(radix_tree_remove(rt, k, k + 3));
+                       T_ASSERT(radix_tree_remove(rt, k, 3));
                }
 
                T_ASSERT(c.c == DTR_COUNT);
@@ -587,8 +587,8 @@ static void test_destroy_calls_dtr(void *fixture)
                                v.n = i;
                                uint8_t *k = keys + (i * 3);
                                _gen_key(k, k + 3);
-                               if (!radix_tree_lookup(rt, k, k + 3, &v)) {
-                                       T_ASSERT(radix_tree_insert(rt, k, k + 3, v));
+                               if (!radix_tree_lookup(rt, k, 3, &v)) {
+                                       T_ASSERT(radix_tree_insert(rt, k, 3, v));
                                        found = true;
                                }
 
@@ -621,17 +621,17 @@ static void test_bcache_scenario(void *fixture)
                // trigger the bug.
                k[4] = i;
                v.n = i;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        }
        T_ASSERT(radix_tree_is_well_formed(rt));
 
        k[4] = 0;
-       T_ASSERT(radix_tree_remove(rt, k, k + sizeof(k)));
+       T_ASSERT(radix_tree_remove(rt, k, sizeof(k)));
        T_ASSERT(radix_tree_is_well_formed(rt));
 
        k[4] = i;
        v.n = i;
-       T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+       T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        T_ASSERT(radix_tree_is_well_formed(rt));
 }
 
@@ -647,7 +647,7 @@ static void _bcs2_step1(struct radix_tree *rt)
        for (i = 0x6; i < 0x69; i++) {
                k[0] = i;
                v.n = i;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        }
        T_ASSERT(radix_tree_is_well_formed(rt));
 }
@@ -660,7 +660,7 @@ static void _bcs2_step2(struct radix_tree *rt)
        memset(k, 0, sizeof(k));
        for (i = 0x6; i < 0x69; i++) {
                k[0] = i;
-               radix_tree_remove_prefix(rt, k, k + 4);
+               radix_tree_remove_prefix(rt, k, 4);
        }
        T_ASSERT(radix_tree_is_well_formed(rt));
 }
@@ -679,8 +679,8 @@ static void test_bcache_scenario2(void *fixture)
         for (i = 0; i < 50; i++) {
                k[0] = 0x6;
                v.n = 0x6;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
-               radix_tree_remove_prefix(rt, k, k + 4);
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
+               radix_tree_remove_prefix(rt, k, 4);
         }
         T_ASSERT(radix_tree_is_well_formed(rt));
 
@@ -694,10 +694,10 @@ static void test_bcache_scenario2(void *fixture)
                k[0] = i;
                k[4] = 0xf;
                k[5] = 0x1;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
                k[4] = 0;
                k[5] = 0;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        }
        T_ASSERT(radix_tree_is_well_formed(rt));
 
@@ -706,47 +706,47 @@ static void test_bcache_scenario2(void *fixture)
                k[0] = i - 0x32;
                k[4] = 0xf;
                k[5] = 1;
-               T_ASSERT(radix_tree_remove(rt, k, k + sizeof(k)));
+               T_ASSERT(radix_tree_remove(rt, k, sizeof(k)));
 
                k[0] = i;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
 
                k[0] = i - 0x32;
                k[4] = 0;
                k[5] = 0;
-               T_ASSERT(radix_tree_remove(rt, k, k + sizeof(k)));
+               T_ASSERT(radix_tree_remove(rt, k, sizeof(k)));
 
                k[0] = i;
-               T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+               T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        }
        T_ASSERT(radix_tree_is_well_formed(rt));
 
        memset(k, 0, sizeof(k));
        k[0] = 0x6;
-       radix_tree_remove_prefix(rt, k, k + 4);
+       radix_tree_remove_prefix(rt, k, 4);
        T_ASSERT(radix_tree_is_well_formed(rt));
 
        k[0] = 0x38;
        k[4] = 0xf;
        k[5] = 0x1;
-       T_ASSERT(radix_tree_remove(rt, k, k + sizeof(k)));
+       T_ASSERT(radix_tree_remove(rt, k, sizeof(k)));
        T_ASSERT(radix_tree_is_well_formed(rt));
 
        memset(k, 0, sizeof(k));
        k[0] = 0x6;
-       T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+       T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        T_ASSERT(radix_tree_is_well_formed(rt));
 
        k[0] = 0x7;
-       radix_tree_remove_prefix(rt, k, k + 4);
+       radix_tree_remove_prefix(rt, k, 4);
        T_ASSERT(radix_tree_is_well_formed(rt));
 
        k[0] = 0x38;
-       T_ASSERT(radix_tree_remove(rt, k, k + sizeof(k)));
+       T_ASSERT(radix_tree_remove(rt, k, sizeof(k)));
        T_ASSERT(radix_tree_is_well_formed(rt));
 
        k[0] = 7;
-       T_ASSERT(radix_tree_insert(rt, k, k + sizeof(k), v));
+       T_ASSERT(radix_tree_insert(rt, k, sizeof(k), v));
        T_ASSERT(radix_tree_is_well_formed(rt));
 }
 
@@ -769,7 +769,7 @@ static void __lookup_matches(struct radix_tree *rt, int fd, uint64_t b, uint64_t
 
        k.parts.fd = fd;
        k.parts.b = b;
-       T_ASSERT(radix_tree_lookup(rt, k.bytes, k.bytes + sizeof(k.bytes), &v));
+       T_ASSERT(radix_tree_lookup(rt, k.bytes, sizeof(k.bytes), &v));
        T_ASSERT(v.n == expected);
 }
 
@@ -780,7 +780,7 @@ static void __lookup_fails(struct radix_tree *rt, int fd, uint64_t b)
 
        k.parts.fd = fd;
        k.parts.b = b;
-       T_ASSERT(!radix_tree_lookup(rt, k.bytes, k.bytes + sizeof(k.bytes), &v));
+       T_ASSERT(!radix_tree_lookup(rt, k.bytes, sizeof(k.bytes), &v));
 }
 
 static void __insert(struct radix_tree *rt, int fd, uint64_t b, uint64_t n)
@@ -791,7 +791,7 @@ static void __insert(struct radix_tree *rt, int fd, uint64_t b, uint64_t n)
        k.parts.fd = fd;
        k.parts.b = b;
        v.n = n;
-       T_ASSERT(radix_tree_insert(rt, k.bytes, k.bytes + sizeof(k.bytes), v));
+       T_ASSERT(radix_tree_insert(rt, k.bytes, sizeof(k.bytes), v));
 }
 
 static void __invalidate(struct radix_tree *rt, int fd)
@@ -799,7 +799,7 @@ static void __invalidate(struct radix_tree *rt, int fd)
        union key k;
 
        k.parts.fd = fd;
-       radix_tree_remove_prefix(rt, k.bytes, k.bytes + sizeof(k.parts.fd));
+       radix_tree_remove_prefix(rt, k.bytes, sizeof(k.parts.fd));
        T_ASSERT(radix_tree_is_well_formed(rt));
 }