2dce31a647aeeaf036c4fa5c2f2fc9edfd7211eb
[sip-router] / mem / shm_mem.h
1 /* $Id$*
2  *
3  * shared mem stuff
4  *
5  * Copyright (C) 2001-2003 FhG Fokus
6  *
7  * This file is part of sip-router, a free SIP server.
8  *
9  * Permission to use, copy, modify, and distribute this software for any
10  * purpose with or without fee is hereby granted, provided that the above
11  * copyright notice and this permission notice appear in all copies.
12  *
13  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
14  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
15  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
16  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
17  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20  */
21 /*
22  * History:
23  * --------
24  *  2003-06-29  added shm_realloc & replaced shm_resize (andrei)
25  *  2003-11-19  reverted shm_resize to the old version, using
26  *               realloc causes terrible fragmentation  (andrei)
27  *  2005-03-02   added shm_info() & re-eneabled locking on shm_status (andrei)
28  *  2007-02-23   added shm_available() (andrei)
29  *  2007-06-10   support for sf_malloc (andrei)
30  */
31
32
33 #ifdef SHM_MEM
34
35 #ifndef shm_mem_h
36 #define shm_mem_h
37
38 #include <string.h>
39 #include <errno.h>
40 #include <sys/types.h>
41 #include <sys/ipc.h>
42
43 #ifndef SHM_MMAP
44
45 #include <sys/shm.h>
46
47 #endif
48
49 #include <sys/sem.h>
50 #include <string.h>
51 #include <errno.h>
52
53 /* fix DBG MALLOC stuff */
54
55 /* fix debug defines, DBG_F_MALLOC <=> DBG_QM_MALLOC */
56 #ifdef F_MALLOC
57         #ifdef DBG_F_MALLOC
58                 #ifndef DBG_QM_MALLOC
59                         #define DBG_QM_MALLOC
60                 #endif
61         #elif defined(DBG_QM_MALLOC)
62                 #define DBG_F_MALLOC
63         #endif
64 #endif
65
66
67
68 #include "../dprint.h"
69 #include "../lock_ops.h" /* we don't include locking.h on purpose */
70
71 #ifdef LL_MALLOC
72 #       include "ll_malloc.h"
73 #       define SHM_SAFE_MALLOC /* no need to lock */
74         extern struct sfm_block* shm_block;
75 #ifdef __SUNPRO_C
76 #       define shm_malloc(...) sfm_malloc(shm_block, __VA_ARGS__)
77 #       define shm_free(...) sfm_free(shm_block, __VA_ARGS__)
78 #       define shm_realloc(...) sfm_malloc(shm_block, __VA_ARGS__)
79         /* WARNING: test, especially if switched to real realloc */
80 #       define shm_resize(...)  sfm_realloc(shm_block, __VA_ARGS__)
81 #       define shm_info(...) sfm_info(shm_block, __VA_ARGS__)
82 #else /* __SUNPRO_C */
83 #       define shm_malloc(args...) sfm_malloc(shm_block, ## args)
84 #       define shm_free(args...) sfm_free(shm_block, ## args)
85 #       define shm_realloc(args...) sfm_malloc(shm_block, ## args)
86         /* WARNING: test, especially if switched to real realloc */
87 #       define shm_resize(args...)      sfm_realloc(shm_block, ## args)
88 #       define shm_info(args...) sfm_info(shm_block, ## args)
89 #endif /* __SUNPRO_C */
90 #       define shm_malloc_unsafe  shm_malloc
91 #       define shm_free_unsafe shm_free
92 #       define shm_available    sfm_available(shm_block)
93 #       define shm_status() sfm_status(shm_block)
94 #       define shm_sums() do{}while(0)
95 #       define shm_malloc_init sfm_malloc_init
96 #       define shm_malloc_destroy(b) sfm_malloc_destroy(b)
97 #       define shm_malloc_on_fork()     sfm_pool_reset()
98 #elif SF_MALLOC
99 #       include "sf_malloc.h"
100 #       define SHM_SAFE_MALLOC /* no need to lock */
101         extern struct sfm_block* shm_block;
102 #ifdef __SUNPRO_C
103 #       define shm_malloc(...) sfm_malloc(shm_block, __VA_ARGS__)
104 #       define shm_free(...) sfm_free(shm_block, __VA_ARGS__)
105 #       define shm_realloc(...) sfm_malloc(shm_block, __VA_ARGS__)
106         /* WARNING: test, especially if switched to real realloc */
107 #       define shm_resize(...)  sfm_realloc(shm_block, __VA_ARGS__)
108 #       define shm_info(...) sfm_info(shm_block, __VA_ARGS__)
109 #else /* __SUNPRO_C */
110 #       define shm_malloc(args...) sfm_malloc(shm_block, ## args)
111 #       define shm_free(args...) sfm_free(shm_block, ## args)
112 #       define shm_realloc(args...) sfm_malloc(shm_block, ## args)
113         /* WARNING: test, especially if switched to real realloc */
114 #       define shm_resize(args...)      sfm_realloc(shm_block, ## args)
115 #       define shm_info(args...) sfm_info(shm_block, ## args)
116 #endif /* __SUNPRO_C */
117 #       define shm_malloc_unsafe  shm_malloc
118 #       define shm_free_unsafe shm_free
119 #       define shm_available    sfm_available(shm_block)
120 #       define shm_status() sfm_status(shm_block)
121 #       define shm_sums() do{}while(0)
122 #       define shm_malloc_init sfm_malloc_init
123 #       define shm_malloc_destroy(b) sfm_malloc_destroy(b)
124 #       define shm_malloc_on_fork()     sfm_pool_reset()
125 #elif defined F_MALLOC
126 #       include "f_malloc.h"
127         extern struct fm_block* shm_block;
128 #       define MY_MALLOC fm_malloc
129 #       define MY_FREE fm_free
130 #       define MY_REALLOC fm_realloc
131 #       define MY_STATUS fm_status
132 #       define MY_MEMINFO       fm_info
133 #       define MY_SUMS  fm_sums
134 #       define  shm_malloc_init fm_malloc_init
135 #       define shm_malloc_destroy(b) do{}while(0)
136 #       define shm_available() fm_available(shm_block)
137 #       define shm_malloc_on_fork() do{}while(0)
138 #elif defined DL_MALLOC
139 #       include "dl_malloc.h"
140         extern mspace shm_block;
141 #       define MY_MALLOC mspace_malloc
142 #       define MY_FREE mspace_free
143 #       define MY_REALLOC mspace_realloc
144 #       define MY_STATUS(...) 0
145 #       define MY_SUMS do{}while(0)
146 #       define MY_MEMINFO       mspace_info
147 #       define  shm_malloc_init(buf, len) create_mspace_with_base(buf, len, 0)
148 #       define shm_malloc_destroy(b) do{}while(0)
149 #       define shm_malloc_on_fork() do{}while(0)
150 #else
151 #       include "q_malloc.h"
152         extern struct qm_block* shm_block;
153 #       define MY_MALLOC qm_malloc
154 #       define MY_FREE qm_free
155 #       define MY_REALLOC qm_realloc
156 #       define MY_STATUS qm_status
157 #       define MY_MEMINFO       qm_info
158 #       define MY_SUMS  qm_sums
159 #       define  shm_malloc_init qm_malloc_init
160 #       define shm_malloc_destroy(b) do{}while(0)
161 #       define shm_available() qm_available(shm_block)
162 #       define shm_malloc_on_fork() do{}while(0)
163 #endif
164
165 #ifndef SHM_SAFE_MALLOC
166         extern gen_lock_t* mem_lock;
167 #endif
168
169
170 int shm_mem_init(int); /* calls shm_getmem & shm_mem_init_mallocs */
171 int shm_getmem();   /* allocates the memory (mmap or sysv shmap) */
172 int shm_mem_init_mallocs(void* mempool, unsigned long size); /* initialize
173                                                                                                                                 the mallocs
174                                                                                                                                 & the lock */
175 void shm_mem_destroy();
176
177
178
179 #ifdef SHM_SAFE_MALLOC
180 #define shm_lock() do{}while(0)
181 #define shm_unlock() do{}while(0)
182
183 #else /* ! SHM_SAFE_MALLOC */
184
185 #define shm_lock()    lock_get(mem_lock)
186 #define shm_unlock()  lock_release(mem_lock)
187
188 #ifdef DBG_QM_MALLOC
189
190 #include "src_loc.h"
191
192 #define shm_malloc_unsafe(_size ) \
193         MY_MALLOC(shm_block, (_size), _SRC_LOC_, _SRC_FUNCTION_, _SRC_LINE_ )
194
195
196 inline static void* _shm_malloc(unsigned int size, 
197         const char *file, const char *function, int line )
198 {
199         void *p;
200         
201         shm_lock();
202         p=MY_MALLOC(shm_block, size, file, function, line );
203         shm_unlock();
204         return p; 
205 }
206
207
208 inline static void* _shm_realloc(void *ptr, unsigned int size, 
209                 const char* file, const char* function, int line )
210 {
211         void *p;
212         shm_lock();
213         p=MY_REALLOC(shm_block, ptr, size, file, function, line);
214         shm_unlock();
215         return p;
216 }
217
218 #define shm_malloc( _size ) _shm_malloc((_size), \
219         _SRC_LOC_, _SRC_FUNCTION_, _SRC_LINE_ )
220
221 #define shm_realloc( _ptr, _size ) _shm_realloc( (_ptr), (_size), \
222         _SRC_LOC_, _SRC_FUNCTION_, _SRC_LINE_ )
223
224
225
226 #define shm_free_unsafe( _p  ) \
227         MY_FREE( shm_block, (_p), _SRC_LOC_, _SRC_FUNCTION_, _SRC_LINE_ )
228
229 #define shm_free(_p) \
230 do { \
231                 shm_lock(); \
232                 shm_free_unsafe( (_p)); \
233                 shm_unlock(); \
234 }while(0)
235
236
237
238 void* _shm_resize(void* ptr, unsigned int size, const char* f, const char* fn,
239                                         int line);
240 #define shm_resize(_p, _s ) _shm_resize((_p), (_s), \
241                 _SRC_LOC_, _SRC_FUNCTION_, _SRC_LINE_ )
242 /*#define shm_resize(_p, _s ) shm_realloc( (_p), (_s))*/
243
244
245
246 #else /*DBQ_QM_MALLOC*/
247
248
249 #define shm_malloc_unsafe(_size) MY_MALLOC(shm_block, (_size))
250
251 inline static void* shm_malloc(unsigned int size)
252 {
253         void *p;
254         
255         shm_lock();
256         p=shm_malloc_unsafe(size);
257         shm_unlock();
258          return p; 
259 }
260
261
262 inline static void* shm_realloc(void *ptr, unsigned int size)
263 {
264         void *p;
265         shm_lock();
266         p=MY_REALLOC(shm_block, ptr, size);
267         shm_unlock();
268         return p;
269 }
270
271
272
273 #define shm_free_unsafe( _p ) MY_FREE(shm_block, (_p))
274
275 #define shm_free(_p) \
276 do { \
277                 shm_lock(); \
278                 shm_free_unsafe( _p ); \
279                 shm_unlock(); \
280 }while(0)
281
282
283
284 void* _shm_resize(void* ptr, unsigned int size);
285 #define shm_resize(_p, _s) _shm_resize( (_p), (_s))
286 /*#define shm_resize(_p, _s) shm_realloc( (_p), (_s))*/
287
288
289 #endif  /* DBG_QM_MALLOC */
290
291
292 #define shm_status() \
293 do { \
294                 shm_lock(); \
295                 MY_STATUS(shm_block); \
296                 shm_unlock(); \
297 }while(0)
298
299
300 #define shm_info(mi) \
301 do{\
302         shm_lock(); \
303         MY_MEMINFO(shm_block, mi); \
304         shm_unlock(); \
305 }while(0)
306
307 #ifdef MY_SUMS
308 #define shm_sums() \
309         do { \
310                 shm_lock(); \
311                 MY_SUMS(shm_block); \
312                 shm_unlock(); \
313         }while(0)
314         
315 #endif /* MY_SUMS */
316
317 #endif /* ! SHM_SAFE_MALLOC */
318
319 #endif /* shm_mem_h */
320
321 #endif /* SHM_MEM */
322