initial commit
[freebsd-arm:freebsd-arm.git] / cddl / compat / opensolaris / kern / opensolaris_kmem.c
1 /*-
2  * Copyright (c) 2006-2007 Pawel Jakub Dawidek <pjd@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29
30 #include <sys/param.h>
31 #include <sys/kernel.h>
32 #include <sys/systm.h>
33 #include <sys/malloc.h>
34 #include <sys/kmem.h>
35 #include <sys/debug.h>
36 #include <sys/mutex.h>
37
38 #include <vm/vm_page.h>
39 #include <vm/vm_object.h>
40 #include <vm/vm_kern.h>
41 #include <vm/vm_map.h>
42
43 #ifdef KMEM_DEBUG
44 #include <sys/queue.h>
45 #include <sys/stack.h>
46 #endif
47
48 #ifdef _KERNEL
49 static MALLOC_DEFINE(M_SOLARIS, "solaris", "Solaris");
50 #else
51 #define malloc(size, type, flags)       malloc(size)
52 #define free(addr, type)                free(addr)
53 #endif
54
55 #ifdef KMEM_DEBUG
56 struct kmem_item {
57         struct stack    stack;
58         LIST_ENTRY(kmem_item) next;
59 };
60 static LIST_HEAD(, kmem_item) kmem_items;
61 static struct mtx kmem_items_mtx;
62 MTX_SYSINIT(kmem_items_mtx, &kmem_items_mtx, "kmem_items", MTX_DEF);
63 #endif  /* KMEM_DEBUG */
64
65 void *
66 zfs_kmem_alloc(size_t size, int kmflags)
67 {
68         void *p;
69 #ifdef KMEM_DEBUG
70         struct kmem_item *i;
71
72         size += sizeof(struct kmem_item);
73 #endif
74         p = malloc(size, M_SOLARIS, kmflags);
75 #ifndef _KERNEL
76         if (kmflags & KM_SLEEP)
77                 assert(p != NULL);
78 #endif
79 #ifdef KMEM_DEBUG
80         if (p != NULL) {
81                 i = p;
82                 p = (u_char *)p + sizeof(struct kmem_item);
83                 stack_save(&i->stack);
84                 mtx_lock(&kmem_items_mtx);
85                 LIST_INSERT_HEAD(&kmem_items, i, next);
86                 mtx_unlock(&kmem_items_mtx);
87         }
88 #endif
89         return (p);
90 }
91
92 void
93 zfs_kmem_free(void *buf, size_t size __unused)
94 {
95 #ifdef KMEM_DEBUG
96         if (buf == NULL) {
97                 printf("%s: attempt to free NULL\n", __func__);
98                 return;
99         }
100         struct kmem_item *i;
101
102         buf = (u_char *)buf - sizeof(struct kmem_item);
103         mtx_lock(&kmem_items_mtx);
104         LIST_FOREACH(i, &kmem_items, next) {
105                 if (i == buf)
106                         break;
107         }
108         ASSERT(i != NULL);
109         LIST_REMOVE(i, next);
110         mtx_unlock(&kmem_items_mtx);
111 #endif
112         free(buf, M_SOLARIS);
113 }
114
115 uint64_t
116 kmem_size(void)
117 {
118
119         return ((uint64_t)vm_kmem_size);
120 }
121
122 uint64_t
123 kmem_used(void)
124 {
125
126         return ((uint64_t)kmem_map->size);
127 }
128
129 static int
130 kmem_std_constructor(void *mem, int size __unused, void *private, int flags)
131 {
132         struct kmem_cache *cache = private;
133
134         return (cache->kc_constructor(mem, cache->kc_private, flags));
135 }
136
137 static void
138 kmem_std_destructor(void *mem, int size __unused, void *private)
139 {
140         struct kmem_cache *cache = private;
141
142         cache->kc_destructor(mem, cache->kc_private);
143 }
144
145 kmem_cache_t *
146 kmem_cache_create(char *name, size_t bufsize, size_t align,
147     int (*constructor)(void *, void *, int), void (*destructor)(void *, void *),
148     void (*reclaim)(void *) __unused, void *private, vmem_t *vmp, int cflags)
149 {
150         kmem_cache_t *cache;
151
152         ASSERT(vmp == NULL);
153
154         cache = kmem_alloc(sizeof(*cache), KM_SLEEP);
155         strlcpy(cache->kc_name, name, sizeof(cache->kc_name));
156         cache->kc_constructor = constructor;
157         cache->kc_destructor = destructor;
158         cache->kc_private = private;
159 #if defined(_KERNEL) && !defined(KMEM_DEBUG)
160         cache->kc_zone = uma_zcreate(cache->kc_name, bufsize,
161             constructor != NULL ? kmem_std_constructor : NULL,
162             destructor != NULL ? kmem_std_destructor : NULL,
163             NULL, NULL, align > 0 ? align - 1 : 0, cflags);
164 #else
165         cache->kc_size = bufsize;
166 #endif
167
168         return (cache);
169 }
170
171 void
172 kmem_cache_destroy(kmem_cache_t *cache)
173 {
174 #if defined(_KERNEL) && !defined(KMEM_DEBUG)
175         uma_zdestroy(cache->kc_zone);
176 #endif
177         kmem_free(cache, sizeof(*cache));
178 }
179
180 void *
181 kmem_cache_alloc(kmem_cache_t *cache, int flags)
182 {
183 #if defined(_KERNEL) && !defined(KMEM_DEBUG)
184         return (uma_zalloc_arg(cache->kc_zone, cache, flags));
185 #else
186         void *p;
187
188         p = kmem_alloc(cache->kc_size, flags);
189         if (p != NULL && cache->kc_constructor != NULL)
190                 kmem_std_constructor(p, cache->kc_size, cache, flags);
191         return (p);
192 #endif
193 }
194
195 void
196 kmem_cache_free(kmem_cache_t *cache, void *buf)
197 {
198 #if defined(_KERNEL) && !defined(KMEM_DEBUG)
199         uma_zfree_arg(cache->kc_zone, buf, cache);
200 #else
201         if (cache->kc_destructor != NULL)
202                 kmem_std_destructor(buf, cache->kc_size, cache);
203         kmem_free(buf, cache->kc_size);
204 #endif
205 }
206
207 #ifdef _KERNEL
208 void
209 kmem_cache_reap_now(kmem_cache_t *cache)
210 {
211 #ifndef KMEM_DEBUG
212         zone_drain(cache->kc_zone);
213 #endif
214 }
215
216 void
217 kmem_reap(void)
218 {
219         uma_reclaim();
220 }
221 #else
222 void
223 kmem_cache_reap_now(kmem_cache_t *cache __unused)
224 {
225 }
226
227 void
228 kmem_reap(void)
229 {
230 }
231 #endif
232
233 int
234 kmem_debugging(void)
235 {
236         return (0);
237 }
238
239 void *
240 calloc(size_t n, size_t s)
241 {
242         return (kmem_zalloc(n * s, KM_NOSLEEP));
243 }
244
245 #ifdef KMEM_DEBUG
246 void kmem_show(void *);
247 void
248 kmem_show(void *dummy __unused)
249 {
250         struct kmem_item *i;
251
252         mtx_lock(&kmem_items_mtx);
253         if (LIST_EMPTY(&kmem_items))
254                 printf("KMEM_DEBUG: No leaked elements.\n");
255         else {
256                 printf("KMEM_DEBUG: Leaked elements:\n\n");
257                 LIST_FOREACH(i, &kmem_items, next) {
258                         printf("address=%p\n", i);
259                         stack_print_ddb(&i->stack);
260                         printf("\n");
261                 }
262         }
263         mtx_unlock(&kmem_items_mtx);
264 }
265
266 SYSUNINIT(sol_kmem, SI_SUB_CPU, SI_ORDER_FIRST, kmem_show, NULL);
267 #endif  /* KMEM_DEBUG */