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