[mirror_ubuntu-bionic-kernel.git] / tools / testing / radix-tree / linux.c

// SPDX-License-Identifier: GPL-2.0
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <pthread.h>
#include <unistd.h>
#include <assert.h>

#include <linux/gfp.h>
#include <linux/poison.h>
#include <linux/slab.h>
#include <linux/radix-tree.h>
#include <urcu/uatomic.h>

int nr_allocated;
int preempt_count;
int kmalloc_verbose;
int test_verbose;

struct kmem_cache {
	pthread_mutex_t lock;
	int size;
	int nr_objs;
	void *objs;
	void (*ctor)(void *);
};

void *kmem_cache_alloc(struct kmem_cache *cachep, int flags)
{
	struct radix_tree_node *node;

	if (flags & __GFP_NOWARN)
		return NULL;

	pthread_mutex_lock(&cachep->lock);
	if (cachep->nr_objs) {
		cachep->nr_objs--;
		node = cachep->objs;
		cachep->objs = node->parent;
		pthread_mutex_unlock(&cachep->lock);
		node->parent = NULL;
	} else {
		pthread_mutex_unlock(&cachep->lock);
		node = malloc(cachep->size);
		if (cachep->ctor)
			cachep->ctor(node);
	}

	uatomic_inc(&nr_allocated);
	if (kmalloc_verbose)
		printf("Allocating %p from slab\n", node);
	return node;
}

void kmem_cache_free(struct kmem_cache *cachep, void *objp)
{
	assert(objp);
	uatomic_dec(&nr_allocated);
	if (kmalloc_verbose)
		printf("Freeing %p to slab\n", objp);
	pthread_mutex_lock(&cachep->lock);
	if (cachep->nr_objs > 10) {
		memset(objp, POISON_FREE, cachep->size);
		free(objp);
	} else {
		struct radix_tree_node *node = objp;
		cachep->nr_objs++;
		node->parent = cachep->objs;
		cachep->objs = node;
	}
	pthread_mutex_unlock(&cachep->lock);
}

void *kmalloc(size_t size, gfp_t gfp)
{
	void *ret = malloc(size);
	uatomic_inc(&nr_allocated);
	if (kmalloc_verbose)
		printf("Allocating %p from malloc\n", ret);
	return ret;
}

void kfree(void *p)
{
	if (!p)
		return;
	uatomic_dec(&nr_allocated);
	if (kmalloc_verbose)
		printf("Freeing %p to malloc\n", p);
	free(p);
}

struct kmem_cache *
kmem_cache_create(const char *name, size_t size, size_t offset,
	unsigned long flags, void (*ctor)(void *))
{
	struct kmem_cache *ret = malloc(sizeof(*ret));

	pthread_mutex_init(&ret->lock, NULL);
	ret->size = size;
	ret->nr_objs = 0;
	ret->objs = NULL;
	ret->ctor = ctor;
	return ret;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1366c37e MW	2	#include <stdlib.h>
	3	#include <string.h>
	4	#include <malloc.h>
bbe9d71f	5	#include <pthread.h>
1366c37e MW	6	#include <unistd.h>
	7	#include <assert.h>
	8
12ea6539	9	#include <linux/gfp.h>
bbe9d71f	10	#include <linux/poison.h>
1366c37e	11	#include <linux/slab.h>
bbe9d71f	12	#include <linux/radix-tree.h>
1366c37e MW	13	#include <urcu/uatomic.h>
	14
	15	int nr_allocated;
847d3576	16	int preempt_count;
5eeb2d23	17	int kmalloc_verbose;
73bc029b	18	int test_verbose;
1366c37e	19
bbe9d71f MW	20	struct kmem_cache {
	21	pthread_mutex_t lock;
	22	int size;
	23	int nr_objs;
	24	void *objs;
	25	void (ctor)(void );
	26	};
	27
1366c37e MW	28	void kmem_cache_alloc(struct kmem_cache cachep, int flags)
1366c37e MW	29	{
bbe9d71f	30	struct radix_tree_node *node;
31023cd6 MW	31
	32	if (flags & __GFP_NOWARN)
	33	return NULL;
	34
bbe9d71f MW	35	pthread_mutex_lock(&cachep->lock);
	36	if (cachep->nr_objs) {
	37	cachep->nr_objs--;
	38	node = cachep->objs;
1293d5c5	39	cachep->objs = node->parent;
bbe9d71f	40	pthread_mutex_unlock(&cachep->lock);
1293d5c5	41	node->parent = NULL;
bbe9d71f MW	42	} else {
	43	pthread_mutex_unlock(&cachep->lock);
	44	node = malloc(cachep->size);
	45	if (cachep->ctor)
	46	cachep->ctor(node);
	47	}
	48
1366c37e	49	uatomic_inc(&nr_allocated);
5eeb2d23 MW	50	if (kmalloc_verbose)
5eeb2d23 MW	51	printf("Allocating %p from slab\n", node);
bbe9d71f	52	return node;
1366c37e MW	53	}
	54
	55	void kmem_cache_free(struct kmem_cache cachep, void objp)
	56	{
	57	assert(objp);
	58	uatomic_dec(&nr_allocated);
5eeb2d23 MW	59	if (kmalloc_verbose)
5eeb2d23 MW	60	printf("Freeing %p to slab\n", objp);
bbe9d71f MW	61	pthread_mutex_lock(&cachep->lock);
	62	if (cachep->nr_objs > 10) {
	63	memset(objp, POISON_FREE, cachep->size);
	64	free(objp);
	65	} else {
	66	struct radix_tree_node *node = objp;
	67	cachep->nr_objs++;
1293d5c5	68	node->parent = cachep->objs;
bbe9d71f MW	69	cachep->objs = node;
	70	}
	71	pthread_mutex_unlock(&cachep->lock);
1366c37e MW	72	}
1366c37e MW	73
de1af8f6 MW	74	void *kmalloc(size_t size, gfp_t gfp)
	75	{
	76	void *ret = malloc(size);
	77	uatomic_inc(&nr_allocated);
5eeb2d23 MW	78	if (kmalloc_verbose)
5eeb2d23 MW	79	printf("Allocating %p from malloc\n", ret);
de1af8f6 MW	80	return ret;
	81	}
	82
	83	void kfree(void *p)
	84	{
	85	if (!p)
	86	return;
	87	uatomic_dec(&nr_allocated);
5eeb2d23 MW	88	if (kmalloc_verbose)
5eeb2d23 MW	89	printf("Freeing %p to malloc\n", p);
de1af8f6 MW	90	free(p);
	91	}
	92
1366c37e MW	93	struct kmem_cache *
	94	kmem_cache_create(const char *name, size_t size, size_t offset,
	95	unsigned long flags, void (ctor)(void ))
	96	{
	97	struct kmem_cache ret = malloc(sizeof(ret));
	98
bbe9d71f	99	pthread_mutex_init(&ret->lock, NULL);
1366c37e	100	ret->size = size;
bbe9d71f MW	101	ret->nr_objs = 0;
bbe9d71f MW	102	ret->objs = NULL;
1366c37e MW	103	ret->ctor = ctor;
	104	return ret;
	105	}