1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// 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 test_verbose;
struct kmem_cache {
pthread_mutex_t lock;
unsigned int size;
unsigned int align;
int nr_objs;
void *objs;
void (*ctor)(void *);
unsigned int non_kernel;
unsigned long nr_allocated;
unsigned long nr_tallocated;
};
void kmem_cache_set_non_kernel(struct kmem_cache *cachep, unsigned int val)
{
cachep->non_kernel = val;
}
unsigned long kmem_cache_get_alloc(struct kmem_cache *cachep)
{
return cachep->size * cachep->nr_allocated;
}
unsigned long kmem_cache_nr_allocated(struct kmem_cache *cachep)
{
return cachep->nr_allocated;
}
unsigned long kmem_cache_nr_tallocated(struct kmem_cache *cachep)
{
return cachep->nr_tallocated;
}
void kmem_cache_zero_nr_tallocated(struct kmem_cache *cachep)
{
cachep->nr_tallocated = 0;
}
void *kmem_cache_alloc_lru(struct kmem_cache *cachep, struct list_lru *lru,
int gfp)
{
void *p;
if (!(gfp & __GFP_DIRECT_RECLAIM)) {
if (!cachep->non_kernel)
return NULL;
cachep->non_kernel--;
}
pthread_mutex_lock(&cachep->lock);
if (cachep->nr_objs) {
struct radix_tree_node *node = cachep->objs;
cachep->nr_objs--;
cachep->objs = node->parent;
pthread_mutex_unlock(&cachep->lock);
node->parent = NULL;
p = node;
} else {
pthread_mutex_unlock(&cachep->lock);
if (cachep->align)
posix_memalign(&p, cachep->align, cachep->size);
else
p = malloc(cachep->size);
if (cachep->ctor)
cachep->ctor(p);
else if (gfp & __GFP_ZERO)
memset(p, 0, cachep->size);
}
uatomic_inc(&cachep->nr_allocated);
uatomic_inc(&nr_allocated);
uatomic_inc(&cachep->nr_tallocated);
if (kmalloc_verbose)
printf("Allocating %p from slab\n", p);
return p;
}
void kmem_cache_free(struct kmem_cache *cachep, void *objp)
{
assert(objp);
uatomic_dec(&nr_allocated);
uatomic_dec(&cachep->nr_allocated);
if (kmalloc_verbose)
printf("Freeing %p to slab\n", objp);
pthread_mutex_lock(&cachep->lock);
if (cachep->nr_objs > 10 || cachep->align) {
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);
}
struct kmem_cache *
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->nr_allocated = 0;
ret->nr_tallocated = 0;
ret->objs = NULL;
ret->ctor = ctor;
ret->non_kernel = 0;
return ret;
}
|
