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
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
Functions
void *	ao2_alloc (size_t data_size, ao2_destructor_fn destructor_fn)
	Allocate and initialize an object.
void	ao2_bt (void)
void *	ao2_callback (struct ao2_container *c, const enum search_flags flags, ao2_callback_fn *cb_fn, void *arg)
	ao2_callback() is a generic function that applies cb_fn() to all objects in a container, as described below.
struct ao2_container *	ao2_container_alloc (const unsigned int n_buckets, ao2_hash_fn *hash_fn, ao2_callback_fn *cmp_fn)
	Allocate and initialize a container with the desired number of buckets.
int	ao2_container_count (struct ao2_container *c)
	Returns the number of elements in a container.
void *	ao2_find (struct ao2_container *c, void *arg, enum search_flags flags)
void	ao2_iterator_destroy (struct ao2_iterator *i)
	Destroy a container iterator.
struct ao2_iterator	ao2_iterator_init (struct ao2_container *c, int flags)
	Create an iterator for a container.
void *	ao2_iterator_next (struct ao2_iterator *a)
void *	ao2_link (struct ao2_container *c, void *user_data)
	Add an object to a container.
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
int	ao2_ref (void *user_data, const int delta)
	Reference/unreference an object and return the old refcount.
int	ao2_trylock (void *user_data)
	Try locking-- (don't block if fail).
void *	ao2_unlink (struct ao2_container *c, void *user_data)
	Remove an object from the container.
int	ao2_unlock (void *user_data)
	Unlock an object.
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 void	container_destruct (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 50 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 127 of file astobj2.c.

Referenced by ao2_alloc(), ao2_callback(), and ao2_iterator_next().

---

Function Documentation

void* ao2_alloc	(	const size_t	data_size,
		ao2_destructor_fn	destructor_fn
	)

Allocate and initialize an object.

Parameters:

	data_size	The sizeof() of the user-defined structure.
	destructor_fn	The destructor function (can be NULL)

Returns:

A pointer to user-data.

Allocates a struct astobj2 with sufficient space for the user-defined structure.

Note:

• storage is zeroed; XXX maybe we want a flag to enable/disable this.
• the refcount of the object just created is 1
• the returned pointer cannot be free()'d or realloc()'ed; rather, we just call ao2_ref(o, -1);

Definition at line 248 of file astobj2.c.

References 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 add_calltoken_ignore(), alloc_queue(), ao2_container_alloc(), ast_tcptls_client_start(), ast_tcptls_server_root(), build_callno_limits(), build_device(), build_peer(), build_profile(), build_route(), build_user(), conf_run(), create_callno_pools(), create_queue_member(), dialgroup_write(), get_filestream(), get_lock(), moh_class_malloc(), new_iax(), peercnt_add(), set_fn(), sip_alloc(), try_calling(), and xml_translate().

{
   /* allocation */
   struct astobj2 *obj;

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

   obj = ast_calloc(1, sizeof(*obj) + data_size);

   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);
}

void ao2_bt

(

void

)

Definition at line 78 of file astobj2.c.

{}

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

ao2_callback() is a generic function that applies cb_fn() to all objects in a container, as described below.

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.

Definition at line 447 of file astobj2.c.

References ao2_lock(), ao2_ref(), ao2_unlock(), ast_atomic_fetchadd_int(), AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log(), bucket_list::astobj, ao2_container::buckets, cb_true(), CMP_MATCH, CMP_STOP, ao2_container::elements, bucket_list::entry, 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_find(), ao2_unlink(), ast_moh_destroy(), calltoken_required(), container_destruct(), delete_users(), get_mohbydigit(), load_config(), load_module(), load_moh_classes(), reload_config(), set_config_destroy(), set_peercnt_limit(), and unload_module().

{
   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 */
      start = 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);
            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);
            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;
}

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

Allocate and initialize a container with the desired number of buckets.

We allocate space for a struct astobj_container, struct container and the buckets[] array.

Parameters:

	n_buckets	Number of buckets for hash
	hash_fn	Pointer to a function computing a hash value.
	cmp_fn	Pointer to a function comparating key-value with a string. (can be NULL)

Returns:

A pointer to a struct container.

destructor is set implicitly.

Definition at line 335 of file astobj2.c.

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

Referenced by config_text_file_save(), create_callno_pools(), dialgroup_write(), get_lock(), init_queue(), load_module(), load_objects(), and xml_translate().

{
   /* 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);

   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;
}

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 362 of file astobj2.c.

References ao2_container::elements.

Referenced by __queues_show(), get_unused_callno(), lock_broker(), and unload_module().

{
   return c->elements;
}

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

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

Definition at line 555 of file astobj2.c.

References ao2_callback(), and ao2_container::cmp_fn.

Referenced by __find_callno(), add_calltoken_ignore(), authenticate_request(), authenticate_verify(), build_callno_limits(), build_peer(), build_user(), compare_weight(), dialgroup_read(), dialgroup_write(), find_peer(), find_profile(), find_pvt(), find_queue_by_name_rt(), find_user(), get_member_penalty(), get_mohbyname(), get_unused_callno(), handle_cli_iax2_unregister(), iax2_destroy_helper(), load_realtime_queue(), peercnt_add(), peercnt_modify(), peercnt_remove_by_addr(), phoneprov_callback(), queue_function_queuememberlist(), queue_function_queuewaitingcount(), queue_function_var(), reload_queue_members(), reload_queues(), remove_from_queue(), rt_handle_member_record(), sched_delay_remove(), set_fn(), update_queue(), and xml_translate().

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

void ao2_iterator_destroy

(

struct ao2_iterator *

i

)

Destroy a container iterator.

destroy an iterator

Definition at line 578 of file astobj2.c.

References ao2_ref(), and ao2_iterator::c.

Referenced by __iax2_show_peers(), __queues_show(), authenticate_reply(), check_access(), cli_console_active(), cli_list_devices(), compare_weight(), complete_iax2_show_peer(), complete_iax2_unregister(), complete_queue(), complete_queue_remove_member(), delete_profiles(), delete_routes(), destroy_pvts(), dialgroup_read(), 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_show_routes(), iax2_getpeername(), iax2_getpeertrunk(), interface_exists(), interface_exists_global(), manager_iax2_show_peer_list(), manager_queues_status(), manager_queues_summary(), num_available_members(), poke_all_peers(), prune_peers(), prune_users(), queue_function_qac(), queue_function_qac_dep(), queue_function_queuememberlist(), set_member_paused(), set_member_penalty(), stop_streams(), try_calling(), unload_module(), update_queue(), and update_realtime_members().

{
   ao2_ref(i->c, -1);
   i->c = NULL;
}

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

Create an iterator for a container.

initialize an iterator so we start from the first object

Definition at line 563 of file astobj2.c.

References ao2_ref(), ao2_iterator::c, and ao2_iterator::flags.

Referenced by __iax2_show_peers(), __queues_show(), authenticate_reply(), check_access(), cli_console_active(), cli_list_devices(), compare_weight(), complete_iax2_show_peer(), complete_iax2_unregister(), complete_queue(), complete_queue_remove_member(), delete_profiles(), delete_routes(), destroy_pvts(), dialgroup_read(), 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_show_routes(), iax2_getpeername(), iax2_getpeertrunk(), interface_exists(), interface_exists_global(), manager_iax2_show_peer_list(), manager_queues_status(), manager_queues_summary(), num_available_members(), poke_all_peers(), prune_peers(), prune_users(), queue_function_qac(), queue_function_qac_dep(), queue_function_queuememberlist(), reload_queues(), set_member_paused(), set_member_penalty(), stop_streams(), try_calling(), unload_module(), update_queue(), update_realtime_members(), and update_status().

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

   ao2_ref(c, +1);
   
   return a;
}

void* ao2_iterator_next

(

struct ao2_iterator *

a

)

Definition at line 587 of file astobj2.c.

References AO2_ITERATOR_DONTLOCK, ao2_lock(), ao2_ref(), ao2_unlock(), AST_LIST_NEXT, AST_LIST_TRAVERSE, bucket_list::astobj, ao2_iterator::bucket, ao2_container::buckets, ao2_iterator::c, ao2_iterator::c_version, bucket_list::entry, EXTERNAL_OBJ, ao2_iterator::flags, INTERNAL_OBJ(), ao2_container::n_buckets, ao2_iterator::obj, bucket_list::version, ao2_iterator::version, and ao2_container::version.

Referenced by __iax2_show_peers(), __queues_show(), authenticate_reply(), check_access(), cli_console_active(), cli_list_devices(), compare_weight(), complete_iax2_show_peer(), complete_iax2_unregister(), complete_queue(), complete_queue_remove_member(), delete_profiles(), delete_routes(), destroy_pvts(), dialgroup_read(), 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_show_routes(), iax2_getpeername(), iax2_getpeertrunk(), interface_exists(), interface_exists_global(), manager_iax2_show_peer_list(), manager_queues_status(), manager_queues_summary(), num_available_members(), poke_all_peers(), prune_peers(), prune_users(), queue_function_qac(), queue_function_qac_dep(), queue_function_queuememberlist(), reload_queues(), set_member_paused(), set_member_penalty(), stop_streams(), try_calling(), unload_module(), update_queue(), update_realtime_members(), and update_status().

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

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

   if (!(a->flags & AO2_ITERATOR_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 */
      ao2_ref(ret, 1);
   }

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

   return ret;
}

void* ao2_link	(	struct ao2_container *	c,
		void *	newobj
	)

Add an object to a container.

Parameters:

	c	the container to operate on.
	newobj	the object to be added.

Return values:

	NULL	on errors
	newobj	on success.

This function inserts an object in a container according its key.

Note:

Remember to set the key before calling this function.

This function automatically increases the reference count to account for the reference that the container now holds to the object.

Definition at line 381 of file astobj2.c.

References ao2_lock(), ao2_ref(), ao2_unlock(), ast_atomic_fetchadd_int(), ast_calloc, AST_LIST_INSERT_TAIL, bucket_list::astobj, INTERNAL_OBJ(), OBJ_POINTER, and bucket_list::version.

Referenced by add_calltoken_ignore(), add_to_queue(), build_callno_limits(), build_device(), build_profile(), build_route(), create_callno_pools(), dialgroup_write(), find_queue_by_name_rt(), get_lock(), moh_register(), peercnt_add(), realtime_peer(), realtime_user(), reload_queues(), replace_callno(), rt_handle_member_record(), set_config(), set_fn(), store_by_peercallno(), store_by_transfercallno(), and xml_translate().

{
   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 = abs(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);
   ao2_ref(user_data, +1);
   ao2_unlock(c);
   
   return p;
}

int ao2_lock

(

void *

a

)

Lock an object.

Parameters:

a

A pointer to the object we want lock.

Returns:

0 on success, other values on error.

Definition at line 130 of file astobj2.c.

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

Referenced by __queues_show(), add_calltoken_ignore(), add_to_queue(), ao2_callback(), ao2_iterator_next(), ao2_link(), build_callno_limits(), compare_weight(), complete_queue_remove_member(), end_bridge_callback(), find_queue_by_name_rt(), get_member_penalty(), get_member_status(), get_unused_callno(), interface_exists_global(), is_our_turn(), join_queue(), leave_queue(), load_realtime_queue(), manager_queues_status(), manager_queues_summary(), moh_release(), mohalloc(), monmp3thread(), peercnt_add(), peercnt_remove(), 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(), set_member_paused(), set_member_penalty(), try_calling(), 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 415 of file astobj2.c.

References CMP_MATCH, and CMP_STOP.

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

int ao2_ref	(	void *	o,
		int	delta
	)

Reference/unreference an object and return the old refcount.

Parameters:

	o	A pointer to the object
	delta	Value to add to the reference counter.

Returns:

The value of the reference counter before the operation.

Increase/decrease the reference counter according the value of delta.

If the refcount goes to zero, the object is destroyed.

Note:

The object must not be locked by the caller of this function, as it is invalid to try to unlock it after releasing the reference.

if we know the pointer to an object, it is because we have a reference count to it, so the only case when the object can go away is when we release our reference, and it is the last one in existence.

Definition at line 200 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 __find_callno(), __queues_show(), __sip_destroy(), __unload_module(), _sip_tcp_helper_thread(), add_calltoken_ignore(), add_to_queue(), alloc_queue(), announce_thread(), ao2_callback(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next(), ao2_link(), ast_closestream(), ast_make_file_from_fd(), ast_tcptls_client_start(), ast_tcptls_server_root(), build_callno_limits(), calltoken_required(), cd_cb(), compare_weight(), complete_queue_remove_member(), conf_free(), conf_run(), config_text_file_save(), copy_socket_data(), create_callno_pools(), destroy_queue(), dialgroup_read(), dialgroup_write(), dialog_ref(), dialog_unref(), dump_queue_members(), end_bridge_callback(), end_bridge_callback_data_fixup(), find_queue_by_name_rt(), free_members(), get_lock(), get_member_penalty(), get_member_status(), group_destroy(), handle_cli_iax2_show_callno_limits(), hangupcalls(), httpd_helper_thread(), iax2_destroy(), interface_exists(), interface_exists_global(), load_module(), load_objects(), manager_queues_status(), manager_queues_summary(), new_iax(), num_available_members(), parse_moved_contact(), peer_ref(), peer_unref(), peercnt_add(), peercnt_modify(), peercnt_remove_by_addr(), peercnt_remove_cb(), queue_function_qac(), queue_function_qac_dep(), queue_function_queuememberlist(), queue_ref(), queue_unref(), ref_pvt(), reload_queues(), remove_from_queue(), replace_callno(), rt_handle_member_record(), sched_delay_remove(), session_do(), set_member_paused(), set_member_penalty(), set_peercnt_limit(), set_socket_transport(), sip_destroy_peer(), sip_prepare_socket(), sip_tcp_locate(), try_calling(), unload_module(), unref_profile(), unref_pvt(), unref_route(), update_queue(), update_realtime_members(), update_status(), user_ref(), user_unref(), and xml_translate().

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

   if (obj == NULL)
      return -1;

   /* 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;
}

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 174 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;
}

void* ao2_unlink	(	struct ao2_container *	c,
		void *	obj
	)

Remove an object from the container.

• c the container
• obj the object to unlink

Return values:

NULL,always

Note:

The object requested to be unlinked must be valid. However, if it turns out that it is not in the container, this function is still safe to be called.

If the object gets unlinked from the container, the container's reference to the object will be automatically released.

Definition at line 424 of file astobj2.c.

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

Referenced by build_user(), delete_profiles(), delete_routes(), destroy_pvts(), dialgroup_write(), find_queue_by_name_rt(), free_members(), get_lock(), handle_cli_iax2_prune_realtime(), leave_queue(), peercnt_remove(), prune_users(), reload_queues(), remove_by_peercallno(), remove_by_transfercallno(), remove_from_queue(), unlink_peer(), unload_module(), and update_realtime_members().

{
   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;
}

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 152 of file astobj2.c.

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

Referenced by __queues_show(), add_calltoken_ignore(), add_to_queue(), ao2_callback(), ao2_iterator_next(), ao2_link(), build_callno_limits(), compare_weight(), complete_queue_remove_member(), end_bridge_callback(), find_queue_by_name_rt(), get_member_penalty(), get_member_status(), get_unused_callno(), interface_exists_global(), is_our_turn(), join_queue(), leave_queue(), load_realtime_queue(), manager_queues_status(), manager_queues_summary(), moh_release(), mohalloc(), monmp3thread(), peercnt_add(), peercnt_remove(), 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(), set_member_paused(), set_member_penalty(), try_calling(), 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
}

int astobj2_init

(

void

)

Provided by astobj2.c

Definition at line 798 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 437 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 646 of file astobj2.c.

References ao2_ref().

Referenced by container_destruct().

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

static void container_destruct

(

void *

c

)

[static]

Definition at line 652 of file astobj2.c.

References ao2_callback(), ast_atomic_fetchadd_int(), ast_free, AST_LIST_REMOVE_HEAD, ao2_container::buckets, cd_cb(), bucket_list::entry, 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 *cur;

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

#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 326 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 104 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_lock(), ao2_ref(), ao2_trylock(), ao2_unlink(), 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;
}