xref: /freebsd/sys/compat/linuxkpi/common/include/linux/slab.h (revision 190cef3d52236565eb22e18b33e9e865ec634aa3)
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)			kmalloc(size, 0)
46 #define	kzalloc(size, flags)		kmalloc(size, (flags) | __GFP_ZERO)
47 #define	kzalloc_node(size, flags, node)	kmalloc(size, (flags) | __GFP_ZERO)
48 #define	kfree_const(ptr)		kfree(ptr)
49 #define	vzalloc(size)			__vmalloc(size, GFP_KERNEL | __GFP_NOWARN | __GFP_ZERO, 0)
50 #define	vfree(arg)			kfree(arg)
51 #define	kvfree(arg)			kfree(arg)
52 #define	vmalloc_node(size, node)	__vmalloc(size, GFP_KERNEL, 0)
53 #define	vmalloc_user(size)		__vmalloc(size, GFP_KERNEL | __GFP_ZERO, 0)
54 #define	vmalloc(size)			__vmalloc(size, GFP_KERNEL, 0)
55 #define	__kmalloc(...)			kmalloc(__VA_ARGS__)
56 #define	kmalloc_node(chunk, flags, n)	kmalloc(chunk, flags)
57 
58 /*
59  * Prefix some functions with linux_ to avoid namespace conflict
60  * with the OpenSolaris code in the kernel.
61  */
62 #define	kmem_cache		linux_kmem_cache
63 #define	kmem_cache_create(...)	linux_kmem_cache_create(__VA_ARGS__)
64 #define	kmem_cache_alloc(...)	linux_kmem_cache_alloc(__VA_ARGS__)
65 #define	kmem_cache_free(...)	linux_kmem_cache_free(__VA_ARGS__)
66 #define	kmem_cache_destroy(...) linux_kmem_cache_destroy(__VA_ARGS__)
67 
68 #define	KMEM_CACHE(__struct, flags)					\
69 	linux_kmem_cache_create(#__struct, sizeof(struct __struct),	\
70 	__alignof(struct __struct), (flags), NULL)
71 
72 typedef void linux_kmem_ctor_t (void *);
73 
74 struct linux_kmem_cache {
75 	uma_zone_t cache_zone;
76 	linux_kmem_ctor_t *cache_ctor;
77 	unsigned cache_flags;
78 	unsigned cache_size;
79 };
80 
81 #define	SLAB_HWCACHE_ALIGN	(1 << 0)
82 #define	SLAB_TYPESAFE_BY_RCU	(1 << 1)
83 #define	SLAB_RECLAIM_ACCOUNT	(1 << 2)
84 
85 #define	SLAB_DESTROY_BY_RCU \
86 	SLAB_TYPESAFE_BY_RCU
87 
88 #define	ARCH_KMALLOC_MINALIGN \
89 	__alignof(unsigned long long)
90 
91 static inline gfp_t
92 linux_check_m_flags(gfp_t flags)
93 {
94 	const gfp_t m = M_NOWAIT | M_WAITOK;
95 
96 	/* make sure either M_NOWAIT or M_WAITOK is set */
97 	if ((flags & m) == 0)
98 		flags |= M_NOWAIT;
99 	else if ((flags & m) == m)
100 		flags &= ~M_WAITOK;
101 
102 	/* mask away LinuxKPI specific flags */
103 	return (flags & GFP_NATIVE_MASK);
104 }
105 
106 static inline void *
107 kmalloc(size_t size, gfp_t flags)
108 {
109 	return (malloc(size, M_KMALLOC, linux_check_m_flags(flags)));
110 }
111 
112 static inline void *
113 kcalloc(size_t n, size_t size, gfp_t flags)
114 {
115 	flags |= __GFP_ZERO;
116 	return (mallocarray(n, size, M_KMALLOC, linux_check_m_flags(flags)));
117 }
118 
119 static inline void *
120 __vmalloc(size_t size, gfp_t flags, int other)
121 {
122 	return (malloc(size, M_KMALLOC, linux_check_m_flags(flags)));
123 }
124 
125 static inline void *
126 vmalloc_32(size_t size)
127 {
128 	return (contigmalloc(size, M_KMALLOC, M_WAITOK, 0, UINT_MAX, 1, 1));
129 }
130 
131 static inline void *
132 kmalloc_array(size_t n, size_t size, gfp_t flags)
133 {
134 	return (mallocarray(n, size, M_KMALLOC, linux_check_m_flags(flags)));
135 }
136 
137 static inline void *
138 kvmalloc_array(size_t n, size_t size, gfp_t flags)
139 {
140 	return (mallocarray(n, size, M_KMALLOC, linux_check_m_flags(flags)));
141 }
142 
143 static inline void *
144 krealloc(void *ptr, size_t size, gfp_t flags)
145 {
146 	return (realloc(ptr, size, M_KMALLOC, linux_check_m_flags(flags)));
147 }
148 
149 static inline void
150 kfree(const void *ptr)
151 {
152 	free(__DECONST(void *, ptr), M_KMALLOC);
153 }
154 
155 extern struct linux_kmem_cache *linux_kmem_cache_create(const char *name,
156     size_t size, size_t align, unsigned flags, linux_kmem_ctor_t *ctor);
157 
158 static inline void *
159 linux_kmem_cache_alloc(struct linux_kmem_cache *c, gfp_t flags)
160 {
161 	return (uma_zalloc_arg(c->cache_zone, c,
162 	    linux_check_m_flags(flags)));
163 }
164 
165 static inline void *
166 kmem_cache_zalloc(struct linux_kmem_cache *c, gfp_t flags)
167 {
168 	return (uma_zalloc_arg(c->cache_zone, c,
169 	    linux_check_m_flags(flags | M_ZERO)));
170 }
171 
172 extern void linux_kmem_cache_free_rcu(struct linux_kmem_cache *, void *);
173 
174 static inline void
175 linux_kmem_cache_free(struct linux_kmem_cache *c, void *m)
176 {
177 	if (unlikely(c->cache_flags & SLAB_TYPESAFE_BY_RCU))
178 		linux_kmem_cache_free_rcu(c, m);
179 	else
180 		uma_zfree(c->cache_zone, m);
181 }
182 
183 extern void linux_kmem_cache_destroy(struct linux_kmem_cache *);
184 
185 #endif					/* _LINUX_SLAB_H_ */
186