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