radix tree test suite: Support kmem_cache alignment

The radix tree doesn't use alignment, so the argument was ignored.
The maple tree needs its nodes to be aligned, so we need to pay attention
to the alignment argument.  Also change the types of 'size' and 'align'
to unsigned int to match commit f4957d5bd0916.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>

diff --git a/tools/testing/radix-tree/linux.c b/tools/testing/radix-tree/linux.c
index 44a0d1a..2d9c59d 100644 (file)
--- a/tools/testing/radix-tree/linux.c
+++ b/tools/testing/radix-tree/linux.c
@@ -19,37 +19,44 @@ int test_verbose;
 
 struct kmem_cache {
        pthread_mutex_t lock;
-       int size;
+       unsigned int size;
+       unsigned int align;
        int nr_objs;
        void *objs;
        void (*ctor)(void *);
 };
 
-void *kmem_cache_alloc(struct kmem_cache *cachep, int flags)
+void *kmem_cache_alloc(struct kmem_cache *cachep, int gfp)
 {
-       struct radix_tree_node *node;
+       void *p;
 
-       if (!(flags & __GFP_DIRECT_RECLAIM))
+       if (!(gfp & __GFP_DIRECT_RECLAIM))
                return NULL;
 
        pthread_mutex_lock(&cachep->lock);
        if (cachep->nr_objs) {
+               struct radix_tree_node *node = cachep->objs;
                cachep->nr_objs--;
-               node = cachep->objs;
                cachep->objs = node->parent;
                pthread_mutex_unlock(&cachep->lock);
                node->parent = NULL;
+               p = node;
        } else {
                pthread_mutex_unlock(&cachep->lock);
-               node = malloc(cachep->size);
+               if (cachep->align)
+                       posix_memalign(&p, cachep->align, cachep->size);
+               else
+                       p = malloc(cachep->size);
                if (cachep->ctor)
-                       cachep->ctor(node);
+                       cachep->ctor(p);
+               else if (gfp & __GFP_ZERO)
+                       memset(p, 0, cachep->size);
        }
 
        uatomic_inc(&nr_allocated);
        if (kmalloc_verbose)
-               printf("Allocating %p from slab\n", node);
-       return node;
+               printf("Allocating %p from slab\n", p);
+       return p;
 }
 
 void kmem_cache_free(struct kmem_cache *cachep, void *objp)
@@ -59,7 +66,7 @@ void kmem_cache_free(struct kmem_cache *cachep, void *objp)
        if (kmalloc_verbose)
                printf("Freeing %p to slab\n", objp);
        pthread_mutex_lock(&cachep->lock);
-       if (cachep->nr_objs > 10) {
+       if (cachep->nr_objs > 10 || cachep->align) {
                memset(objp, POISON_FREE, cachep->size);
                free(objp);
        } else {
@@ -98,13 +105,14 @@ void kfree(void *p)
 }
 
 struct kmem_cache *
-kmem_cache_create(const char *name, size_t size, size_t offset,
-       unsigned long flags, void (*ctor)(void *))
+kmem_cache_create(const char *name, unsigned int size, unsigned int align,
+               unsigned int flags, void (*ctor)(void *))
 {
        struct kmem_cache *ret = malloc(sizeof(*ret));
 
        pthread_mutex_init(&ret->lock, NULL);
        ret->size = size;
+       ret->align = align;
        ret->nr_objs = 0;
        ret->objs = NULL;
        ret->ctor = ctor;

diff --git a/tools/testing/radix-tree/linux/slab.h b/tools/testing/radix-tree/linux/slab.h
index a037def..2958830 100644 (file)
--- a/tools/testing/radix-tree/linux/slab.h
+++ b/tools/testing/radix-tree/linux/slab.h
@@ -20,8 +20,8 @@ static inline void *kzalloc(size_t size, gfp_t gfp)
 void *kmem_cache_alloc(struct kmem_cache *cachep, int flags);
 void kmem_cache_free(struct kmem_cache *cachep, void *objp);
 
-struct kmem_cache *
-kmem_cache_create(const char *name, size_t size, size_t offset,
-       unsigned long flags, void (*ctor)(void *));
+struct kmem_cache *kmem_cache_create(const char *name, unsigned int size,
+                       unsigned int align, unsigned int flags,
+                       void (*ctor)(void *));
 
 #endif         /* SLAB_H */