mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-04 12:07:07 +07:00
148deab223
This fixes several interlinked problems with the iterators in the presence of multiorder entries. 1. radix_tree_iter_next() would only advance by one slot, which would result in the iterators returning the same entry more than once if there were sibling entries. 2. radix_tree_next_slot() could return an internal pointer instead of a user pointer if a tagged multiorder entry was immediately followed by an entry of lower order. 3. radix_tree_next_slot() expanded to a lot more code than it used to when multiorder support was compiled in. And I wasn't comfortable with entry_to_node() being in a header file. Fixing radix_tree_iter_next() for the presence of sibling entries necessarily involves examining the contents of the radix tree, so we now need to pass 'slot' to radix_tree_iter_next(), and we need to change the calling convention so it is called *before* dropping the lock which protects the tree. Also rename it to radix_tree_iter_resume(), as some people thought it was necessary to call radix_tree_iter_next() each time around the loop. radix_tree_next_slot() becomes closer to how it looked before multiorder support was introduced. It only checks to see if the next entry in the chunk is a sibling entry or a pointer to a node; this should be rare enough that handling this case out of line is not a performance impact (and such impact is amortised by the fact that the entry we just processed was a multiorder entry). Also, radix_tree_next_slot() used to force a new chunk lookup for untagged entries, which is more expensive than the out of line sibling entry skipping. Link: http://lkml.kernel.org/r/1480369871-5271-55-git-send-email-mawilcox@linuxonhyperv.com Signed-off-by: Matthew Wilcox <mawilcox@microsoft.com> Tested-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com> Cc: Konstantin Khlebnikov <koct9i@gmail.com> Cc: Ross Zwisler <ross.zwisler@linux.intel.com> Cc: Matthew Wilcox <mawilcox@microsoft.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
118 lines
3.0 KiB
C
118 lines
3.0 KiB
C
/*
|
|
* Regression3
|
|
* Description:
|
|
* Helper radix_tree_iter_retry resets next_index to the current index.
|
|
* In following radix_tree_next_slot current chunk size becomes zero.
|
|
* This isn't checked and it tries to dereference null pointer in slot.
|
|
*
|
|
* Helper radix_tree_iter_resume reset slot to NULL and next_index to index + 1,
|
|
* for tagger iteraction it also must reset cached tags in iterator to abort
|
|
* next radix_tree_next_slot and go to slow-path into radix_tree_next_chunk.
|
|
*
|
|
* Running:
|
|
* This test should run to completion immediately. The above bug would
|
|
* cause it to segfault.
|
|
*
|
|
* Upstream commit:
|
|
* Not yet
|
|
*/
|
|
#include <linux/kernel.h>
|
|
#include <linux/gfp.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/radix-tree.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
#include "regression.h"
|
|
|
|
void regression3_test(void)
|
|
{
|
|
RADIX_TREE(root, GFP_KERNEL);
|
|
void *ptr0 = (void *)4ul;
|
|
void *ptr = (void *)8ul;
|
|
struct radix_tree_iter iter;
|
|
void **slot;
|
|
bool first;
|
|
|
|
printf("running regression test 3 (should take milliseconds)\n");
|
|
|
|
radix_tree_insert(&root, 0, ptr0);
|
|
radix_tree_tag_set(&root, 0, 0);
|
|
|
|
first = true;
|
|
radix_tree_for_each_tagged(slot, &root, &iter, 0, 0) {
|
|
printf("tagged %ld %p\n", iter.index, *slot);
|
|
if (first) {
|
|
radix_tree_insert(&root, 1, ptr);
|
|
radix_tree_tag_set(&root, 1, 0);
|
|
first = false;
|
|
}
|
|
if (radix_tree_deref_retry(*slot)) {
|
|
printf("retry at %ld\n", iter.index);
|
|
slot = radix_tree_iter_retry(&iter);
|
|
continue;
|
|
}
|
|
}
|
|
radix_tree_delete(&root, 1);
|
|
|
|
first = true;
|
|
radix_tree_for_each_slot(slot, &root, &iter, 0) {
|
|
printf("slot %ld %p\n", iter.index, *slot);
|
|
if (first) {
|
|
radix_tree_insert(&root, 1, ptr);
|
|
first = false;
|
|
}
|
|
if (radix_tree_deref_retry(*slot)) {
|
|
printk("retry at %ld\n", iter.index);
|
|
slot = radix_tree_iter_retry(&iter);
|
|
continue;
|
|
}
|
|
}
|
|
radix_tree_delete(&root, 1);
|
|
|
|
first = true;
|
|
radix_tree_for_each_contig(slot, &root, &iter, 0) {
|
|
printk("contig %ld %p\n", iter.index, *slot);
|
|
if (first) {
|
|
radix_tree_insert(&root, 1, ptr);
|
|
first = false;
|
|
}
|
|
if (radix_tree_deref_retry(*slot)) {
|
|
printk("retry at %ld\n", iter.index);
|
|
slot = radix_tree_iter_retry(&iter);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
radix_tree_for_each_slot(slot, &root, &iter, 0) {
|
|
printf("slot %ld %p\n", iter.index, *slot);
|
|
if (!iter.index) {
|
|
printf("next at %ld\n", iter.index);
|
|
slot = radix_tree_iter_resume(slot, &iter);
|
|
}
|
|
}
|
|
|
|
radix_tree_for_each_contig(slot, &root, &iter, 0) {
|
|
printf("contig %ld %p\n", iter.index, *slot);
|
|
if (!iter.index) {
|
|
printf("next at %ld\n", iter.index);
|
|
slot = radix_tree_iter_resume(slot, &iter);
|
|
}
|
|
}
|
|
|
|
radix_tree_tag_set(&root, 0, 0);
|
|
radix_tree_tag_set(&root, 1, 0);
|
|
radix_tree_for_each_tagged(slot, &root, &iter, 0, 0) {
|
|
printf("tagged %ld %p\n", iter.index, *slot);
|
|
if (!iter.index) {
|
|
printf("next at %ld\n", iter.index);
|
|
slot = radix_tree_iter_resume(slot, &iter);
|
|
}
|
|
}
|
|
|
|
radix_tree_delete(&root, 0);
|
|
radix_tree_delete(&root, 1);
|
|
|
|
printf("regression test 3 passed\n");
|
|
}
|