astobj2.c File Reference

#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/astobj2.h"
#include "asterisk/utils.h"
#include "asterisk/cli.h"

Include dependency graph for astobj2.c:

Go to the source code of this file.

Data Structures
struct	__priv_data
struct	ao2_container
struct	astobj2
struct	bucket_list
Defines
#define	AO2_MAGIC   0xa570b123
#define	EXTERNAL_OBJ(_p)   ((_p) == NULL ? NULL : (_p)->user_data)
	convert from a pointer _p to an astobj2 object
#define	REF_FILE   "/tmp/refs"
Functions
static void *	__ao2_alloc (size_t data_size, ao2_destructor_fn destructor_fn, const char *file, int line, const char *funcname)
static void *	__ao2_callback (struct ao2_container *c, const enum search_flags flags, ao2_callback_fn *cb_fn, void *arg, char *tag, char *file, int line, const char *funcname)
static struct ao2_container *	__ao2_container_alloc (struct ao2_container *c, const unsigned int n_buckets, ao2_hash_fn *hash_fn, ao2_callback_fn *cmp_fn)
static struct ao2_container *	__ao2_container_alloc (struct ao2_container *c, const uint n_buckets, ao2_hash_fn *hash_fn, ao2_callback_fn *cmp_fn)
static void *	__ao2_iterator_next (struct ao2_iterator *a, struct bucket_list **q)
static struct bucket_list *	__ao2_link (struct ao2_container *c, void *user_data)
static int	__ao2_ref (void *user_data, const int delta)
void *	_ao2_alloc (size_t data_size, ao2_destructor_fn destructor_fn)
void *	_ao2_alloc_debug (size_t data_size, ao2_destructor_fn destructor_fn, char *tag, const char *file, int line, const char *funcname, int ref_debug)
void *	_ao2_callback (struct ao2_container *c, const enum search_flags flags, ao2_callback_fn *cb_fn, void *arg)
void *	_ao2_callback_debug (struct ao2_container *c, const enum search_flags flags, ao2_callback_fn *cb_fn, void *arg, char *tag, char *file, int line, const char *funcname)
struct ao2_container *	_ao2_container_alloc (const unsigned int n_buckets, ao2_hash_fn *hash_fn, ao2_callback_fn *cmp_fn)
struct ao2_container *	_ao2_container_alloc_debug (const unsigned int n_buckets, ao2_hash_fn *hash_fn, ao2_callback_fn *cmp_fn, char *tag, char *file, int line, const char *funcname, int ref_debug)
void *	_ao2_find (struct ao2_container *c, void *arg, enum search_flags flags)
void *	_ao2_find_debug (struct ao2_container *c, void *arg, enum search_flags flags, char *tag, char *file, int line, const char *funcname)
void *	_ao2_iterator_next (struct ao2_iterator *a)
void *	_ao2_iterator_next_debug (struct ao2_iterator *a, char *tag, char *file, int line, const char *funcname)
void *	_ao2_link (struct ao2_container *c, void *user_data)
void *	_ao2_link_debug (struct ao2_container *c, void *user_data, char *tag, char *file, int line, const char *funcname)
int	_ao2_ref (void *user_data, const int delta)
int	_ao2_ref_debug (void *user_data, const int delta, char *tag, char *file, int line, const char *funcname)
void *	_ao2_unlink (struct ao2_container *c, void *user_data)
void *	_ao2_unlink_debug (struct ao2_container *c, void *user_data, char *tag, char *file, int line, const char *funcname)
void	ao2_bt (void)
int	ao2_container_count (struct ao2_container *c)
	Returns the number of elements in a container.
struct ao2_iterator	ao2_iterator_init (struct ao2_container *c, int flags)
int	ao2_lock (void *user_data)
	Lock an object.
int	ao2_match_by_addr (void *user_data, void *arg, int flags)
	another convenience function is a callback that matches on address
void *	ao2_object_get_lockaddr (void *obj)
	Return the lock address of an object.
int	ao2_trylock (void *user_data)
	Try locking-- (don't block if fail).
int	ao2_unlock (void *user_data)
	Unlock an object.
	AST_LIST_HEAD_NOLOCK (bucket, bucket_list)
int	astobj2_init (void)
static int	cb_true (void *user_data, void *arg, int flags)
	special callback that matches all
static int	cd_cb (void *obj, void *arg, int flag)
static int	cd_cb_debug (void *obj, void *arg, int flag)
static void	container_destruct (void *c)
static void	container_destruct_debug (void *c)
static int	hash_zero (const void *user_obj, const int flags)
	always zero hash function
static struct astobj2 *	INTERNAL_OBJ (void *user_data)
	convert from a pointer _p to a user-defined object

---

Define Documentation

#define AO2_MAGIC   0xa570b123

Definition at line 51 of file astobj2.c.

Referenced by __ao2_alloc(), and INTERNAL_OBJ().

#define EXTERNAL_OBJ

(

_p

)

((_p) == NULL ? NULL : (_p)->user_data)

convert from a pointer _p to an astobj2 object

Returns:

the pointer to the user-defined portion.

Definition at line 128 of file astobj2.c.

Referenced by __ao2_alloc(), __ao2_callback(), and __ao2_iterator_next().

#define REF_FILE   "/tmp/refs"

Definition at line 28 of file astobj2.c.

Referenced by _ao2_alloc_debug(), and _ao2_ref_debug().

---

Function Documentation

static void* __ao2_alloc	(	size_t	data_size,
		ao2_destructor_fn	destructor_fn,
		const char *	file,
		int	line,
		const char *	funcname
	)			[static]

Definition at line 300 of file astobj2.c.

References __ast_calloc(), AO2_MAGIC, ast_atomic_fetchadd_int(), ast_calloc, ast_mutex_init(), __priv_data::data_size, __priv_data::destructor_fn, EXTERNAL_OBJ, __priv_data::lock, __priv_data::magic, astobj2::priv_data, and __priv_data::ref_counter.

Referenced by _ao2_alloc(), and _ao2_alloc_debug().

{
   /* allocation */
   struct astobj2 *obj;

   if (data_size < sizeof(void *))
      data_size = sizeof(void *);

#if defined(__AST_DEBUG_MALLOC)
   obj = __ast_calloc(1, sizeof(*obj) + data_size, file, line, funcname);
#else
   obj = ast_calloc(1, sizeof(*obj) + data_size);
#endif

   if (obj == NULL)
      return NULL;

   ast_mutex_init(&obj->priv_data.lock);
   obj->priv_data.magic = AO2_MAGIC;
   obj->priv_data.data_size = data_size;
   obj->priv_data.ref_counter = 1;
   obj->priv_data.destructor_fn = destructor_fn;   /* can be NULL */

#ifdef AO2_DEBUG
   ast_atomic_fetchadd_int(&ao2.total_objects, 1);
   ast_atomic_fetchadd_int(&ao2.total_mem, data_size);
   ast_atomic_fetchadd_int(&ao2.total_refs, 1);
#endif

   /* return a pointer to the user data */
   return EXTERNAL_OBJ(obj);
}

static void * __ao2_callback	(	struct ao2_container *	c,
		const enum search_flags	flags,
		ao2_callback_fn *	cb_fn,
		void *	arg,
		char *	tag,
		char *	file,
		int	line,
		const char *	funcname
	)			[static]

Browse the container using different stategies accoding the flags.

Returns:

Is a pointer to an object or to a list of object if OBJ_MULTIPLE is specified. Luckily, for debug purposes, the added args (tag, file, line, funcname) aren't an excessive load to the system, as the callback should not be called as often as, say, the ao2_ref func is called.

Definition at line 590 of file astobj2.c.

References _ao2_ref(), _ao2_ref_debug(), ao2_lock(), ao2_unlock(), ast_atomic_fetchadd_int(), AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log(), ao2_container::buckets, cb_true(), CMP_MATCH, CMP_STOP, ao2_container::elements, EXTERNAL_OBJ, free, ao2_container::hash_fn, INTERNAL_OBJ(), last, LOG_WARNING, match(), ao2_container::n_buckets, OBJ_CONTINUE, OBJ_MULTIPLE, OBJ_NODATA, OBJ_POINTER, OBJ_UNLINK, and ao2_container::version.

Referenced by _ao2_callback(), and _ao2_callback_debug().

{
   int i, start, last;  /* search boundaries */
   void *ret = NULL;

   if (INTERNAL_OBJ(c) == NULL)  /* safety check on the argument */
      return NULL;

   if ((flags & (OBJ_MULTIPLE | OBJ_NODATA)) == OBJ_MULTIPLE) {
      ast_log(LOG_WARNING, "multiple data return not implemented yet (flags %x)\n", flags);
      return NULL;
   }

   /* override the match function if necessary */
   if (cb_fn == NULL)   /* if NULL, match everything */
      cb_fn = cb_true;
   /*
    * XXX this can be optimized.
    * If we have a hash function and lookup by pointer,
    * run the hash function. Otherwise, scan the whole container
    * (this only for the time being. We need to optimize this.)
    */
   if ((flags & OBJ_POINTER)) /* we know hash can handle this case */
      start = i = c->hash_fn(arg, flags & OBJ_POINTER) % c->n_buckets;
   else        /* don't know, let's scan all buckets */
      i = -1;     /* XXX this must be fixed later. */

   /* determine the search boundaries: i..last-1 */
   if (i < 0) {
      start = i = 0;
      last = c->n_buckets;
   } else if ((flags & OBJ_CONTINUE)) {
      last = c->n_buckets;
   } else {
      last = i + 1;
   }

   ao2_lock(c);   /* avoid modifications to the content */

   for (; i < last ; i++) {
      /* scan the list with prev-cur pointers */
      struct bucket_list *cur;

      AST_LIST_TRAVERSE_SAFE_BEGIN(&c->buckets[i], cur, entry) {
         int match = cb_fn(EXTERNAL_OBJ(cur->astobj), arg, flags) & (CMP_MATCH | CMP_STOP);

         /* we found the object, performing operations according flags */
         if (match == 0) { /* no match, no stop, continue */
            continue;
         } else if (match == CMP_STOP) {  /* no match but stop, we are done */
            i = last;
            break;
         }
         /* we have a match (CMP_MATCH) here */
         if (!(flags & OBJ_NODATA)) {  /* if must return the object, record the value */
            /* it is important to handle this case before the unlink */
            ret = EXTERNAL_OBJ(cur->astobj);
            if (tag)
               _ao2_ref_debug(ret, 1, tag, file, line, funcname);
            else
               _ao2_ref(ret, 1);
         }

         if (flags & OBJ_UNLINK) {  /* must unlink */
            struct bucket_list *x = cur;

            /* we are going to modify the container, so update version */
            ast_atomic_fetchadd_int(&c->version, 1);
            AST_LIST_REMOVE_CURRENT(entry);
            /* update number of elements and version */
            ast_atomic_fetchadd_int(&c->elements, -1);
            if (tag)
               _ao2_ref_debug(EXTERNAL_OBJ(x->astobj), -1, tag, file, line, funcname);
            else
               _ao2_ref(EXTERNAL_OBJ(x->astobj), -1);
            free(x); /* free the link record */
         }

         if ((match & CMP_STOP) || (flags & OBJ_MULTIPLE) == 0) {
            /* We found the only match we need */
            i = last;   /* force exit from outer loop */
            break;
         }
         if (!(flags & OBJ_NODATA)) {
#if 0 /* XXX to be completed */
            /*
             * This is the multiple-return case. We need to link
             * the object in a list. The refcount is already increased.
             */
#endif
         }
      }
      AST_LIST_TRAVERSE_SAFE_END;

      if (ret) {
         /* This assumes OBJ_MULTIPLE with !OBJ_NODATA is still not implemented */
         break;
      }

      if (i == c->n_buckets - 1 && (flags & OBJ_POINTER) && (flags & OBJ_CONTINUE)) {
         /* Move to the beginning to ensure we check every bucket */
         i = -1;
         last = start;
      }
   }
   ao2_unlock(c);
   return ret;
}

static struct ao2_container* __ao2_container_alloc	(	struct ao2_container *	c,
		const unsigned int	n_buckets,
		ao2_hash_fn *	hash_fn,
		ao2_callback_fn *	cmp_fn
	)			[static, read]

Definition at line 420 of file astobj2.c.

References ast_atomic_fetchadd_int(), ao2_container::cmp_fn, ao2_container::hash_fn, hash_zero(), ao2_container::n_buckets, and ao2_container::version.

{
   /* XXX maybe consistency check on arguments ? */
   /* compute the container size */

   if (!c)
      return NULL;
   
   c->version = 1;   /* 0 is a reserved value here */
   c->n_buckets = n_buckets;
   c->hash_fn = hash_fn ? hash_fn : hash_zero;
   c->cmp_fn = cmp_fn;

#ifdef AO2_DEBUG
   ast_atomic_fetchadd_int(&ao2.total_containers, 1);
#endif

   return c;
}

static struct ao2_container* __ao2_container_alloc	(	struct ao2_container *	c,
		const uint	n_buckets,
		ao2_hash_fn *	hash_fn,
		ao2_callback_fn *	cmp_fn
	)			[static, read]

Referenced by _ao2_container_alloc(), and _ao2_container_alloc_debug().

static void * __ao2_iterator_next	(	struct ao2_iterator *	a,
		struct bucket_list **	q
	)			[static]

Definition at line 744 of file astobj2.c.

References ao2_lock(), AST_LIST_NEXT, AST_LIST_TRAVERSE, ao2_iterator::bucket, ao2_container::buckets, ao2_iterator::c, ao2_iterator::c_version, EXTERNAL_OBJ, F_AO2I_DONTLOCK, ao2_iterator::flags, INTERNAL_OBJ(), ao2_container::n_buckets, ao2_iterator::obj, ao2_iterator::version, and ao2_container::version.

Referenced by _ao2_iterator_next(), and _ao2_iterator_next_debug().

{
   int lim;
   struct bucket_list *p = NULL;
   void *ret = NULL;

   *q = NULL;
   
   if (INTERNAL_OBJ(a->c) == NULL)
      return NULL;

   if (!(a->flags & F_AO2I_DONTLOCK))
      ao2_lock(a->c);

   /* optimization. If the container is unchanged and
    * we have a pointer, try follow it
    */
   if (a->c->version == a->c_version && (p = a->obj) ) {
      if ( (p = AST_LIST_NEXT(p, entry)) )
         goto found;
      /* nope, start from the next bucket */
      a->bucket++;
      a->version = 0;
      a->obj = NULL;
   }

   lim = a->c->n_buckets;

   /* Browse the buckets array, moving to the next
    * buckets if we don't find the entry in the current one.
    * Stop when we find an element with version number greater
    * than the current one (we reset the version to 0 when we
    * switch buckets).
    */
   for (; a->bucket < lim; a->bucket++, a->version = 0) {
      /* scan the current bucket */
      AST_LIST_TRAVERSE(&a->c->buckets[a->bucket], p, entry) {
         if (p->version > a->version)
            goto found;
      }
   }

found:
   if (p) {
      a->version = p->version;
      a->obj = p;
      a->c_version = a->c->version;
      ret = EXTERNAL_OBJ(p->astobj);
      /* inc refcount of returned object */
      *q = p;
   }

   return ret;
}

static struct bucket_list * __ao2_link	(	struct ao2_container *	c,
		void *	user_data
	)			[static, read]

Definition at line 489 of file astobj2.c.

References ao2_lock(), ast_atomic_fetchadd_int(), ast_calloc, AST_LIST_INSERT_TAIL, ao2_container::buckets, ao2_container::elements, ao2_container::hash_fn, INTERNAL_OBJ(), ao2_container::n_buckets, OBJ_POINTER, and ao2_container::version.

Referenced by _ao2_link(), and _ao2_link_debug().

{
   int i;
   /* create a new list entry */
   struct bucket_list *p;
   struct astobj2 *obj = INTERNAL_OBJ(user_data);
   
   if (!obj)
      return NULL;

   if (INTERNAL_OBJ(c) == NULL)
      return NULL;

   p = ast_calloc(1, sizeof(*p));
   if (!p)
      return NULL;

   i = c->hash_fn(user_data, OBJ_POINTER);

   ao2_lock(c);
   i %= c->n_buckets;
   p->astobj = obj;
   p->version = ast_atomic_fetchadd_int(&c->version, 1);
   AST_LIST_INSERT_TAIL(&c->buckets[i], p, entry);
   ast_atomic_fetchadd_int(&c->elements, 1);

   /* the last two operations (ao2_ref, ao2_unlock) must be done by the calling func */
   return p;
}

static int __ao2_ref	(	void *	user_data,
		const int	delta
	)			[static]

Definition at line 254 of file astobj2.c.

References ast_atomic_fetchadd_int(), ast_log(), ast_mutex_destroy(), __priv_data::data_size, __priv_data::destructor_fn, free, INTERNAL_OBJ(), __priv_data::lock, LOG_ERROR, astobj2::priv_data, and __priv_data::ref_counter.

Referenced by _ao2_ref(), and _ao2_ref_debug().

{
   struct astobj2 *obj = INTERNAL_OBJ(user_data);
   int current_value;
   int ret;

   /* if delta is 0, just return the refcount */
   if (delta == 0)
      return (obj->priv_data.ref_counter);

   /* we modify with an atomic operation the reference counter */
   ret = ast_atomic_fetchadd_int(&obj->priv_data.ref_counter, delta);
   current_value = ret + delta;

#ifdef AO2_DEBUG  
   ast_atomic_fetchadd_int(&ao2.total_refs, delta);
#endif

   /* this case must never happen */
   if (current_value < 0)
      ast_log(LOG_ERROR, "refcount %d on object %p\n", current_value, user_data);

   if (current_value <= 0) { /* last reference, destroy the object */
      if (obj->priv_data.destructor_fn != NULL) {
         obj->priv_data.destructor_fn(user_data);
      }

      ast_mutex_destroy(&obj->priv_data.lock);
#ifdef AO2_DEBUG
      ast_atomic_fetchadd_int(&ao2.total_mem, - obj->priv_data.data_size);
      ast_atomic_fetchadd_int(&ao2.total_objects, -1);
#endif
      /* for safety, zero-out the astobj2 header and also the
       * first word of the user-data, which we make sure is always
       * allocated. */
      memset(obj, '\0', sizeof(struct astobj2 *) + sizeof(void *) );
      free(obj);
   }

   return ret;
}

void* _ao2_alloc	(	size_t	data_size,
		ao2_destructor_fn	destructor_fn
	)

Definition at line 354 of file astobj2.c.

References __ao2_alloc().

Referenced by _ao2_container_alloc().

{
   return __ao2_alloc(data_size, destructor_fn, __FILE__, __LINE__, __FUNCTION__);
}

void* _ao2_alloc_debug	(	size_t	data_size,
		ao2_destructor_fn	destructor_fn,
		char *	tag,
		const char *	file,
		int	line,
		const char *	funcname,
		int	ref_debug
	)

Definition at line 333 of file astobj2.c.

References __ao2_alloc(), and REF_FILE.

Referenced by _ao2_container_alloc_debug().

{
   /* allocation */
   void *obj;
   FILE *refo = ref_debug ? fopen(REF_FILE,"a") : NULL;

   obj = __ao2_alloc(data_size, destructor_fn, file, line, funcname);

   if (obj == NULL)
      return NULL;
   
   if (refo) {
      fprintf(refo, "%p =1   %s:%d:%s (%s)\n", obj, file, line, funcname, tag);
      fclose(refo);
   }

   /* return a pointer to the user data */
   return obj;
}

void* _ao2_callback	(	struct ao2_container *	c,
		const enum search_flags	flags,
		ao2_callback_fn *	cb_fn,
		void *	arg
	)

Definition at line 709 of file astobj2.c.

References __ao2_callback().

Referenced by _ao2_find(), _ao2_unlink(), and container_destruct().

{
   return __ao2_callback(c,flags, cb_fn, arg, NULL, NULL, 0, NULL);
}

void* _ao2_callback_debug	(	struct ao2_container *	c,
		const enum search_flags	flags,
		ao2_callback_fn *	cb_fn,
		void *	arg,
		char *	tag,
		char *	file,
		int	line,
		const char *	funcname
	)

Definition at line 701 of file astobj2.c.

References __ao2_callback().

Referenced by _ao2_find_debug(), _ao2_unlink_debug(), and container_destruct_debug().

{
   return __ao2_callback(c,flags, cb_fn, arg, tag, file, line, funcname);
}

struct ao2_container* _ao2_container_alloc	(	const unsigned int	n_buckets,
		ao2_hash_fn *	hash_fn,
		ao2_callback_fn *	cmp_fn
	)			[read]

Definition at line 454 of file astobj2.c.

References __ao2_container_alloc(), _ao2_alloc(), and container_destruct().

{
   /* XXX maybe consistency check on arguments ? */
   /* compute the container size */

   size_t container_size = sizeof(struct ao2_container) + n_buckets * sizeof(struct bucket);
   struct ao2_container *c = _ao2_alloc(container_size, container_destruct);

   return __ao2_container_alloc(c, n_buckets, hash_fn, cmp_fn);
}

struct ao2_container* _ao2_container_alloc_debug	(	const unsigned int	n_buckets,
		ao2_hash_fn *	hash_fn,
		ao2_callback_fn *	cmp_fn,
		char *	tag,
		char *	file,
		int	line,
		const char *	funcname,
		int	ref_debug
	)			[read]

Definition at line 441 of file astobj2.c.

References __ao2_container_alloc(), _ao2_alloc_debug(), and container_destruct_debug().

{
   /* XXX maybe consistency check on arguments ? */
   /* compute the container size */
   size_t container_size = sizeof(struct ao2_container) + n_buckets * sizeof(struct bucket);
   struct ao2_container *c = _ao2_alloc_debug(container_size, container_destruct_debug, tag, file, line, funcname, ref_debug);

   return __ao2_container_alloc(c, n_buckets, hash_fn, cmp_fn);
}

void* _ao2_find	(	struct ao2_container *	c,
		void *	arg,
		enum search_flags	flags
	)

Definition at line 723 of file astobj2.c.

References _ao2_callback(), and ao2_container::cmp_fn.

{
   return _ao2_callback(c, flags, c->cmp_fn, arg);
}

void* _ao2_find_debug	(	struct ao2_container *	c,
		void *	arg,
		enum search_flags	flags,
		char *	tag,
		char *	file,
		int	line,
		const char *	funcname
	)

the find function just invokes the default callback with some reasonable flags.

Definition at line 718 of file astobj2.c.

References _ao2_callback_debug(), and ao2_container::cmp_fn.

{
   return _ao2_callback_debug(c, flags, c->cmp_fn, arg, tag, file, line, funcname);
}

void* _ao2_iterator_next

(

struct ao2_iterator *

a

)

Definition at line 817 of file astobj2.c.

References __ao2_iterator_next(), _ao2_ref(), ao2_unlock(), ao2_iterator::c, F_AO2I_DONTLOCK, and ao2_iterator::flags.

{
   struct bucket_list *p = NULL;
   void *ret = NULL;

   ret = __ao2_iterator_next(a, &p);
   
   if (p) {
      /* inc refcount of returned object */
      _ao2_ref(ret, 1);
   }

   if (!(a->flags & F_AO2I_DONTLOCK))
      ao2_unlock(a->c);

   return ret;
}

void* _ao2_iterator_next_debug	(	struct ao2_iterator *	a,
		char *	tag,
		char *	file,
		int	line,
		const char *	funcname
	)

Definition at line 799 of file astobj2.c.

References __ao2_iterator_next(), _ao2_ref_debug(), ao2_unlock(), ao2_iterator::c, F_AO2I_DONTLOCK, and ao2_iterator::flags.

{
   struct bucket_list *p;
   void *ret = NULL;

   ret = __ao2_iterator_next(a, &p);
   
   if (p) {
      /* inc refcount of returned object */
      _ao2_ref_debug(ret, 1, tag, file, line, funcname);
   }

   if (!(a->flags & F_AO2I_DONTLOCK))
      ao2_unlock(a->c);

   return ret;
}

void* _ao2_link	(	struct ao2_container *	c,
		void *	user_data
	)

Definition at line 530 of file astobj2.c.

References __ao2_link(), _ao2_ref(), and ao2_unlock().

{
   struct bucket_list *p = __ao2_link(c, user_data);
   
   if (p) {
      _ao2_ref(user_data, +1);
      ao2_unlock(c);
   }
   return p;
}

void* _ao2_link_debug	(	struct ao2_container *	c,
		void *	user_data,
		char *	tag,
		char *	file,
		int	line,
		const char *	funcname
	)

Definition at line 519 of file astobj2.c.

References __ao2_link(), _ao2_ref_debug(), and ao2_unlock().

{
   struct bucket_list *p = __ao2_link(c, user_data);
   
   if (p) {
      _ao2_ref_debug(user_data, +1, tag, file, line, funcname);
      ao2_unlock(c);
   }
   return p;
}

int _ao2_ref	(	void *	user_data,
		const int	delta
	)

Definition at line 244 of file astobj2.c.

References __ao2_ref(), and INTERNAL_OBJ().

Referenced by __ao2_callback(), _ao2_iterator_next(), _ao2_link(), and cd_cb().

{
   struct astobj2 *obj = INTERNAL_OBJ(user_data);

   if (obj == NULL)
      return -1;

   return __ao2_ref(user_data, delta);
}

int _ao2_ref_debug	(	void *	user_data,
		const int	delta,
		char *	tag,
		char *	file,
		int	line,
		const char *	funcname
	)

Definition at line 224 of file astobj2.c.

References __ao2_ref(), __priv_data::destructor_fn, INTERNAL_OBJ(), astobj2::priv_data, __priv_data::ref_counter, and REF_FILE.

Referenced by __ao2_callback(), _ao2_iterator_next_debug(), _ao2_link_debug(), and cd_cb_debug().

{
   struct astobj2 *obj = INTERNAL_OBJ(user_data);
   
   if (obj == NULL)
      return -1;

   if (delta != 0) {
      FILE *refo = fopen(REF_FILE,"a");
      fprintf(refo, "%p %s%d   %s:%d:%s (%s) [@%d]\n", user_data, (delta<0? "":"+"), delta, file, line, funcname, tag, obj->priv_data.ref_counter);
      fclose(refo);
   }
   if (obj->priv_data.ref_counter + delta == 0 && obj->priv_data.destructor_fn != NULL) { /* this isn't protected with lock; just for o/p */
         FILE *refo = fopen(REF_FILE,"a");    
         fprintf(refo, "%p **call destructor** %s:%d:%s (%s)\n", user_data, file, line, funcname, tag);   
         fclose(refo);
   }
   return __ao2_ref(user_data, delta);
}

void* _ao2_unlink	(	struct ao2_container *	c,
		void *	user_data
	)

Definition at line 564 of file astobj2.c.

References _ao2_callback(), ao2_match_by_addr, INTERNAL_OBJ(), OBJ_NODATA, OBJ_POINTER, and OBJ_UNLINK.

{
   if (INTERNAL_OBJ(user_data) == NULL)   /* safety check on the argument */
      return NULL;

   _ao2_callback(c, OBJ_UNLINK | OBJ_POINTER | OBJ_NODATA, ao2_match_by_addr, user_data);

   return NULL;
}

void* _ao2_unlink_debug	(	struct ao2_container *	c,
		void *	user_data,
		char *	tag,
		char *	file,
		int	line,
		const char *	funcname
	)

Definition at line 553 of file astobj2.c.

References _ao2_callback_debug(), ao2_match_by_addr, INTERNAL_OBJ(), OBJ_NODATA, OBJ_POINTER, and OBJ_UNLINK.

{
   if (INTERNAL_OBJ(user_data) == NULL)   /* safety check on the argument */
      return NULL;

   _ao2_callback_debug(c, OBJ_UNLINK | OBJ_POINTER | OBJ_NODATA, ao2_match_by_addr, user_data, tag, file, line, funcname);

   return NULL;
}

void ao2_bt

(

void

)

Definition at line 79 of file astobj2.c.

{}

int ao2_container_count

(

struct ao2_container *

c

)

Returns the number of elements in a container.

return the number of elements in the container

Definition at line 469 of file astobj2.c.

References ao2_container::elements.

Referenced by __queues_show(), _sip_show_peers(), cli_tps_report(), do_timing(), get_unused_callno(), and pthread_timer_open().

{
   return c->elements;
}

struct ao2_iterator ao2_iterator_init	(	struct ao2_container *	c,
		int	flags
	)			[read]

initialize an iterator so we start from the first object

Definition at line 731 of file astobj2.c.

References ao2_iterator::c, and ao2_iterator::flags.

Referenced by __iax2_show_peers(), __queues_show(), _sip_show_peers(), ast_odbc_request_obj(), authenticate_reply(), check_access(), cli_console_active(), cli_list_devices(), cli_tps_report(), compare_weight(), complete_iax2_peers(), complete_iax2_unregister(), complete_queue(), complete_queue_remove_member(), complete_sip_peer(), complete_sip_registered_peer(), complete_sip_user(), complete_sipch(), delete_profiles(), delete_routes(), delete_users(), destroy_pvts(), dialgroup_read(), do_parking_thread(), dump_queue_members(), find_queue_by_name_rt(), free_members(), get_member_status(), handle_cli_iax2_show_callno_limits(), handle_cli_iax2_show_users(), handle_cli_moh_show_classes(), handle_cli_moh_show_files(), handle_cli_odbc_show(), handle_feature_show(), handle_parkedcalls(), handle_request_subscribe(), handle_show_routes(), iax2_getpeername(), iax2_getpeertrunk(), interface_exists(), interface_exists_global(), manager_iax2_show_peer_list(), manager_parking_status(), manager_queues_status(), manager_queues_summary(), num_available_members(), poke_all_peers(), pp_each_user_exec(), prune_peers(), prune_users(), queue_function_qac(), queue_function_qac_dep(), queue_function_queuememberlist(), reload(), reload_queues(), rt_handle_member_record(), set_member_paused(), set_member_penalty(), sip_poke_all_peers(), sip_prune_realtime(), sip_show_channel(), sip_show_history(), sip_show_inuse(), sip_show_users(), stop_streams(), tps_taskprocessor_tab_complete(), try_calling(), unload_module(), update_queue(), update_realtime_members(), and update_status().

{
   struct ao2_iterator a = {
      .c = c,
      .flags = flags
   };
   
   return a;
}

int ao2_lock

(

void *

a

)

Lock an object.

Parameters:

a

A pointer to the object we want to lock.

Returns:

0 on success, other values on error.

Definition at line 142 of file astobj2.c.

References ast_atomic_fetchadd_int(), ast_mutex_lock(), INTERNAL_OBJ(), __priv_data::lock, and astobj2::priv_data.

Referenced by __ao2_callback(), __ao2_iterator_next(), __ao2_link(), __queues_show(), _sip_show_peers(), add_calltoken_ignore(), add_to_queue(), ast_taskprocessor_get(), ast_taskprocessor_unreference(), build_callno_limits(), build_parkinglot(), compare_weight(), complete_queue_remove_member(), complete_sip_user(), dialog_needdestroy(), end_bridge_callback(), find_call(), find_queue_by_name_rt(), get_member_penalty(), get_member_status(), get_unused_callno(), handle_request_subscribe(), interface_exists_global(), is_our_turn(), join_queue(), leave_queue(), load_config(), load_realtime_queue(), manager_queues_status(), manager_queues_summary(), moh_release(), mohalloc(), monmp3thread(), mwi_event_cb(), peercnt_add(), peercnt_remove(), pthread_timer_ack(), pthread_timer_disable_continuous(), pthread_timer_enable_continuous(), pthread_timer_get_event(), pthread_timer_open(), pthread_timer_set_rate(), queue_function_qac(), queue_function_qac_dep(), queue_function_queuememberlist(), queue_function_queuewaitingcount(), queue_function_var(), recalc_holdtime(), record_abandoned(), reload_queue_members(), reload_queues(), remove_from_queue(), replace_callno(), ring_entry(), run_timer(), set_member_paused(), set_member_penalty(), sip_poke_all_peers(), sip_prune_realtime(), sip_show_inuse(), sip_show_user(), sip_show_users(), try_calling(), update_call_counter(), update_queue(), update_realtime_members(), and update_status().

{
   struct astobj2 *p = INTERNAL_OBJ(user_data);

   if (p == NULL)
      return -1;

#ifdef AO2_DEBUG
   ast_atomic_fetchadd_int(&ao2.total_locked, 1);
#endif

#ifndef DEBUG_THREADS
   return ast_mutex_lock(&p->priv_data.lock);
#else
   return __ast_pthread_mutex_lock(file, line, func, var, &p->priv_data.lock);
#endif
}

int ao2_match_by_addr	(	void *	user_data,
		void *	arg,
		int	flags
	)

another convenience function is a callback that matches on address

Definition at line 544 of file astobj2.c.

References CMP_MATCH, and CMP_STOP.

{
   return (user_data == arg) ? (CMP_MATCH | CMP_STOP) : 0;
}

void* ao2_object_get_lockaddr

(

void *

obj

)

Return the lock address of an object.

Parameters:

[in]

obj

A pointer to the object we want.

Returns:

the address of the lock, else NULL.

This function comes in handy mainly for debugging locking situations, where the locking trace code reports the lock address, this allows you to correlate against object address, to match objects to reported locks.

Since:

1.6.1

Definition at line 209 of file astobj2.c.

References INTERNAL_OBJ(), __priv_data::lock, and astobj2::priv_data.

{
   struct astobj2 *p = INTERNAL_OBJ(obj);
   
   if (p == NULL)
      return NULL;

   return &p->priv_data.lock;
}

int ao2_trylock

(

void *

a

)

Try locking-- (don't block if fail).

Parameters:

a

A pointer to the object we want to lock.

Returns:

0 on success, other values on error.

Definition at line 186 of file astobj2.c.

References ast_atomic_fetchadd_int(), ast_mutex_trylock(), INTERNAL_OBJ(), __priv_data::lock, and astobj2::priv_data.

{
   struct astobj2 *p = INTERNAL_OBJ(user_data);
   int ret;
   
   if (p == NULL)
      return -1;
#ifndef DEBUG_THREADS
   ret = ast_mutex_trylock(&p->priv_data.lock);
#else
   ret = __ast_pthread_mutex_trylock(file, line, func, var, &p->priv_data.lock);
#endif

#ifdef AO2_DEBUG
   if (!ret)
      ast_atomic_fetchadd_int(&ao2.total_locked, 1);
#endif
   return ret;
}

int ao2_unlock

(

void *

a

)

Unlock an object.

Parameters:

a

A pointer to the object we want unlock.

Returns:

0 on success, other values on error.

Definition at line 164 of file astobj2.c.

References ast_atomic_fetchadd_int(), ast_mutex_unlock(), INTERNAL_OBJ(), __priv_data::lock, and astobj2::priv_data.

Referenced by __ao2_callback(), __queues_show(), _ao2_iterator_next(), _ao2_iterator_next_debug(), _ao2_link(), _ao2_link_debug(), _sip_show_peers(), add_calltoken_ignore(), add_to_queue(), ast_taskprocessor_get(), ast_taskprocessor_unreference(), build_callno_limits(), build_parkinglot(), compare_weight(), complete_queue_remove_member(), complete_sip_user(), dialog_needdestroy(), end_bridge_callback(), find_call(), find_queue_by_name_rt(), get_member_penalty(), get_member_status(), get_unused_callno(), handle_request_subscribe(), interface_exists_global(), is_our_turn(), join_queue(), leave_queue(), load_config(), load_realtime_queue(), manager_queues_status(), manager_queues_summary(), moh_release(), mohalloc(), monmp3thread(), mwi_event_cb(), peercnt_add(), peercnt_remove(), pthread_timer_ack(), pthread_timer_disable_continuous(), pthread_timer_enable_continuous(), pthread_timer_get_event(), pthread_timer_open(), pthread_timer_set_rate(), queue_function_qac(), queue_function_qac_dep(), queue_function_queuememberlist(), queue_function_queuewaitingcount(), queue_function_var(), recalc_holdtime(), record_abandoned(), reload_queue_members(), reload_queues(), remove_from_queue(), replace_callno(), ring_entry(), run_timer(), set_member_paused(), set_member_penalty(), sip_poke_all_peers(), sip_prune_realtime(), sip_show_inuse(), sip_show_user(), sip_show_users(), try_calling(), update_call_counter(), update_queue(), update_realtime_members(), and update_status().

{
   struct astobj2 *p = INTERNAL_OBJ(user_data);

   if (p == NULL)
      return -1;

#ifdef AO2_DEBUG
   ast_atomic_fetchadd_int(&ao2.total_locked, -1);
#endif

#ifndef DEBUG_THREADS
   return ast_mutex_unlock(&p->priv_data.lock);
#else
   return __ast_pthread_mutex_unlock(file, line, func, var, &p->priv_data.lock);
#endif
}

AST_LIST_HEAD_NOLOCK	(	bucket	,
		bucket_list
	)

int astobj2_init

(

void

)

Provided by astobj2.c

Definition at line 1021 of file astobj2.c.

References ARRAY_LEN, and ast_cli_register_multiple().

Referenced by main().

{
#ifdef AO2_DEBUG
   ast_cli_register_multiple(cli_astobj2, ARRAY_LEN(cli_astobj2));
#endif

   return 0;
}

static int cb_true	(	void *	user_data,
		void *	arg,
		int	flags
	)			[static]

special callback that matches all

Definition at line 577 of file astobj2.c.

References CMP_MATCH.

Referenced by __ao2_callback().

{
   return CMP_MATCH;
}

static int cd_cb	(	void *	obj,
		void *	arg,
		int	flag
	)			[static]

Definition at line 838 of file astobj2.c.

References _ao2_ref().

Referenced by container_destruct().

{
   _ao2_ref(obj, -1);
   return 0;
}

static int cd_cb_debug	(	void *	obj,
		void *	arg,
		int	flag
	)			[static]

Definition at line 844 of file astobj2.c.

References _ao2_ref_debug().

Referenced by container_destruct_debug().

{
   _ao2_ref_debug(obj, -1, "deref object via container destroy",  __FILE__, __LINE__, __PRETTY_FUNCTION__);
   return 0;
}

static void container_destruct

(

void *

c

)

[static]

Definition at line 850 of file astobj2.c.

References _ao2_callback(), ast_atomic_fetchadd_int(), ast_free, AST_LIST_REMOVE_HEAD, ao2_container::buckets, cd_cb(), ao2_container::n_buckets, and OBJ_UNLINK.

Referenced by _ao2_container_alloc().

{
   struct ao2_container *c = _c;
   int i;

   _ao2_callback(c, OBJ_UNLINK, cd_cb, NULL);

   for (i = 0; i < c->n_buckets; i++) {
      struct bucket_list *current;

      while ((current = AST_LIST_REMOVE_HEAD(&c->buckets[i], entry))) {
         ast_free(current);
      }
   }

#ifdef AO2_DEBUG
   ast_atomic_fetchadd_int(&ao2.total_containers, -1);
#endif
}

static void container_destruct_debug

(

void *

c

)

[static]

Definition at line 870 of file astobj2.c.

References _ao2_callback_debug(), ast_atomic_fetchadd_int(), ast_free, AST_LIST_REMOVE_HEAD, ao2_container::buckets, cd_cb_debug(), ao2_container::n_buckets, and OBJ_UNLINK.

Referenced by _ao2_container_alloc_debug().

{
   struct ao2_container *c = _c;
   int i;

   _ao2_callback_debug(c, OBJ_UNLINK, cd_cb_debug, NULL, "container_destruct_debug called", __FILE__, __LINE__, __PRETTY_FUNCTION__);

   for (i = 0; i < c->n_buckets; i++) {
      struct bucket_list *current;

      while ((current = AST_LIST_REMOVE_HEAD(&c->buckets[i], entry))) {
         ast_free(current);
      }
   }

#ifdef AO2_DEBUG
   ast_atomic_fetchadd_int(&ao2.total_containers, -1);
#endif
}

static int hash_zero	(	const void *	user_obj,
		const int	flags
	)			[static]

always zero hash function

it is convenient to have a hash function that always returns 0. This is basically used when we want to have a container that is a simple linked list.

Returns:

0

Definition at line 412 of file astobj2.c.

Referenced by __ao2_container_alloc().

{
   return 0;
}

static struct astobj2* INTERNAL_OBJ

(

void *

user_data

)

[static, read]

convert from a pointer _p to a user-defined object

Returns:

the pointer to the astobj2 structure

Definition at line 105 of file astobj2.c.

References AO2_MAGIC, ast_log(), LOG_ERROR, __priv_data::magic, and astobj2::priv_data.

Referenced by __ao2_callback(), __ao2_iterator_next(), __ao2_link(), __ao2_ref(), _ao2_ref(), _ao2_ref_debug(), _ao2_unlink(), _ao2_unlink_debug(), ao2_lock(), ao2_object_get_lockaddr(), ao2_trylock(), and ao2_unlock().

{
   struct astobj2 *p;

   if (!user_data) {
      ast_log(LOG_ERROR, "user_data is NULL\n");
      return NULL;
   }

   p = (struct astobj2 *) ((char *) user_data - sizeof(*p));
   if (AO2_MAGIC != (p->priv_data.magic) ) {
      ast_log(LOG_ERROR, "bad magic number 0x%x for %p\n", p->priv_data.magic, p);
      p = NULL;
   }

   return p;
}