1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or https://opensource.org/licenses/CDDL-1.0.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #ifndef _LIBSPL_UMEM_H
28 #define _LIBSPL_UMEM_H
29
30 /*
31 * XXX: We should use the real portable umem library if it is detected
32 * at configure time. However, if the library is not available, we can
33 * use a trivial malloc based implementation. This obviously impacts
34 * performance, but unless you are using a full userspace build of zpool for
35 * something other than ztest, you are likely not going to notice or care.
36 *
37 * https://labs.omniti.com/trac/portableumem
38 */
39 #include <sys/debug.h>
40
41 #include <stdlib.h>
42 #include <stdio.h>
43 #include <string.h>
44
45 #ifdef __cplusplus
46 extern "C" {
47 #endif
48
49 typedef void vmem_t;
50
51 /*
52 * Flags for umem_alloc/umem_free
53 */
54 #define UMEM_DEFAULT 0x0000 /* normal -- may fail */
55 #define UMEM_NOFAIL 0x0100 /* Never fails */
56
57 /*
58 * Flags for umem_cache_create()
59 */
60 #define UMC_NODEBUG 0x00020000
61
62 #define UMEM_CACHE_NAMELEN 31
63
64 typedef int umem_nofail_callback_t(void);
65 typedef int umem_constructor_t(void *, void *, int);
66 typedef void umem_destructor_t(void *, void *);
67 typedef void umem_reclaim_t(void *);
68
69 typedef struct umem_cache {
70 char cache_name[UMEM_CACHE_NAMELEN + 1];
71 size_t cache_bufsize;
72 size_t cache_align;
73 umem_constructor_t *cache_constructor;
74 umem_destructor_t *cache_destructor;
75 umem_reclaim_t *cache_reclaim;
76 void *cache_private;
77 void *cache_arena;
78 int cache_cflags;
79 } umem_cache_t;
80
81 /* Prototypes for functions to provide defaults for umem envvars */
82 const char *_umem_debug_init(void);
83 const char *_umem_options_init(void);
84 const char *_umem_logging_init(void);
85
86 __attribute__((malloc, alloc_size(1)))
87 static inline void *
umem_alloc(size_t size,int flags)88 umem_alloc(size_t size, int flags)
89 {
90 void *ptr = NULL;
91
92 do {
93 ptr = malloc(size);
94 } while (ptr == NULL && (flags & UMEM_NOFAIL));
95
96 return (ptr);
97 }
98
99 __attribute__((malloc, alloc_size(1)))
100 static inline void *
umem_alloc_aligned(size_t size,size_t align,int flags)101 umem_alloc_aligned(size_t size, size_t align, int flags)
102 {
103 void *ptr = NULL;
104 int rc = EINVAL;
105
106 do {
107 rc = posix_memalign(&ptr, align, size);
108 } while (rc == ENOMEM && (flags & UMEM_NOFAIL));
109
110 if (rc == EINVAL) {
111 fprintf(stderr, "%s: invalid memory alignment (%zd)\n",
112 __func__, align);
113 if (flags & UMEM_NOFAIL)
114 abort();
115 return (NULL);
116 }
117
118 return (ptr);
119 }
120
121 __attribute__((malloc, alloc_size(1)))
122 static inline void *
umem_zalloc(size_t size,int flags)123 umem_zalloc(size_t size, int flags)
124 {
125 void *ptr = NULL;
126
127 ptr = umem_alloc(size, flags);
128 if (ptr)
129 memset(ptr, 0, size);
130
131 return (ptr);
132 }
133
134 static inline void
umem_free(const void * ptr,size_t size __maybe_unused)135 umem_free(const void *ptr, size_t size __maybe_unused)
136 {
137 free((void *)ptr);
138 }
139
140 /*
141 * umem_free_aligned was added for supporting portability
142 * with non-POSIX platforms that require a different free
143 * to be used with aligned allocations.
144 */
145 static inline void
umem_free_aligned(void * ptr,size_t size __maybe_unused)146 umem_free_aligned(void *ptr, size_t size __maybe_unused)
147 {
148 #ifndef _WIN32
149 free((void *)ptr);
150 #else
151 _aligned_free(ptr);
152 #endif
153 }
154
155 static inline void
umem_nofail_callback(umem_nofail_callback_t * cb __maybe_unused)156 umem_nofail_callback(umem_nofail_callback_t *cb __maybe_unused)
157 {}
158
159 static inline umem_cache_t *
umem_cache_create(const char * name,size_t bufsize,size_t align,umem_constructor_t * constructor,umem_destructor_t * destructor,umem_reclaim_t * reclaim,void * priv,void * vmp,int cflags)160 umem_cache_create(
161 const char *name, size_t bufsize, size_t align,
162 umem_constructor_t *constructor,
163 umem_destructor_t *destructor,
164 umem_reclaim_t *reclaim,
165 void *priv, void *vmp, int cflags)
166 {
167 umem_cache_t *cp;
168
169 cp = (umem_cache_t *)umem_alloc(sizeof (umem_cache_t), UMEM_DEFAULT);
170 if (cp) {
171 strlcpy(cp->cache_name, name, UMEM_CACHE_NAMELEN);
172 cp->cache_bufsize = bufsize;
173 cp->cache_align = align;
174 cp->cache_constructor = constructor;
175 cp->cache_destructor = destructor;
176 cp->cache_reclaim = reclaim;
177 cp->cache_private = priv;
178 cp->cache_arena = vmp;
179 cp->cache_cflags = cflags;
180 }
181
182 return (cp);
183 }
184
185 static inline void
umem_cache_destroy(umem_cache_t * cp)186 umem_cache_destroy(umem_cache_t *cp)
187 {
188 umem_free(cp, sizeof (umem_cache_t));
189 }
190
191 __attribute__((malloc))
192 static inline void *
umem_cache_alloc(umem_cache_t * cp,int flags)193 umem_cache_alloc(umem_cache_t *cp, int flags)
194 {
195 void *ptr = NULL;
196
197 if (cp->cache_align != 0)
198 ptr = umem_alloc_aligned(
199 cp->cache_bufsize, cp->cache_align, flags);
200 else
201 ptr = umem_alloc(cp->cache_bufsize, flags);
202
203 if (ptr && cp->cache_constructor)
204 cp->cache_constructor(ptr, cp->cache_private, UMEM_DEFAULT);
205
206 return (ptr);
207 }
208
209 static inline void
umem_cache_free(umem_cache_t * cp,void * ptr)210 umem_cache_free(umem_cache_t *cp, void *ptr)
211 {
212 if (cp->cache_destructor)
213 cp->cache_destructor(ptr, cp->cache_private);
214
215 if (cp->cache_align != 0)
216 umem_free_aligned(ptr, cp->cache_bufsize);
217 else
218 umem_free(ptr, cp->cache_bufsize);
219 }
220
221 static inline void
umem_cache_reap_now(umem_cache_t * cp __maybe_unused)222 umem_cache_reap_now(umem_cache_t *cp __maybe_unused)
223 {
224 }
225
226 #ifdef __cplusplus
227 }
228 #endif
229
230 #endif
231