mem/mem.h
47f59303
 /*
84d8e165
  * Copyright (C) 2001-2003 FhG Fokus
7dd0b342
  *
e4f42ce1
  * This file is part of sip-router, a free SIP server.
7dd0b342
  *
e4f42ce1
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
7dd0b342
  *
e4f42ce1
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
dda9dab1
  */
47f59303
 
6419a43f
 /*
  * History:
  * --------
  *  2003-03-10  __FUNCTION__ is a gcc-ism, defined it to "" for sun cc
  *               (andrei)
90907c3f
  *  2003-03-07  split init_malloc into init_pkg_mallocs & init_shm_mallocs 
  *               (andrei)
8799e028
  *  2007-02-23   added pkg_info() and pkg_available() (andrei)
6419a43f
  */
dda9dab1
 
47f59303
 /**
  * \defgroup mem SIP-router memory manager
  * \brief  SIP-router internal memory manager
  * 
  * SIP-router internal memory manager for private (per process) and shared
  * memory pools. It provides several different strategies for the memory
  * management, like really fast, with extended debugging and also plain system
  * memory management.
  */
 
 /**
  * \file
  * \brief Main definitions for memory manager
  * 
  * \brief Main definitions for memory manager, like malloc, free and realloc
  * \ingroup mem
  */
dda9dab1
 
7dd0b342
 
dda9dab1
 #ifndef mem_h
 #define mem_h
 #include "../config.h"
 #include "../dprint.h"
 
9c01c860
 /* fix debug defines, DBG_F_MALLOC <=> DBG_QM_MALLOC */
 #ifdef F_MALLOC
 	#ifdef DBG_F_MALLOC
 		#ifndef DBG_QM_MALLOC
 			#define DBG_QM_MALLOC
 		#endif
 	#elif defined(DBG_QM_MALLOC)
 		#define DBG_F_MALLOC
 	#endif
 #endif
 
dda9dab1
 #ifdef PKG_MALLOC
f92113d8
 #	ifdef F_MALLOC
b2dec9c6
 #		include "f_malloc.h"
 		extern struct fm_block* mem_block;
51ea5ec2
 #	elif defined DL_MALLOC
 #		include "dl_malloc.h"
b2dec9c6
 #   else
dda9dab1
 #		include "q_malloc.h"
 		extern struct qm_block* mem_block;
 #	endif
 
7b3a6eca
 	extern char* mem_pool;
dda9dab1
 
 
 #	ifdef DBG_QM_MALLOC
220ac6e2
 
 #	include "src_loc.h" /* src location macros: _SRC_* */
f92113d8
 #		ifdef F_MALLOC
220ac6e2
 #			define pkg_malloc(s) fm_malloc(mem_block, (s), _SRC_LOC_, \
 				_SRC_FUNCTION_, _SRC_LINE_)
 #			define pkg_free(p)   fm_free(mem_block, (p), _SRC_LOC_,  \
 				_SRC_FUNCTION_, _SRC_LINE_)
 #			define pkg_realloc(p, s) fm_realloc(mem_block, (p), (s), \
 					_SRC_LOC_, _SRC_FUNCTION_, _SRC_LINE_)
dda9dab1
 #		else
220ac6e2
 #			define pkg_malloc(s) qm_malloc(mem_block, (s),_SRC_LOC_, \
 				_SRC_FUNCTION_, _SRC_LINE_)
 #			define pkg_realloc(p, s) qm_realloc(mem_block, (p), (s), \
 				_SRC_LOC_, _SRC_FUNCTION_, _SRC_LINE_)
 #			define pkg_free(p)   qm_free(mem_block, (p), _SRC_LOC_,  \
 				_SRC_FUNCTION_, _SRC_LINE_)
dda9dab1
 #		endif
 #	else
f92113d8
 #		ifdef F_MALLOC
b2dec9c6
 #			define pkg_malloc(s) fm_malloc(mem_block, (s))
9c01c860
 #			define pkg_realloc(p, s) fm_realloc(mem_block, (p), (s))
b2dec9c6
 #			define pkg_free(p)   fm_free(mem_block, (p))
51ea5ec2
 #		elif defined DL_MALLOC
 #			define pkg_malloc(s) dlmalloc((s))
 #			define pkg_realloc(p, s) dlrealloc((p), (s))
 #			define pkg_free(p)   dlfree((p))
dda9dab1
 #		else
 #			define pkg_malloc(s) qm_malloc(mem_block, (s))
f22b996b
 #			define pkg_realloc(p, s) qm_realloc(mem_block, (p), (s))
dda9dab1
 #			define pkg_free(p)   qm_free(mem_block, (p))
 #		endif
 #	endif
f92113d8
 #	ifdef F_MALLOC
8799e028
 #		define pkg_status()    fm_status(mem_block)
 #		define pkg_info(mi)    fm_info(mem_block, mi)
 #		define pkg_available() fm_available(mem_block)
ed20ee1d
 #		define pkg_sums()      fm_sums(mem_block)
51ea5ec2
 #	elif defined DL_MALLOC
 #		define pkg_status()  0
 #		define pkg_info(mi)  0
 #		define pkg_available()  0
ed20ee1d
 #		define pkg_sums()  0
dda9dab1
 #	else
8799e028
 #		define pkg_status()    qm_status(mem_block)
 #		define pkg_info(mi)    qm_info(mem_block, mi)
 #		define pkg_available() qm_available(mem_block)
ed20ee1d
 #		define pkg_sums()      qm_sums(mem_block)
dda9dab1
 #	endif
 #elif defined(SHM_MEM) && defined(USE_SHM_MEM)
 #	include "shm_mem.h"
 #	define pkg_malloc(s) shm_malloc((s))
 #	define pkg_free(p)   shm_free((p))
 #	define pkg_status()  shm_status()
ed20ee1d
 #	define pkg_sums()    shm_sums()
dda9dab1
 #else
 #	include <stdlib.h>
58d0d1b5
 #	include "memdbg.h"
dda9dab1
 #	define pkg_malloc(s) \
0809c3f7
 	(  { void *____v123; ____v123=malloc((s)); \
 	   MDBG("malloc %p size %lu end %p\n", ____v123, (unsigned long)(s), (char*)____v123+(s));\
 	   ____v123; } )
 #	define pkg_realloc(p, s) \
 	(  { void *____v123; ____v123=realloc(p, s); \
 	   MDBG("realloc %p size %lu end %p\n", ____v123, (unsigned long)(s), (char*)____v123+(s));\
 	    ____v123; } )
58d0d1b5
 #	define pkg_free(p)  do{ MDBG("free %p\n", (p)); free((p)); }while(0);
dda9dab1
 #	define pkg_status()
ed20ee1d
 #	define pkg_sums()
dda9dab1
 #endif
 
47f59303
 /**
  * \brief Initialize private memory pool
  * \return 0 if the memory allocation was successful, -1 otherwise
  */
9f8a2ff6
 int init_pkg_mallocs(void);
47f59303
 
 /**
  * \brief Destroy private memory pool
  */
9f8a2ff6
 void destroy_pkg_mallocs(void);
47f59303
 
 /**
  * \brief Initialize shared memory pool
  * \param force_alloc Force allocation of memory, e.g. initialize complete block with zero
  * \return 0 if the memory allocation was successful, -1 otherwise
  */
7c855aa0
 int init_shm_mallocs(int force_alloc);
dda9dab1
 
47f59303
 /** generic logging helper for allocation errors in private memory pool/ system */
f34610e3
 #ifdef SYSTEM_MALLOC
 #define PKG_MEM_ERROR LM_ERR("could not allocate private memory from system")
 #else
 #define PKG_MEM_ERROR LM_ERR("could not allocate private memory from available pool")
 #endif
47f59303
 /** generic logging helper for allocation errors in shared memory pool */
f34610e3
 #define SHM_MEM_ERROR LM_ERR("could not allocate shared memory from available pool")
 
dda9dab1
 #endif