int insert_result(struct results_tree *res, unsigned char *digest,
struct filerec *recs[2], uint64_t startoff[2],
uint64_t endoff[2])
{
struct extent *e0 = alloc_extent(recs[0], startoff[0]);
struct extent *e1 = alloc_extent(recs[1], startoff[1]);
struct dupe_extents *dext;
uint64_t len = endoff[0] - startoff[0];
int add_score = 1;
if (!e0 || !e1)
return ENOMEM;
dext = find_dupe_extents(res, digest, len);
if (!dext) {
dext = dupe_extents_new(res, digest, len);
if (!dext)
return ENOMEM;
add_score = 0;
}
abort_on(dext->de_len != len);
insert_extent_list_free(dext, &e0);
insert_extent_list_free(dext, &e1);
if (e0) {
if (add_score)
dext->de_score += len;
e0->e_itnode.start = e0->e_loff;
e0->e_itnode.last = extent_end(e0);
interval_tree_insert(&e0->e_itnode, &recs[0]->extent_tree);
#ifdef ITDEBUG
recs[0]->num_extents++;
#endif
}
if (e1) {
if (add_score)
dext->de_score += len;
e1->e_itnode.start = e1->e_loff;
e1->e_itnode.last = extent_end(e1);
interval_tree_insert(&e1->e_itnode, &recs[1]->extent_tree);
#ifdef ITDEBUG
recs[1]->num_extents++;
#endif
}
return 0;
}
static int interval_tree_test_init(void)
{
int i, j;
unsigned long results;
cycles_t time1, time2, _time;
printk(KERN_ALERT "interval tree insert/remove");
prandom_seed_state(&rnd, 3141592653589793238ULL);
init();
time1 = get_cycles();
for (i = 0; i < PERF_LOOPS; i++) {
for (j = 0; j < NODES; j++)
interval_tree_insert(nodes + j, &root);
for (j = 0; j < NODES; j++)
interval_tree_remove(nodes + j, &root);
}
time2 = get_cycles();
_time = time2 - time1;
_time = div_u64(_time, PERF_LOOPS);
printk(" -> %llu cycles\n", (unsigned long long)time);
printk(KERN_ALERT "interval tree search");
for (j = 0; j < NODES; j++)
interval_tree_insert(nodes + j, &root);
time1 = get_cycles();
results = 0;
for (i = 0; i < SEARCH_LOOPS; i++)
for (j = 0; j < SEARCHES; j++)
results += search(queries[j], &root);
time2 = get_cycles();
_time = time2 - time1;
_time = div_u64(_time, SEARCH_LOOPS);
results = div_u64(results, SEARCH_LOOPS);
printk(" -> %llu cycles (%lu results)\n",
(unsigned long long)time, results);
return -EAGAIN; /* Fail will directly unload the module */
}
bool interval_tree_read(interval_tree tree, int fd, uint64_t n)
{
interval intervals[INTERVAL_COUNT];
int i, block;
bool r;
CHECK_MUTEX_LOCKED(tree->mutex);
for (; n > 0; n -= block)
{
block = n > INTERVAL_COUNT ? INTERVAL_COUNT : n;
r = full_read(fd, intervals, block * sizeof(interval));
if (!r)
return false;
for (i = 0; i < block; i++)
{
intervals[i].start = le_to_u64(intervals[i].start);
intervals[i].end = le_to_u64(intervals[i].end);
interval_tree_insert(tree, intervals[i].start, intervals[i].end);
}
}
return true;
}
static int interval_tree_add_1(splay_tree_node node, void *data)
{
interval_tree tree = (interval_tree) data;
interval_tree_insert(tree, INTERVAL_START(node), INTERVAL_END(node));
return 0;
}
void addresscheck(char *descriptor, void *addr, size_t size)
{
struct mem_range *new_range = malloc(sizeof(struct mem_range));
new_range->descriptor = descriptor;
new_range->start = addr;
new_range->end = addr + (size - 1);
struct mem_range *lookup = interval_tree_lookup(&memory_ranges, new_range);
if (lookup && lookup->start != new_range->start && lookup->end != new_range->end) {
if (descriptor)
kitsune_log("Memory overlap: insertion: %s", descriptor);
if (lookup->descriptor)
kitsune_log("Memory overlap: existing: %s", lookup->descriptor);
if (lookup->start == new_range->start && lookup->end != new_range->end) {
kitsune_log("Memory overlap: matching pointers with differnent sizes!");
} else if ((lookup->start >= new_range->start && lookup->end <= new_range->end) ||
(lookup->start <= new_range->start && lookup->end >= new_range->end)) {
kitsune_log("Memory overlap: pointer internal to memory region!");
} else {
kitsune_log("Memory overlap: weird overlapping pattern!");
}
ptrdiff_t d0 = lookup->start - new_range->start;
ptrdiff_t d1 = lookup->end - lookup->start;
ptrdiff_t d2 = new_range->end - new_range->start;
kitsune_log("Memory overlap: start diff [%ld] size1 [%ld] size2 [%ld]", d0, d1, d2);
}
interval_tree_insert(&memory_ranges, new_range);
}
static void add_object(struct i915_mmu_object *mo)
{
if (mo->attached)
return;
interval_tree_insert(&mo->it, &mo->mn->objects);
mo->attached = true;
}
/* this is the fixup routine from Cormen et al, p. 281*/
static void interval_tree_insert_internal(GtIntervalTree *it,
GtIntervalTreeNode **root,
GtIntervalTreeNode *z)
{
GtIntervalTreeNode* y;
interval_tree_insert(it, root, z);
z->color = RED;
while (z != *root && z->parent->color == RED)
{
if (z->parent == z->parent->parent->left)
{
y = z->parent->parent->right;
if (y != it->nil && y->color == RED)
{
z->parent->color = BLACK;
y->color = BLACK;
z->parent->parent->color = RED;
z = z->parent->parent;
}
else
{
if (z == z->parent->right)
{
z = z->parent;
interval_tree_left_rotate(it, root, z);
}
z->parent->color = BLACK;
z->parent->parent->color = RED;
interval_tree_right_rotate(it, root, z->parent->parent);
}
}
else
{
y = z->parent->parent->left;
if (y != it->nil && y->color == RED)
{
z->parent->color = BLACK;
y->color = BLACK;
z->parent->parent->color = RED;
z = z->parent->parent;
}
else
{
if (z == z->parent->left)
{
z = z->parent;
interval_tree_right_rotate(it, root, z);
}
z->parent->color = BLACK;
z->parent->parent->color = RED;
interval_tree_left_rotate(it, root, z->parent->parent);
}
}
}
(*root)->color = BLACK;
}
static void add_object(struct i915_mmu_object *mo)
{
GEM_BUG_ON(!RB_EMPTY_NODE(&mo->it.rb));
interval_tree_insert(&mo->it, &mo->mn->objects);
}
/*! \brief Read data from the version file. It uses intervals build during
open. \param dentry Dentry of the file \param start Start of data interval
\param end End of data interval \param[out] buf Buffer to store the data
\see version_build_intervals */
int32_t
version_read_old_data(internal_dentry dentry, uint64_t start, uint64_t end,
char *buf)
{
// read data from version files
unsigned int i, j;
version_item *item;
interval_tree covered;
uint32_t rsize = 0;
covered = interval_tree_create(1, NULL);
interval_tree_add(covered, dentry->fh->versioned);
for (i = 0; i < dentry->fh->version_list_length; i++)
{
varray v, rv;
int fd;
item = &dentry->fh->version_list[i];
if (!item->stamp)
continue;
if (item->intervals)
interval_tree_intersection(item->intervals, start, end, &v);
else
{
interval ival;
ival.start = start;
ival.end = end;
varray_create(&v, sizeof(interval), 1);
VARRAY_PUSH(v, ival, interval);
}
if (VARRAY_USED(v) == 0)
{
varray_destroy(&v);
continue;
}
interval_tree_complement_varray(covered, &v, &rv);
varray_destroy(&v);
fd = open(item->path, O_RDONLY);
for (j = 0; j < VARRAY_USED(rv); j++)
{
interval ival;
ssize_t rd;
ival = VARRAY_ACCESS(rv, j, interval);
lseek(fd, ival.start, SEEK_SET);
read_again:
rd = read(fd, buf + ival.start - start, ival.end - ival.start);
if (rd < 0 && errno == EINTR)
goto read_again;
if (rd > 0)
{
rsize += rd;
interval_tree_insert(covered, ival.start, ival.end);
}
message(LOG_DEBUG, FACILITY_VERSION,
"read version name=%s, start=%lld, end=%lld, read=%d\n",
item->name, ival.start, ival.end, rd);
}
close(fd);
varray_destroy(&rv);
}
interval_tree_destroy(covered);
RETURN_INT(ZFS_OK);
}
