/src/opensips/mem/shm_mem.h

Source (jump to first uncovered line)
/*
 * Shared memory functions
 *
 * Copyright (C) 2001-2003 FhG Fokus
 * Copyright (C) 2019 OpenSIPS Solutions
 *
 * This file is part of opensips, a free SIP server.
 *
 * opensips is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version
 *
 * opensips is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 */


#include "../statistics.h"
#include "../error.h"

#ifndef shm_mem_h
#define shm_mem_h

#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/ipc.h>


#ifndef SHM_MMAP

#include <sys/shm.h>

#endif

#include <sys/sem.h>
#include <string.h>
#include <errno.h>

#include "../dprint.h"
#include "../globals.h"
#include "../lock_ops.h" /* we don't include locking.h on purpose */
#include "mem_funcs.h"
#include "common.h"

#include "../mi/mi.h"

#ifdef SHM_EXTRA_STATS
#include "module_info.h"
#include "mem_stats.h"

#ifdef INLINE_ALLOC
#if defined F_MALLOC
#define shm_stats_core_init fm_stats_core_init
#define shm_stats_get_index fm_stats_get_index
#define shm_stats_set_index fm_stats_set_index
#define shm_frag_overhead FM_FRAG_OVERHEAD
#define shm_frag_file fm_frag_file
#define shm_frag_func fm_frag_func
#define shm_frag_line fm_frag_line
#elif defined Q_MALLOC
#define shm_stats_core_init qm_stats_core_init
#define shm_stats_get_index qm_stats_get_index
#define shm_stats_set_index qm_stats_set_index
#define shm_frag_overhead QM_FRAG_OVERHEAD
#define shm_frag_file qm_frag_file
#define shm_frag_func qm_frag_func
#define shm_frag_line qm_frag_line
#elif defined HP_MALLOC
#define shm_stats_core_init hp_stats_core_init
#define shm_stats_get_index hp_stats_get_index
#define shm_stats_set_index hp_stats_set_index
#define shm_frag_overhead HP_FRAG_OVERHEAD
#define shm_frag_file hp_frag_file
#define shm_frag_func hp_frag_func
#define shm_frag_line hp_frag_line
#endif
#else
extern void (*shm_stats_core_init)(void *blk, int core_index);
extern unsigned long (*shm_stats_get_index)(void *ptr);
extern void (*shm_stats_set_index)(void *ptr, unsigned long idx);
extern int shm_frag_overhead;
extern const char *(*shm_frag_file)(void *p);
extern const char *(*shm_frag_func)(void *p);
extern unsigned long (*shm_frag_line)(void *p);
#endif
#endif

#ifdef INLINE_ALLOC
#ifdef F_MALLOC
#define shm_frag_size fm_frag_size
#elif defined Q_MALLOC
#define shm_frag_size qm_frag_size
#elif defined HP_MALLOC
#define shm_frag_size hp_frag_size
#elif defined F_PARALLEL_MALLOC
#define shm_frag_size parallel_frag_size
#endif
#else
extern unsigned long (*shm_frag_size)(void *p);
#endif

int set_shm_mm(const char *mm_name);

#ifndef INLINE_ALLOC
#ifdef DBG_MALLOC
extern void *(*gen_shm_malloc)(void *blk, unsigned long size,
                        const char *file, const char *func, unsigned int line);
extern void *(*gen_shm_malloc_unsafe)(void *blk, unsigned long size,
                        const char *file, const char *func, unsigned int line);
extern void *(*gen_shm_realloc)(void *blk, void *p, unsigned long size,
                        const char *file, const char *func, unsigned int line);
extern void *(*gen_shm_realloc_unsafe)(void *blk, void *p, unsigned long size,
                        const char *file, const char *func, unsigned int line);
extern void (*gen_shm_free)(void *blk, void *p,
                        const char *file, const char *func, unsigned int line);
extern void (*gen_shm_free_unsafe)(void *blk, void *p,
                        const char *file, const char *func, unsigned int line);
#else
extern void *(*gen_shm_malloc)(void *blk, unsigned long size);
extern void *(*gen_shm_malloc_unsafe)(void *blk, unsigned long size);
extern void *(*gen_shm_realloc)(void *blk, void *p, unsigned long size);
extern void *(*gen_shm_realloc_unsafe)(void *blk, void *p, unsigned long size);
extern void (*gen_shm_free)(void *blk, void *p);
extern void (*gen_shm_free_unsafe)(void *blk, void *p);
#endif
extern void (*gen_shm_info)(void *blk, struct mem_info *info);
extern void (*gen_shm_status)(void *blk);
extern unsigned long (*gen_shm_get_size)(void *blk);
extern unsigned long (*gen_shm_get_used)(void *blk);
extern unsigned long (*gen_shm_get_rused)(void *blk);
extern unsigned long (*gen_shm_get_mused)(void *blk);
extern unsigned long (*gen_shm_get_free)(void *blk);
extern unsigned long (*gen_shm_get_frags)(void *blk);
#endif

#ifdef INLINE_ALLOC
#ifdef F_MALLOC
#define SHM_MALLOC             fm_malloc
#define SHM_MALLOC_UNSAFE      fm_malloc
#define SHM_REALLOC            fm_realloc
#define SHM_REALLOC_UNSAFE     fm_realloc
#define SHM_FREE               fm_free
#define SHM_FREE_UNSAFE        fm_free
#define SHM_INFO               fm_info
#define SHM_STATUS             fm_status
#define SHM_GET_SIZE           fm_get_size
#define SHM_GET_USED           fm_get_used
#define SHM_GET_RUSED          fm_get_real_used
#define SHM_GET_MUSED          fm_get_max_real_used
#define SHM_GET_FREE           fm_get_free
#define SHM_GET_FRAGS          fm_get_frags
#elif defined Q_MALLOC
#define SHM_MALLOC             qm_malloc
#define SHM_MALLOC_UNSAFE      qm_malloc
#define SHM_REALLOC            qm_realloc
#define SHM_REALLOC_UNSAFE     qm_realloc
#define SHM_FREE               qm_free
#define SHM_FREE_UNSAFE        qm_free
#define SHM_INFO               qm_info
#define SHM_STATUS             qm_status
#define SHM_GET_SIZE           qm_get_size
#define SHM_GET_USED           qm_get_used
#define SHM_GET_RUSED          qm_get_real_used
#define SHM_GET_MUSED          qm_get_max_real_used
#define SHM_GET_FREE           qm_get_free
#define SHM_GET_FRAGS          qm_get_frags
#elif defined HP_MALLOC
#define SHM_MALLOC             hp_shm_malloc
#define SHM_MALLOC_UNSAFE      hp_shm_malloc_unsafe
#define SHM_REALLOC            hp_shm_realloc
#define SHM_REALLOC_UNSAFE     hp_shm_realloc_unsafe
#define SHM_FREE               hp_shm_free
#define SHM_FREE_UNSAFE        hp_shm_free_unsafe
#define SHM_INFO               hp_info
#define SHM_STATUS             hp_status
#define SHM_GET_SIZE           hp_shm_get_size
#define SHM_GET_USED           hp_shm_get_used
#define SHM_GET_RUSED          hp_shm_get_real_used
#define SHM_GET_MUSED          hp_shm_get_max_real_used
#define SHM_GET_FREE           hp_shm_get_free
#define SHM_GET_FRAGS          hp_shm_get_frags
#endif /* F_MALLOC || Q_MALLOC || HP_MALLOC */
#else
#define SHM_MALLOC             gen_shm_malloc
#define SHM_MALLOC_UNSAFE      gen_shm_malloc_unsafe
#define SHM_REALLOC            gen_shm_realloc
#define SHM_REALLOC_UNSAFE     gen_shm_realloc_unsafe
#define SHM_FREE               gen_shm_free
#define SHM_FREE_UNSAFE        gen_shm_free_unsafe
#define SHM_INFO               gen_shm_info
#define SHM_STATUS             gen_shm_status
#define SHM_GET_SIZE           gen_shm_get_size
#define SHM_GET_USED           gen_shm_get_used
#define SHM_GET_RUSED          gen_shm_get_rused
#define SHM_GET_MUSED          gen_shm_get_mused
#define SHM_GET_FREE           gen_shm_get_free
#define SHM_GET_FRAGS          gen_shm_get_frags
#endif /* INLINE_ALLOC */

#if defined F_MALLOC || defined Q_MALLOC
extern gen_lock_t* mem_lock;
extern gen_lock_t* rpmem_lock;
#endif

#ifdef DBG_MALLOC
extern gen_lock_t* mem_dbg_lock;
#endif

#ifdef HP_MALLOC
extern gen_lock_t* mem_locks;
extern gen_lock_t* rpmem_locks;
#endif

extern enum osips_mm mem_allocator_shm;

#define INVALID_MAP ((void *)-1)
int shm_mem_init(); /* calls shm_getmem & shm_mem_init_mallocs */

#ifdef DBG_MALLOC
int shm_dbg_mem_init(void);
#endif

/*
 * must be called after the statistics engine is initialized
 *  - updates the atomic shm statistics with proper values
 *  - performs memory warming with HP_MALLOC
 */
int init_shm_post_yyparse(void);
void *shm_getmem(int, void *, unsigned long);   /* allocates the memory (mmap or sysv shmap) */
void shm_relmem(void *, unsigned long); /* deallocates the memory allocated by shm_getmem() */
void shm_mem_destroy();


#ifdef STATISTICS

// threshold percentage checked
extern long event_shm_threshold;

// determines the last percentage triggered
extern long *event_shm_last;

// determines if there is a pending event
extern int *event_shm_pending;

/* indicates the statistics updates should not be done */
#ifdef SHM_EXTRA_STATS
extern int mem_skip_stats;
#endif

// events are used only if SHM and STATISTICS are used
void shm_event_raise(long used, long size, long perc);

inline static void shm_threshold_check(void)
{
  long shm_perc, used, size;

  if (event_shm_threshold == 0 || // threshold not used)
      !shm_block || !event_shm_last || !event_shm_pending || // shm not init
      *event_shm_pending ) { // somebody else is raising the event
    // do not do anything
    return;
  }

  // compute the percentage here to avoid a function call
  used = SHM_GET_RUSED(shm_block);
  size = SHM_GET_SIZE(shm_block);
  shm_perc = used * 100 / size;

  /* check if the event has to be raised or if it was already notified */
  if ((shm_perc < event_shm_threshold && *event_shm_last <= event_shm_threshold) ||
    (shm_perc >= event_shm_threshold && *event_shm_last == shm_perc))
    return;

  shm_event_raise(used, size, shm_perc);
}
#else
 #define shm_threshold_check()
#endif

#if defined(HP_MALLOC) || defined(F_PARALLEL_MALLOC)
  #ifdef INLINE_ALLOC
  #define shm_lock()
  #define shm_unlock()
  #else
  extern int shm_use_global_lock;
  #define shm_lock() \
    do { \
      if (shm_use_global_lock) \
        lock_get(mem_lock); \
    } while (0)
  #define shm_unlock() \
    do { \
      if (shm_use_global_lock) \
        lock_release(mem_lock); \
    } while (0)
  #endif
  extern unsigned long long *shm_hash_usage;
#else
#define shm_lock()    lock_get(mem_lock)
#define shm_unlock()  lock_release(mem_lock)
#endif

#ifdef DBG_MALLOC
#define shm_dbg_lock()    lock_get(mem_dbg_lock)
#define shm_dbg_unlock()  lock_release(mem_dbg_lock)
#endif

#ifdef SHM_EXTRA_STATS
  #define PASTER(_x, _y) _x ## _y
  #define VAR_STAT(_n) PASTER(_n, _mem_stat)
#endif

#include "shm_mem_dbg.h"

#ifdef DBG_MALLOC

  #ifdef __SUNPRO_C
      #define __FUNCTION__ ""  /* gcc specific */
  #endif

inline static void* _shm_dbg_malloc(unsigned long size,
  const char *file, const char *function, unsigned int line )
{
  void *p;

  shm_dbg_lock();

  p = SHM_MALLOC(shm_dbg_block, size, file, function, line);

  shm_dbg_unlock();

  return p;
}

inline static void* _shm_dbg_malloc_unsafe(unsigned long size,
  const char *file, const char *function, unsigned int line )
{
  void *p;

  p = SHM_MALLOC(shm_dbg_block, size, file, function, line);

  return p;
}

inline static void* _shm_dbg_realloc(void *ptr, unsigned long size,
    const char* file, const char* function, unsigned int line )
{
  void *p;

  shm_dbg_lock();

  p = SHM_REALLOC(shm_dbg_block, ptr, size, file, function, line);

  shm_dbg_unlock();

  return p;
}

inline static void _shm_dbg_free(void *ptr,
    const char* file, const char* function, unsigned int line)
{
  shm_dbg_lock();

  SHM_FREE(shm_dbg_block, ptr, file, function, line);

  shm_dbg_unlock();
}

#define shm_dbg_malloc_func _shm_dbg_malloc
#define shm_dbg_malloc( _size ) _shm_dbg_malloc((_size), \
  __FILE__, __FUNCTION__, __LINE__ )

#define shm_dbg_malloc_unsafe_func _shm_dbg_malloc_unsafe
#define shm_dbg_malloc_unsafe( _size ) _shm_dbg_malloc_unsafe((_size), \
  __FILE__, __FUNCTION__, __LINE__ )

#define shm_dbg_realloc_func _shm_dbg_realloc
#define shm_dbg_realloc( _ptr, _size ) _shm_dbg_realloc( (_ptr), (_size), \
  __FILE__, __FUNCTION__, __LINE__ )

#define shm_dbg_free_func _shm_dbg_free
#define shm_dbg_free( _ptr ) _shm_dbg_free( (_ptr), \
  __FILE__, __FUNCTION__, __LINE__ )

#define shm_malloc_func _shm_malloc
#define shm_realloc_func _shm_realloc
#define shm_free_func _shm_free

inline static void* _shm_malloc(unsigned long size,
  const char *file, const char *function, unsigned int line )
{
  void *p;

  shm_lock();

  p = SHM_MALLOC(shm_block, size, file, function, line);
  shm_threshold_check();

  shm_unlock();

  DBG_SHM_ALLOC(SH_SHM_MALLOC);

  #ifdef SHM_EXTRA_STATS
  if (p) {
    unsigned long size_f = shm_frag_size(p);
    update_module_stats(size_f, size_f + shm_frag_overhead, 1, VAR_STAT(MOD_NAME));
    shm_stats_set_index(p, VAR_STAT(MOD_NAME));
  }
  #endif

  return p;
}

inline static void* _shm_malloc_unsafe(unsigned long size,
  const char *file, const char *function, unsigned int line )
{
  void *p;

  p = SHM_MALLOC_UNSAFE(shm_block, size, file, function, line);
  shm_threshold_check();

#ifdef SHM_EXTRA_STATS
  if (p) {
    unsigned long size_f = shm_frag_size(p);
    update_module_stats(size_f, size_f + shm_frag_overhead, 1, VAR_STAT(MOD_NAME));
    shm_stats_set_index(p, VAR_STAT(MOD_NAME));
  }
#endif

  return p;
}

inline static void* _shm_malloc_bulk(unsigned long size,
  const char *file, const char *function, unsigned int line )
{
  void *p;

  p = SHM_MALLOC(shm_block, size, file, function, line);
  shm_threshold_check();

  DBG_SHM_ALLOC(SH_SHM_MALLOC);

  #ifdef SHM_EXTRA_STATS
  if (p) {
    unsigned long size_f = shm_frag_size(p);
    update_module_stats(size_f, size_f + shm_frag_overhead, 1, VAR_STAT(MOD_NAME));
    shm_stats_set_index(p, VAR_STAT(MOD_NAME));
  }
  #endif

  return p;
}

inline static void* _shm_realloc(void *ptr, unsigned long size,
    const char* file, const char* function, unsigned int line )
{
  void *p;

  #ifdef SHM_EXTRA_STATS
    unsigned long origin = 0;
    if (ptr) {
      origin = shm_stats_get_index(ptr);
      update_module_stats(-shm_frag_size(ptr), -(shm_frag_size(ptr) + shm_frag_overhead), -1, shm_stats_get_index(ptr));
    }
  #endif

  shm_lock();

  p = SHM_REALLOC(shm_block, ptr, size, file, function, line);
  shm_threshold_check();

  shm_unlock();

  DBG_SHM_ALLOC(SH_SHM_REALLOC);

  #ifdef SHM_EXTRA_STATS
  if (p) {
    update_module_stats(shm_frag_size(p), shm_frag_size(p) + shm_frag_overhead,
      1 , VAR_STAT(MOD_NAME));
    if (ptr && origin !=  VAR_STAT(MOD_NAME))
      LM_GEN1(memlog, "memory reallocated from different module than it was allocated, allocated in"
        "module index %ld, at %s: %s %ld, reallocated in module index %ld, at %s: %s %d \n", 
        origin, shm_frag_file(p), shm_frag_func(p), shm_frag_line(p), VAR_STAT(MOD_NAME), file, function, line);
    shm_stats_set_index(p, VAR_STAT(MOD_NAME));
  }
  #endif

  return p;
}

inline static void* _shm_realloc_unsafe(void *ptr, unsigned long size,
    const char* file, const char* function, unsigned int line )
{
  void *p;

  #ifdef SHM_EXTRA_STATS
    unsigned long origin = 0;
    if (ptr) {
      origin = shm_stats_get_index(ptr);
      update_module_stats(-shm_frag_size(ptr), -(shm_frag_size(ptr) + shm_frag_overhead), -1, shm_stats_get_index(ptr));
    }
  #endif

  p = SHM_REALLOC_UNSAFE(shm_block, ptr, size, file, function, line);
  shm_threshold_check();

  #ifdef SHM_EXTRA_STATS
  if (p) {
    update_module_stats(shm_frag_size(p), shm_frag_size(p) +  shm_frag_overhead,
      1 , VAR_STAT(MOD_NAME));
    if (ptr && origin !=  VAR_STAT(MOD_NAME))
      LM_GEN1(memlog, "memory reallocated from different module than it was allocated, allocated in"
        "module index %ld, at %s: %s %ld, reallocated in module index %ld, at %s: %s %d \n", 
        origin, shm_frag_file(p), shm_frag_func(p), shm_frag_line(p), VAR_STAT(MOD_NAME), file, function, line);
    shm_stats_set_index(p, VAR_STAT(MOD_NAME));
  }
  #endif

  return p;
}

inline static void _shm_free(void *ptr,
    const char* file, const char* function, unsigned int line)
{
  int size = -1;

  shm_lock();

  #ifdef SHM_EXTRA_STATS
    if (shm_stats_get_index(ptr) !=  VAR_STAT(MOD_NAME)) {
        update_module_stats(-shm_frag_size(ptr), -(shm_frag_size(ptr) + shm_frag_overhead), -1, shm_stats_get_index(ptr));
        LM_GEN1(memlog, "memory freed from different module than it was allocated, allocated in"
          "module with index %ld, freed in module index %ld, at %s: %s %d \n", shm_stats_get_index(ptr), VAR_STAT(MOD_NAME),
          __FILE__, __FUNCTION__, __LINE__);
    } else {
      update_module_stats(-shm_frag_size(ptr), -(shm_frag_size(ptr) + shm_frag_overhead), -1, VAR_STAT(MOD_NAME));
    }
  #endif

  if (ptr)
    size = shm_frag_size(ptr);

  SHM_FREE(shm_block, ptr, file, function, line);
  shm_threshold_check();

  shm_unlock();
  DBG_SHM_FREE(file, function, line, size);
}

inline static void _shm_free_unsafe(void *ptr,
    const char* file, const char* function, unsigned int line )
{

#ifdef SHM_EXTRA_STATS
  if (shm_stats_get_index(ptr) !=  VAR_STAT(MOD_NAME)) {
    update_module_stats(-shm_frag_size(ptr), -(shm_frag_size(ptr) + shm_frag_overhead), -1, shm_stats_get_index(ptr));
    LM_GEN1(memlog, "memory freed from different module than it was allocated, allocated in"
      "module index %ld, at %s: %s %ld, freed in module index %ld, at %s: %s %d \n",
      shm_stats_get_index(ptr), shm_frag_file(ptr), shm_frag_func(ptr), shm_frag_line(ptr), VAR_STAT(MOD_NAME),
      file, function, line);
  } else {
    update_module_stats(-shm_frag_size(ptr), -(shm_frag_size(ptr) + shm_frag_overhead), -1, VAR_STAT(MOD_NAME));
  }
#endif

  SHM_FREE_UNSAFE(shm_block, ptr, file, function, line);
  shm_threshold_check();
}

inline static void _shm_free_bulk(void *ptr,
    const char* file, const char* function, unsigned int line)
{
  int size;

  #ifdef SHM_EXTRA_STATS
    if (shm_stats_get_index(ptr) !=  VAR_STAT(MOD_NAME)) {
        update_module_stats(-shm_frag_size(ptr), -(shm_frag_size(ptr) + shm_frag_overhead), -1, shm_stats_get_index(ptr));
        LM_GEN1(memlog, "memory freed from different module than it was allocated, allocated in"
          "module with index %ld, freed in module index %ld, at %s: %s %d \n", shm_stats_get_index(ptr), VAR_STAT(MOD_NAME),
          __FILE__, __FUNCTION__, __LINE__);
    } else {
      update_module_stats(-shm_frag_size(ptr), -(shm_frag_size(ptr) + shm_frag_overhead), -1, VAR_STAT(MOD_NAME));
    }
  #endif

  if (ptr)
    size = shm_frag_size(ptr);

  SHM_FREE(shm_block, ptr, file, function, line);
  shm_threshold_check();

  DBG_SHM_FREE(file, function, line, size);
}

#define shm_malloc_func _shm_malloc
#define shm_malloc( _size ) _shm_malloc((_size), \
  __FILE__, __FUNCTION__, __LINE__ )

#define shm_malloc_unsafe_func _shm_malloc_unsafe
#define shm_malloc_unsafe(_size ) _shm_malloc_unsafe((_size), \
  __FILE__, __FUNCTION__, __LINE__ )

#define shm_malloc_bulk_func  _shm_malloc_bulk
#define shm_malloc_bulk(_size ) _shm_malloc_bulk((_size), \
  __FILE__, __FUNCTION__, __LINE__ )

#define shm_realloc_func _shm_realloc
#define shm_realloc( _ptr, _size ) _shm_realloc( (_ptr), (_size), \
  __FILE__, __FUNCTION__, __LINE__ )

#define shm_realloc_func_unsafe _shm_realloc_unsafe
#define shm_realloc_unsafe( _ptr, _size ) _shm_realloc_unsafe( (_ptr), (_size), \
  __FILE__, __FUNCTION__, __LINE__ )

#define shm_free_func _shm_free
#define shm_free( _ptr ) _shm_free( (_ptr), \
  __FILE__, __FUNCTION__, __LINE__ )

#define shm_free_unsafe_func _shm_free_unsafe
#define shm_free_unsafe( _ptr ) _shm_free_unsafe( (_ptr), \
  __FILE__, __FUNCTION__, __LINE__ )

#define shm_free_bulk_func _shm_free_bulk
#define shm_free_bulk( _ptr ) _shm_free_bulk( (_ptr), \
  __FILE__, __FUNCTION__, __LINE__ )

#else /*DBG_MALLOC*/

#define shm_malloc_func shm_malloc
inline static void* shm_malloc(unsigned long size)
{
  void *p;

  shm_lock();

  p = SHM_MALLOC(shm_block, size);
  shm_threshold_check();

  shm_unlock();

#ifdef SHM_EXTRA_STATS
  if (p) {
    unsigned long size_f = shm_frag_size(p);
    update_module_stats(size_f, size_f + shm_frag_overhead, 1, VAR_STAT(MOD_NAME));
    shm_stats_set_index(p, VAR_STAT(MOD_NAME));
  }
#endif

  return p;
}

#define shm_malloc_func_unsafe shm_malloc_unsafe
inline static void* shm_malloc_unsafe(unsigned int size)
{
  void *p;

  p = SHM_MALLOC_UNSAFE(shm_block, size);

  shm_threshold_check();

#ifdef SHM_EXTRA_STATS
  if (p) {
    unsigned long size_f = shm_frag_size(p);
    update_module_stats(size_f, size_f + shm_frag_overhead, 1, VAR_STAT(MOD_NAME));
    shm_stats_set_index(p, VAR_STAT(MOD_NAME));
  }
#endif

  return p;
}

#define shm_malloc_bulk_func shm_malloc_bulk
inline static void* shm_malloc_bulk(unsigned long size)
{
  void *p;

  p = SHM_MALLOC(shm_block, size);
  shm_threshold_check();

#ifdef SHM_EXTRA_STATS
  if (p) {
    unsigned long size_f = shm_frag_size(p);
    update_module_stats(size_f, size_f + shm_frag_overhead, 1, VAR_STAT(MOD_NAME));
    shm_stats_set_index(p, VAR_STAT(MOD_NAME));
  }
#endif

  return p;
}

#define shm_realloc_func shm_realloc
inline static void* shm_realloc(void *ptr, unsigned long size)
{
  void *p;

  shm_lock();

#ifdef SHM_EXTRA_STATS
  unsigned long origin = 0;
  if (ptr) {
    origin = shm_stats_get_index(ptr);
    update_module_stats(-shm_frag_size(ptr), -(shm_frag_size(ptr) + shm_frag_overhead), -1, shm_stats_get_index(ptr));
  }
#endif

  p = SHM_REALLOC(shm_block, ptr, size);
  shm_threshold_check();

  shm_unlock();

#ifdef SHM_EXTRA_STATS
  if (p) {
    update_module_stats(shm_frag_size(p), shm_frag_size(p) + shm_frag_overhead,
                        1 , VAR_STAT(MOD_NAME));
    if (ptr && origin !=  VAR_STAT(MOD_NAME))
      LM_GEN1(memlog, "memory reallocated from different module than it was allocated, allocated in"
        "module with index %ld, freed in module with index %ld, at %s: %s %d \n", origin,
        VAR_STAT(MOD_NAME), __FILE__, __FUNCTION__, __LINE__);
    shm_stats_set_index(p, VAR_STAT(MOD_NAME));
  }
#endif

  return p;
}

#define shm_realloc_func_unsafe shm_realloc_unsafe
inline static void* shm_realloc_unsafe(void *ptr, unsigned long size)
{
  void *p;

#ifdef SHM_EXTRA_STATS
  unsigned long origin = 0;
  if (ptr) {
    origin = shm_stats_get_index(ptr);
    update_module_stats(-shm_frag_size(ptr), -(shm_frag_size(ptr) + shm_frag_overhead), -1, shm_stats_get_index(ptr));
  }
#endif

  p = SHM_REALLOC_UNSAFE(shm_block, ptr, size);
  shm_threshold_check();

#ifdef SHM_EXTRA_STATS
  if (p) {
    update_module_stats(shm_frag_size(p), shm_frag_size(p) + shm_frag_overhead,
                        1, VAR_STAT(MOD_NAME));
    if (ptr && origin !=  VAR_STAT(MOD_NAME))
      LM_GEN1(memlog, "memory reallocated from different module than it was allocated, allocated in"
        "module with index %ld, freed in module with index %ld, at %s: %s %d \n", origin,
        VAR_STAT(MOD_NAME), __FILE__, __FUNCTION__, __LINE__);
    shm_stats_set_index(p, VAR_STAT(MOD_NAME));
  }
#endif
  return p;
}

#define shm_free_func shm_free
inline static void shm_free(void *_p)
{
  shm_lock();

  #ifdef SHM_EXTRA_STATS
    if (shm_stats_get_index(_p) !=  VAR_STAT(MOD_NAME)) {
        update_module_stats(-shm_frag_size(_p), -(shm_frag_size(_p) + shm_frag_overhead), -1, shm_stats_get_index(_p));
        LM_GEN1(memlog, "memory freed from different module than it was allocated, allocated in"
          "module with index %ld, freed in module index %ld, at %s: %s %d \n", shm_stats_get_index(_p), VAR_STAT(MOD_NAME),
          __FILE__, __FUNCTION__, __LINE__);
    } else {
      update_module_stats(-shm_frag_size(_p), -(shm_frag_size(_p) + shm_frag_overhead), -1, VAR_STAT(MOD_NAME));
    }
  #endif

  SHM_FREE(shm_block, _p);
  shm_threshold_check();

  shm_unlock();
}

#define shm_free_unsafe_func shm_free_unsafe
inline static void shm_free_unsafe(void *_p)
{
  #ifdef SHM_EXTRA_STATS
  if (shm_stats_get_index(_p) !=  VAR_STAT(MOD_NAME)) {
      update_module_stats(-shm_frag_size(_p), -(shm_frag_size(_p) + shm_frag_overhead), -1, shm_stats_get_index(_p));
      LM_GEN1(memlog, "memory freed from different module than it was allocated, allocated in"
        "module with index %ld, freed in module index %ld, at %s: %s %d \n", shm_stats_get_index(_p), VAR_STAT(MOD_NAME),
        __FILE__, __FUNCTION__, __LINE__);
  } else {
    update_module_stats(-shm_frag_size(_p), -(shm_frag_size(_p) + shm_frag_overhead), -1, VAR_STAT(MOD_NAME));
  }
  #endif
  SHM_FREE_UNSAFE(shm_block, (_p)); \
  shm_threshold_check(); \
}

#define shm_free_bulk_func shm_free_bulk
inline static void shm_free_bulk(void *_p)
{

  #ifdef SHM_EXTRA_STATS
    if (shm_stats_get_index(_p) !=  VAR_STAT(MOD_NAME)) {
        update_module_stats(-shm_frag_size(_p), -(shm_frag_size(_p) + shm_frag_overhead), -1, shm_stats_get_index(_p));
        LM_GEN1(memlog, "memory freed from different module than it was allocated, allocated in"
          "module with index %ld, freed in module index %ld, at %s: %s %d \n", shm_stats_get_index(_p), VAR_STAT(MOD_NAME),
          __FILE__, __FUNCTION__, __LINE__);
    } else {
      update_module_stats(-shm_frag_size(_p), -(shm_frag_size(_p) + shm_frag_overhead), -1, VAR_STAT(MOD_NAME));
    }
  #endif

  SHM_FREE(shm_block, _p);
  shm_threshold_check();
}

#endif

inline static void shm_status(void)
{
  shm_lock();
  SHM_STATUS(shm_block);
  shm_unlock();
}


inline static void shm_info(struct mem_info* mi)
{
  shm_lock();
  SHM_INFO(shm_block, mi);
  shm_unlock();
}


inline static void shm_force_unlock(void)
{
  if (0
#if defined F_MALLOC || defined Q_MALLOC
    || mem_lock
#endif
#ifdef HP_MALLOC
    || mem_locks
#endif
  ) {
#if defined HP_MALLOC && (defined F_MALLOC || defined Q_MALLOC)
    if (mem_allocator_shm == MM_HP_MALLOC ||
            mem_allocator_shm == MM_HP_MALLOC_DBG) {
      int i;

      for (i = 0; i < HP_HASH_SIZE; i++)
        lock_release(&mem_locks[i]);
    } else {
      if (mem_lock)
        shm_unlock();
    }
#elif defined HP_MALLOC
    int i;

    for (i = 0; i < HP_HASH_SIZE; i++)
      lock_release(&mem_locks[i]);
#else
    shm_unlock();
#endif
  }
}


/*
 * performs a full shared memory pool scan for any corruptions or inconsistencies
 */
mi_response_t *mi_shm_check(const mi_params_t *params,
                struct mi_handler *async_hdl);

#ifdef STATISTICS
extern stat_export_t shm_stats[];

inline static unsigned long shm_get_size(unsigned short foo) {
  return SHM_GET_SIZE(shm_block);
}
inline static unsigned long shm_get_used(unsigned short foo) {
  return SHM_GET_USED(shm_block);
}
inline static unsigned long shm_get_rused(unsigned short foo) {
  return SHM_GET_RUSED(shm_block);
}
inline static unsigned long shm_get_mused(unsigned short foo) {
  return SHM_GET_MUSED(shm_block);
}
inline static unsigned long shm_get_free(unsigned short foo) {
  return SHM_GET_FREE(shm_block);
}
inline static unsigned long shm_get_frags(unsigned short foo) {
  return SHM_GET_FRAGS(shm_block);
}
#endif /*STATISTICS*/

#endif


Coverage Report

Created: 2025-07-18 06:32

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Shared memory functions
3		*
4		* Copyright (C) 2001-2003 FhG Fokus
5		* Copyright (C) 2019 OpenSIPS Solutions
6		*
7		* This file is part of opensips, a free SIP server.
8		*
9		* opensips is free software; you can redistribute it and/or modify
10		* it under the terms of the GNU General Public License as published by
11		* the Free Software Foundation; either version 2 of the License, or
12		* (at your option) any later version
13		*
14		* opensips is distributed in the hope that it will be useful,
15		* but WITHOUT ANY WARRANTY; without even the implied warranty of
16		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17		* GNU General Public License for more details.
18		*
19		* You should have received a copy of the GNU General Public License
20		* along with this program; if not, write to the Free Software
21		* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22		*/
23
24
25		#include "../statistics.h"
26		#include "../error.h"
27
28		#ifndef shm_mem_h
29		#define shm_mem_h
30
31		#include <stdlib.h>
32		#include <string.h>
33		#include <errno.h>
34		#include <sys/types.h>
35		#include <sys/ipc.h>
36
37
38		#ifndef SHM_MMAP
39