xref: /freebsd/sys/compat/linuxkpi/common/include/linux/slab.h (revision c66ec88fed842fbaad62c30d510644ceb7bd2d71)
1 /*-
2  * Copyright (c) 2010 Isilon Systems, Inc.
3  * Copyright (c) 2010 iX Systems, Inc.
4  * Copyright (c) 2010 Panasas, Inc.
5  * Copyright (c) 2013-2017 Mellanox Technologies, Ltd.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice unmodified, this list of conditions, and the following
13  *    disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  *
29  * $FreeBSD$
30  */
31 #ifndef	_LINUX_SLAB_H_
32 #define	_LINUX_SLAB_H_
33 
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/malloc.h>
37 #include <sys/limits.h>
38 #include <vm/uma.h>
39 
40 #include <linux/types.h>
41 #include <linux/gfp.h>
42 
43 MALLOC_DECLARE(M_KMALLOC);
44 
45 #define	kvmalloc(size, flags)		kmalloc(size, flags)
46 #define	kvzalloc(size, flags)		kmalloc(size, (flags) | __GFP_ZERO)
47 #define	kvcalloc(n, size, flags)	kvmalloc_array(n, size, (flags) | __GFP_ZERO)
48 #define	kzalloc(size, flags)		kmalloc(size, (flags) | __GFP_ZERO)
49 #define	kzalloc_node(size, flags, node)	kmalloc(size, (flags) | __GFP_ZERO)
50 #define	kfree_const(ptr)		kfree(ptr)
51 #define	vzalloc(size)			__vmalloc(size, GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO, 0)
52 #define	vfree(arg)			kfree(arg)
53 #define	kvfree(arg)			kfree(arg)
54 #define	vmalloc_node(size, node)	__vmalloc(size, GFP_KERNEL, 0)
55 #define	vmalloc_user(size)		__vmalloc(size, GFP_KERNEL | __GFP_ZERO, 0)
56 #define	vmalloc(size)			__vmalloc(size, GFP_KERNEL, 0)
57 #define	__kmalloc(...)			kmalloc(__VA_ARGS__)
58 #define	kmalloc_node(chunk, flags, n)	kmalloc(chunk, flags)
59 
60 /*
61  * Prefix some functions with linux_ to avoid namespace conflict
62  * with the OpenSolaris code in the kernel.
63  */
64 #define	kmem_cache		linux_kmem_cache
65 #define	kmem_cache_create(...)	linux_kmem_cache_create(__VA_ARGS__)
66 #define	kmem_cache_alloc(...)	linux_kmem_cache_alloc(__VA_ARGS__)
67 #define	kmem_cache_free(...)	linux_kmem_cache_free(__VA_ARGS__)
68 #define	kmem_cache_destroy(...) linux_kmem_cache_destroy(__VA_ARGS__)
69 
70 #define	KMEM_CACHE(__struct, flags)					\
71 	linux_kmem_cache_create(#__struct, sizeof(struct __struct),	\
72 	__alignof(struct __struct), (flags), NULL)
73 
74 typedef void linux_kmem_ctor_t (void *);
75 
76 struct linux_kmem_cache {
77 	uma_zone_t cache_zone;
78 	linux_kmem_ctor_t *cache_ctor;
79 	unsigned cache_flags;
80 	unsigned cache_size;
81 };
82 
83 #define	SLAB_HWCACHE_ALIGN	(1 << 0)
84 #define	SLAB_TYPESAFE_BY_RCU	(1 << 1)
85 #define	SLAB_RECLAIM_ACCOUNT	(1 << 2)
86 
87 #define	SLAB_DESTROY_BY_RCU \
88 	SLAB_TYPESAFE_BY_RCU
89 
90 #define	ARCH_KMALLOC_MINALIGN \
91 	__alignof(unsigned long long)
92 
93 static inline gfp_t
94 linux_check_m_flags(gfp_t flags)
95 {
96 	const gfp_t m = M_NOWAIT | M_WAITOK;
97 
98 	/* make sure either M_NOWAIT or M_WAITOK is set */
99 	if ((flags & m) == 0)
100 		flags |= M_NOWAIT;
101 	else if ((flags & m) == m)
102 		flags &= ~M_WAITOK;
103 
104 	/* mask away LinuxKPI specific flags */
105 	return (flags & GFP_NATIVE_MASK);
106 }
107 
108 static inline void *
109 kmalloc(size_t size, gfp_t flags)
110 {
111 	return (malloc(size, M_KMALLOC, linux_check_m_flags(flags)));
112 }
113 
114 static inline void *
115 kcalloc(size_t n, size_t size, gfp_t flags)
116 {
117 	flags |= __GFP_ZERO;
118 	return (mallocarray(n, size, M_KMALLOC, linux_check_m_flags(flags)));
119 }
120 
121 static inline void *
122 __vmalloc(size_t size, gfp_t flags, int other)
123 {
124 	return (malloc(size, M_KMALLOC, linux_check_m_flags(flags)));
125 }
126 
127 static inline void *
128 vmalloc_32(size_t size)
129 {
130 	return (contigmalloc(size, M_KMALLOC, M_WAITOK, 0, UINT_MAX, 1, 1));
131 }
132 
133 static inline void *
134 kmalloc_array(size_t n, size_t size, gfp_t flags)
135 {
136 	return (mallocarray(n, size, M_KMALLOC, linux_check_m_flags(flags)));
137 }
138 
139 static inline void *
140 kvmalloc_array(size_t n, size_t size, gfp_t flags)
141 {
142 	return (mallocarray(n, size, M_KMALLOC, linux_check_m_flags(flags)));
143 }
144 
145 static inline void *
146 krealloc(void *ptr, size_t size, gfp_t flags)
147 {
148 	return (realloc(ptr, size, M_KMALLOC, linux_check_m_flags(flags)));
149 }
150 
151 static inline void
152 kfree(const void *ptr)
153 {
154 	free(__DECONST(void *, ptr), M_KMALLOC);
155 }
156 
157 static inline size_t
158 ksize(const void *ptr)
159 {
160 	return (malloc_usable_size(ptr));
161 }
162 
163 extern struct linux_kmem_cache *linux_kmem_cache_create(const char *name,
164     size_t size, size_t align, unsigned flags, linux_kmem_ctor_t *ctor);
165 
166 static inline void *
167 linux_kmem_cache_alloc(struct linux_kmem_cache *c, gfp_t flags)
168 {
169 	return (uma_zalloc_arg(c->cache_zone, c,
170 	    linux_check_m_flags(flags)));
171 }
172 
173 static inline void *
174 kmem_cache_zalloc(struct linux_kmem_cache *c, gfp_t flags)
175 {
176 	return (uma_zalloc_arg(c->cache_zone, c,
177 	    linux_check_m_flags(flags | M_ZERO)));
178 }
179 
180 extern void linux_kmem_cache_free_rcu(struct linux_kmem_cache *, void *);
181 
182 static inline void
183 linux_kmem_cache_free(struct linux_kmem_cache *c, void *m)
184 {
185 	if (unlikely(c->cache_flags & SLAB_TYPESAFE_BY_RCU))
186 		linux_kmem_cache_free_rcu(c, m);
187 	else
188 		uma_zfree(c->cache_zone, m);
189 }
190 
191 extern void linux_kmem_cache_destroy(struct linux_kmem_cache *);
192 
193 #endif					/* _LINUX_SLAB_H_ */
194