mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-16 00:34:20 +08:00
afe0e395b6
Setting the indirect bit on the user data entry used to be unambiguous because the tree walking code knew not to expect internal nodes in the last level of the tree. Multiorder entries can appear at any level of the tree, and a leaf with the indirect bit set is indistinguishable from a pointer to a node. Introduce a special entry (RADIX_TREE_RETRY) which is neither a valid user entry, nor a valid pointer to a node. The radix_tree_deref_retry() function continues to work the same way, but tree walking code can distinguish it from a pointer to a node. Also fix the condition for setting slot->parent to NULL; it does not matter what height the tree is, it only matters whether slot is an indirect pointer. Move this code above the comment which is referring to the assignment to root->rnode. Also fix the condition for preventing the tree from shrinking to a single entry if it's a multiorder entry. Add a test-case to the test suite that checks that the tree goes back down to its original height after an item is inserted & deleted from a higher index in the tree. Signed-off-by: Matthew Wilcox <willy@linux.intel.com> Reviewed-by: Ross Zwisler <ross.zwisler@linux.intel.com> Cc: Konstantin Khlebnikov <koct9i@gmail.com> Cc: Kirill Shutemov <kirill.shutemov@linux.intel.com> Cc: Jan Kara <jack@suse.com> Cc: Neil Brown <neilb@suse.de> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
98 lines
2.5 KiB
C
98 lines
2.5 KiB
C
/*
|
|
* multiorder.c: Multi-order radix tree entry testing
|
|
* Copyright (c) 2016 Intel Corporation
|
|
* Author: Ross Zwisler <ross.zwisler@linux.intel.com>
|
|
* Author: Matthew Wilcox <matthew.r.wilcox@intel.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* version 2, as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*/
|
|
#include <linux/radix-tree.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/errno.h>
|
|
|
|
#include "test.h"
|
|
|
|
static void multiorder_check(unsigned long index, int order)
|
|
{
|
|
unsigned long i;
|
|
unsigned long min = index & ~((1UL << order) - 1);
|
|
unsigned long max = min + (1UL << order);
|
|
RADIX_TREE(tree, GFP_KERNEL);
|
|
|
|
printf("Multiorder index %ld, order %d\n", index, order);
|
|
|
|
assert(item_insert_order(&tree, index, order) == 0);
|
|
|
|
for (i = min; i < max; i++) {
|
|
struct item *item = item_lookup(&tree, i);
|
|
assert(item != 0);
|
|
assert(item->index == index);
|
|
}
|
|
for (i = 0; i < min; i++)
|
|
item_check_absent(&tree, i);
|
|
for (i = max; i < 2*max; i++)
|
|
item_check_absent(&tree, i);
|
|
|
|
assert(item_delete(&tree, index) != 0);
|
|
|
|
for (i = 0; i < 2*max; i++)
|
|
item_check_absent(&tree, i);
|
|
}
|
|
|
|
static void multiorder_shrink(unsigned long index, int order)
|
|
{
|
|
unsigned long i;
|
|
unsigned long max = 1 << order;
|
|
RADIX_TREE(tree, GFP_KERNEL);
|
|
struct radix_tree_node *node;
|
|
|
|
printf("Multiorder shrink index %ld, order %d\n", index, order);
|
|
|
|
assert(item_insert_order(&tree, 0, order) == 0);
|
|
|
|
node = tree.rnode;
|
|
|
|
assert(item_insert(&tree, index) == 0);
|
|
assert(node != tree.rnode);
|
|
|
|
assert(item_delete(&tree, index) != 0);
|
|
assert(node == tree.rnode);
|
|
|
|
for (i = 0; i < max; i++) {
|
|
struct item *item = item_lookup(&tree, i);
|
|
assert(item != 0);
|
|
assert(item->index == 0);
|
|
}
|
|
for (i = max; i < 2*max; i++)
|
|
item_check_absent(&tree, i);
|
|
|
|
if (!item_delete(&tree, 0)) {
|
|
printf("failed to delete index %ld (order %d)\n", index, order); abort();
|
|
}
|
|
|
|
for (i = 0; i < 2*max; i++)
|
|
item_check_absent(&tree, i);
|
|
}
|
|
|
|
void multiorder_checks(void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 20; i++) {
|
|
multiorder_check(200, i);
|
|
multiorder_check(0, i);
|
|
multiorder_check((1UL << i) + 1, i);
|
|
}
|
|
|
|
for (i = 0; i < 15; i++)
|
|
multiorder_shrink((1UL << (i + RADIX_TREE_MAP_SHIFT)), i);
|
|
|
|
}
|