Functions implementing astobj2 objects. More...

#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/astobj2.h"
#include "astobj2_private.h"
#include "astobj2_container_private.h"
#include "asterisk/cli.h"
#include "asterisk/paths.h"

Include dependency graph for astobj2.c:

Go to the source code of this file.

Data Structures
struct	__priv_data

struct	ao2_lock_priv

struct	ao2_lockobj_priv

struct	ao2_rwlock_priv

struct	ao2_weakproxy_notification

struct	astobj2

struct	astobj2_lock

struct	astobj2_lockobj

struct	astobj2_rwlock

Macros
#define	__INTERNAL_OBJ_CHECK(user_data, file, line, func)
	convert from a pointer _p to a user-defined object More...

#define	AO2_MAGIC 0xa70b123

#define	AO2_WEAK 0xa70b122

#define	ast_log ast_log_safe

#define	DEBUG_THREADS_LOOSE_ABI

#define	EXCESSIVE_REF_COUNT 100000

#define	EXTERNAL_OBJ(_p) ((_p) == NULL ? NULL : (_p)->user_data)
	convert from a pointer _p to an astobj2 object More...

#define	INTERNAL_OBJ(user_data) (struct astobj2 ) ((char ) user_data - sizeof(struct astobj2))

#define	INTERNAL_OBJ_CHECK(user_data) __INTERNAL_OBJ_CHECK(user_data, __FILE__, __LINE__, __PRETTY_FUNCTION__)

#define	INTERNAL_OBJ_LOCKOBJ(user_data) ((struct astobj2_lockobj ) (((char ) (user_data)) - sizeof(struct astobj2_lockobj)))

#define	INTERNAL_OBJ_MUTEX(user_data) ((struct astobj2_lock ) (((char ) (user_data)) - sizeof(struct astobj2_lock)))

#define	INTERNAL_OBJ_RWLOCK(user_data) ((struct astobj2_rwlock ) (((char ) (user_data)) - sizeof(struct astobj2_rwlock)))

#define	IS_AO2_MAGIC_BAD(p) (AO2_MAGIC != (p->priv_data.magic \| 1))

Functions
enum ao2_lock_req	__adjust_lock (void *user_data, enum ao2_lock_req lock_how, int keep_stronger)

void *	__ao2_alloc (size_t data_size, ao2_destructor_fn destructor_fn, unsigned int options, const char tag, const char file, int line, const char *func)

void *	__ao2_alloc_with_lockobj (size_t data_size, ao2_destructor_fn destructor_fn, void lockobj, const char tag, const char file, int line, const char func)

void	__ao2_cleanup (void *obj)

void	__ao2_cleanup_debug (void obj, const char tag, const char file, int line, const char function)

void *	__ao2_get_weakproxy (void obj, const char tag, const char file, int line, const char func)
	Get the weakproxy attached to obj. More...

int	__ao2_lock (void user_data, enum ao2_lock_req lock_how, const char file, const char func, int line, const char var)
	Lock an object. More...

int	__ao2_ref (void user_data, int delta, const char tag, const char file, int line, const char func)

int	__ao2_trylock (void user_data, enum ao2_lock_req lock_how, const char file, const char func, int line, const char var)
	Try locking– (don't block if fail) More...

int	__ao2_unlock (void user_data, const char file, const char func, int line, const char var)
	Unlock an object. More...

void *	__ao2_weakproxy_alloc (size_t data_size, ao2_destructor_fn destructor_fn, const char tag, const char file, int line, const char *func)
	Allocate an ao2_weakproxy object. More...

void *	__ao2_weakproxy_get_object (void weakproxy, int flags, const char tag, const char file, int line, const char func)
	Get the object associated with weakproxy. More...

int	__ao2_weakproxy_ref_object (void weakproxy, int delta, int flags, const char tag, const char file, int line, const char func)
	Run ao2_t_ref on the object associated with weakproxy. More...

int	__ao2_weakproxy_set_object (void weakproxy, void obj, int flags, const char tag, const char file, int line, const char *func)
	Associate weakproxy with obj. More...

void *	ao2_object_get_lockaddr (void *user_data)
	Return the mutex lock address of an object. More...

unsigned int	ao2_options_get (void *obj)
	Retrieve the ao2 options used to create the object. More...

int	ao2_weakproxy_subscribe (void weakproxy, ao2_weakproxy_notification_cb cb, void data, int flags)
	Request notification when weakproxy points to NULL. More...

int	ao2_weakproxy_unsubscribe (void weakproxy, ao2_weakproxy_notification_cb destroyed_cb, void data, int flags)
	Remove notification of real object destruction. More...

static void	astobj2_cleanup (void)

int	astobj2_init (void)

static void *	internal_ao2_alloc (size_t data_size, ao2_destructor_fn destructor_fn, unsigned int options, void lockobj, const char tag, const char file, int line, const char func)

int	internal_is_ao2_object (void *user_data)

void	log_bad_ao2 (void user_data, const char file, int line, const char *func)

Variables
static FILE *	ref_log

Detailed Description

Functions implementing astobj2 objects.

Author: Richard Mudgett rmudg.nosp@m.ett@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Definition in file astobj2.c.

Macro Definition Documentation

◆ __INTERNAL_OBJ_CHECK

#define __INTERNAL_OBJ_CHECK	(	user_data,
		file,
		line,
		func
	)

convert from a pointer _p to a user-defined object

Returns: the pointer to the astobj2 structure

Definition at line 171 of file astobj2.c.

Referenced by __ao2_get_weakproxy(), __ao2_lock(), __ao2_ref(), __ao2_trylock(), __ao2_unlock(), __ao2_weakproxy_get_object(), __ao2_weakproxy_ref_object(), and __ao2_weakproxy_set_object().

◆ AO2_MAGIC

#define AO2_MAGIC 0xa70b123

Definition at line 96 of file astobj2.c.

Referenced by __ao2_get_weakproxy(), __ao2_ref(), __ao2_weakproxy_set_object(), and internal_ao2_alloc().

◆ AO2_WEAK

#define AO2_WEAK 0xa70b122

Definition at line 97 of file astobj2.c.

Referenced by __ao2_weakproxy_alloc(), __ao2_weakproxy_get_object(), __ao2_weakproxy_ref_object(), __ao2_weakproxy_set_object(), ao2_weakproxy_subscribe(), and ao2_weakproxy_unsubscribe().

◆ ast_log

#define ast_log ast_log_safe

Examples:: /usr/src/asterisk-18.5.0/include/asterisk/logger.h, /usr/src/asterisk-18.5.0/include/asterisk/strings.h, and /usr/src/asterisk-18.5.0/main/app.c.

Definition at line 42 of file astobj2.c.

◆ DEBUG_THREADS_LOOSE_ABI

#define DEBUG_THREADS_LOOSE_ABI

Definition at line 30 of file astobj2.c.

◆ EXCESSIVE_REF_COUNT

#define EXCESSIVE_REF_COUNT 100000

Referenced by __ao2_ref().

◆ EXTERNAL_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 191 of file astobj2.c.

Referenced by internal_ao2_alloc().

◆ INTERNAL_OBJ

#define INTERNAL_OBJ ( user_data ) (struct astobj2 *) ((char *) user_data - sizeof(struct astobj2))

Definition at line 163 of file astobj2.c.

Referenced by __adjust_lock(), __ao2_weakproxy_alloc(), internal_is_ao2_object(), and log_bad_ao2().

◆ INTERNAL_OBJ_CHECK

#define INTERNAL_OBJ_CHECK ( user_data ) __INTERNAL_OBJ_CHECK(user_data, __FILE__, __LINE__, __PRETTY_FUNCTION__)

Definition at line 183 of file astobj2.c.

Referenced by __ao2_ref(), ao2_object_get_lockaddr(), ao2_options_get(), ao2_weakproxy_subscribe(), and ao2_weakproxy_unsubscribe().

◆ INTERNAL_OBJ_LOCKOBJ

#define INTERNAL_OBJ_LOCKOBJ ( user_data ) ((struct astobj2_lockobj *) (((char *) (user_data)) - sizeof(struct astobj2_lockobj)))

Definition at line 160 of file astobj2.c.

Referenced by __adjust_lock(), __ao2_lock(), __ao2_ref(), __ao2_trylock(), and __ao2_unlock().

◆ INTERNAL_OBJ_MUTEX

#define INTERNAL_OBJ_MUTEX ( user_data ) ((struct astobj2_lock *) (((char *) (user_data)) - sizeof(struct astobj2_lock)))

Definition at line 154 of file astobj2.c.

Referenced by __ao2_lock(), __ao2_ref(), __ao2_trylock(), __ao2_unlock(), and ao2_object_get_lockaddr().

◆ INTERNAL_OBJ_RWLOCK

#define INTERNAL_OBJ_RWLOCK ( user_data ) ((struct astobj2_rwlock *) (((char *) (user_data)) - sizeof(struct astobj2_rwlock)))

Definition at line 157 of file astobj2.c.

Referenced by __adjust_lock(), __ao2_lock(), __ao2_ref(), __ao2_trylock(), and __ao2_unlock().

◆ IS_AO2_MAGIC_BAD

#define IS_AO2_MAGIC_BAD ( p ) (AO2_MAGIC != (p->priv_data.magic | 1))

Definition at line 98 of file astobj2.c.

Referenced by internal_is_ao2_object().

Function Documentation

◆ __adjust_lock()

enum ao2_lock_req __adjust_lock	(	void *	user_data,
		enum ao2_lock_req	lock_how,
		int	keep_stronger
	)

Definition at line 425 of file astobj2.c.

References __adjust_lock(), AO2_ALLOC_OPT_LOCK_MASK, AO2_ALLOC_OPT_LOCK_MUTEX, AO2_ALLOC_OPT_LOCK_NOLOCK, AO2_ALLOC_OPT_LOCK_OBJ, AO2_ALLOC_OPT_LOCK_RWLOCK, AO2_LOCK_REQ_MUTEX, AO2_LOCK_REQ_RDLOCK, AO2_LOCK_REQ_WRLOCK, ao2_rdlock, ao2_unlock, ao2_wrlock, ast_log, INTERNAL_OBJ, INTERNAL_OBJ_LOCKOBJ, INTERNAL_OBJ_RWLOCK, ao2_lockobj_priv::lock, astobj2_lockobj::lockobj, LOG_ERROR, ao2_rwlock_priv::num_lockers, __priv_data::options, astobj2::priv_data, and astobj2_rwlock::rwlock.

Referenced by __adjust_lock(), __ao2_iterator_next(), __ao2_link(), __ao2_weakproxy_find(), ao2_iterator_restart(), hash_ao2_node_destructor(), internal_ao2_traverse(), and rb_ao2_node_destructor().

 {
  struct astobj2 *obj = INTERNAL_OBJ(user_data);
  struct astobj2_rwlock *obj_rwlock;
  struct astobj2_lockobj *obj_lockobj;
  enum ao2_lock_req orig_lock;
 
  switch (obj->priv_data.options & AO2_ALLOC_OPT_LOCK_MASK) {
  case AO2_ALLOC_OPT_LOCK_RWLOCK:
  obj_rwlock = INTERNAL_OBJ_RWLOCK(user_data);
  if (obj_rwlock->rwlock.num_lockers < 0) {
  orig_lock = AO2_LOCK_REQ_WRLOCK;
  } else {
  orig_lock = AO2_LOCK_REQ_RDLOCK;
  }
  switch (lock_how) {
  case AO2_LOCK_REQ_MUTEX:
  lock_how = AO2_LOCK_REQ_WRLOCK;
  /* Fall through */
  case AO2_LOCK_REQ_WRLOCK:
  if (lock_how != orig_lock) {
  /* Switch from read lock to write lock. */
  ao2_unlock(user_data);
  ao2_wrlock(user_data);
  }
  break;
  case AO2_LOCK_REQ_RDLOCK:
  if (!keep_stronger && lock_how != orig_lock) {
  /* Switch from write lock to read lock. */
  ao2_unlock(user_data);
  ao2_rdlock(user_data);
  }
  break;
  }
  break;
  case AO2_ALLOC_OPT_LOCK_OBJ:
  obj_lockobj = INTERNAL_OBJ_LOCKOBJ(user_data);
  orig_lock = __adjust_lock(obj_lockobj->lockobj.lock, lock_how, keep_stronger);
  break;
  default:
  ast_log(LOG_ERROR, "Invalid lock option on ao2 object %p\n", user_data);
  /* Fall through */
  case AO2_ALLOC_OPT_LOCK_NOLOCK:
  case AO2_ALLOC_OPT_LOCK_MUTEX:
  orig_lock = AO2_LOCK_REQ_MUTEX;
  break;
  }
 
  return orig_lock;
 }

◆ __ao2_alloc()

void* __ao2_alloc	(	size_t	data_size,
		ao2_destructor_fn	destructor_fn,
		unsigned int	options,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

Definition at line 765 of file astobj2.c.

References internal_ao2_alloc(), and NULL.

Referenced by __ao2_container_alloc_hash(), __ao2_container_alloc_rbtree(), __ao2_weakproxy_alloc(), __ast_channel_internal_alloc(), __ast_format_cap_alloc(), __ast_named_lock_get(), __ast_sorcery_open(), __sip_alloc(), _moh_class_malloc(), and state_alloc().

 {
  return internal_ao2_alloc(data_size, destructor_fn, options, NULL, tag, file, line, func);
 }

◆ __ao2_alloc_with_lockobj()

void* __ao2_alloc_with_lockobj	(	size_t	data_size,
		ao2_destructor_fn	destructor_fn,
		void *	lockobj,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

Definition at line 771 of file astobj2.c.

References AO2_ALLOC_OPT_LOCK_OBJ, and internal_ao2_alloc().

 {
  return internal_ao2_alloc(data_size, destructor_fn, AO2_ALLOC_OPT_LOCK_OBJ, lockobj,
  tag, file, line, func);
 }

◆ __ao2_cleanup()

void __ao2_cleanup ( void * obj )

gcc attribute(cleanup()) functions

Note: they must be able to handle NULL parameters because most of the allocation/find functions can fail and we don't want to try to tear down a NULL

Definition at line 674 of file astobj2.c.

References ao2_ref.

Referenced by agent_request_exec(), ast_ari_bridges_set_video_source(), bridge_agent_hold_push(), bridge_builtin_set_limits(), bridge_stasis_queue_join_action(), dial_bridge_after_cb(), internal_bridge_after_cb(), native_rtp_bridge_framehook_attach(), and parking_set_duration().

 {
  if (obj) {
  ao2_ref(obj, -1);
  }
 }

◆ __ao2_cleanup_debug()

void __ao2_cleanup_debug	(	void *	obj,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	function
	)

Definition at line 667 of file astobj2.c.

References __ao2_ref().

 {
  if (obj) {
  __ao2_ref(obj, -1, tag, file, line, function);
  }
 }

◆ __ao2_get_weakproxy()

void* __ao2_get_weakproxy	(	void *	obj,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

Get the weakproxy attached to obj.

Since: 14.0.0

Parameters

obj	The object to retrieve a weakproxy from

Returns: The weakproxy object

Definition at line 914 of file astobj2.c.

References __ao2_ref(), __INTERNAL_OBJ_CHECK, AO2_MAGIC, __priv_data::magic, NULL, astobj2::priv_data, and __priv_data::weakptr.

 {
  struct astobj2 *obj_internal = __INTERNAL_OBJ_CHECK(obj, file, line, func);
 
  if (!obj_internal || obj_internal->priv_data.magic != AO2_MAGIC) {
  /* This method is meant to be run on normal ao2 objects! */
  return NULL;
  }
 
  if (!obj_internal->priv_data.weakptr) {
  return NULL;
  }
 
  __ao2_ref(obj_internal->priv_data.weakptr, +1, tag, file, line, func);
  return obj_internal->priv_data.weakptr;
 }

◆ __ao2_lock()

int __ao2_lock	(	void *	a,
		enum ao2_lock_req	lock_how,
		const char *	file,
		const char *	func,
		int	line,
		const char *	var
	)

Lock an object.

Parameters

a	A pointer to the object we want to lock.
lock_how,file,func,line,var

Returns: 0 on success, other values on error.

Definition at line 222 of file astobj2.c.

References __ast_pthread_mutex_lock(), __ast_rwlock_rdlock(), __ast_rwlock_wrlock(), __INTERNAL_OBJ_CHECK, __LOG_ERROR, AO2_ALLOC_OPT_LOCK_MASK, AO2_ALLOC_OPT_LOCK_MUTEX, AO2_ALLOC_OPT_LOCK_NOLOCK, AO2_ALLOC_OPT_LOCK_OBJ, AO2_ALLOC_OPT_LOCK_RWLOCK, AO2_LOCK_REQ_MUTEX, AO2_LOCK_REQ_RDLOCK, AO2_LOCK_REQ_WRLOCK, ast_atomic_fetchadd_int(), ast_log, INTERNAL_OBJ_LOCKOBJ, INTERNAL_OBJ_MUTEX, INTERNAL_OBJ_RWLOCK, ao2_lock_priv::lock, ao2_rwlock_priv::lock, ao2_lockobj_priv::lock, astobj2_lockobj::lockobj, __priv_data::lockused, astobj2_lock::mutex, NULL, ao2_rwlock_priv::num_lockers, __priv_data::options, astobj2::priv_data, ref_log, and astobj2_rwlock::rwlock.

Referenced by _agent_lock(), _ast_bridge_channel_lock(), and _ast_bridge_lock().

 {
  struct astobj2 *obj = __INTERNAL_OBJ_CHECK(user_data, file, line, func);
  struct astobj2_lock *obj_mutex;
  struct astobj2_rwlock *obj_rwlock;
  struct astobj2_lockobj *obj_lockobj;
  int res = 0;
 
  if (obj == NULL) {
  return -1;
  }
 
  if (ref_log) {
  obj->priv_data.lockused = 1;
  }
 
  switch (obj->priv_data.options & AO2_ALLOC_OPT_LOCK_MASK) {
  case AO2_ALLOC_OPT_LOCK_MUTEX:
  obj_mutex = INTERNAL_OBJ_MUTEX(user_data);
  res = __ast_pthread_mutex_lock(file, line, func, var, &obj_mutex->mutex.lock);
 #ifdef AO2_DEBUG
  if (!res) {
  ast_atomic_fetchadd_int(&ao2.total_locked, 1);
  }
 #endif
  break;
  case AO2_ALLOC_OPT_LOCK_RWLOCK:
  obj_rwlock = INTERNAL_OBJ_RWLOCK(user_data);
  switch (lock_how) {
  case AO2_LOCK_REQ_MUTEX:
  case AO2_LOCK_REQ_WRLOCK:
  res = __ast_rwlock_wrlock(file, line, func, &obj_rwlock->rwlock.lock, var);
  if (!res) {
  ast_atomic_fetchadd_int(&obj_rwlock->rwlock.num_lockers, -1);
 #ifdef AO2_DEBUG
  ast_atomic_fetchadd_int(&ao2.total_locked, 1);
 #endif
  }
  break;
  case AO2_LOCK_REQ_RDLOCK:
  res = __ast_rwlock_rdlock(file, line, func, &obj_rwlock->rwlock.lock, var);
  if (!res) {
  ast_atomic_fetchadd_int(&obj_rwlock->rwlock.num_lockers, +1);
 #ifdef AO2_DEBUG
  ast_atomic_fetchadd_int(&ao2.total_locked, 1);
 #endif
  }
  break;
  }
  break;
  case AO2_ALLOC_OPT_LOCK_NOLOCK:
  /* The ao2 object has no lock. */
  break;
  case AO2_ALLOC_OPT_LOCK_OBJ:
  obj_lockobj = INTERNAL_OBJ_LOCKOBJ(user_data);
  res = __ao2_lock(obj_lockobj->lockobj.lock, lock_how, file, func, line, var);
  break;
  default:
  ast_log(__LOG_ERROR, file, line, func, "Invalid lock option on ao2 object %p\n",
  user_data);
  return -1;
  }
 
  return res;
 }

◆ __ao2_ref()

int __ao2_ref	(	void *	user_data,
		int	delta,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

Definition at line 498 of file astobj2.c.

References __ast_assert_failed(), __INTERNAL_OBJ_CHECK, __LOG_ERROR, AO2_ALLOC_OPT_LOCK_MASK, AO2_ALLOC_OPT_LOCK_MUTEX, AO2_ALLOC_OPT_LOCK_NOLOCK, AO2_ALLOC_OPT_LOCK_OBJ, AO2_ALLOC_OPT_LOCK_RWLOCK, AO2_ALLOC_OPT_NO_REF_DEBUG, ao2_lock, AO2_MAGIC, ao2_ref, ao2_t_ref, ao2_unlock, ast_assert, ast_atomic_fetch_add, ast_atomic_fetchadd_int(), ast_free, ast_get_tid(), AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_REMOVE_HEAD, ast_log, ast_mutex_destroy, ast_rwlock_destroy, ao2_weakproxy_notification::cb, ao2_weakproxy_notification::data, ao2_weakproxy::destroyed_cb, __priv_data::destructor_fn, EXCESSIVE_REF_COUNT, INTERNAL_OBJ_CHECK, INTERNAL_OBJ_LOCKOBJ, INTERNAL_OBJ_MUTEX, INTERNAL_OBJ_RWLOCK, ao2_weakproxy_notification::list, ao2_lock_priv::lock, ao2_rwlock_priv::lock, ao2_lockobj_priv::lock, astobj2_lockobj::lockobj, __priv_data::lockused, __priv_data::magic, astobj2_lock::mutex, NULL, __priv_data::options, astobj2::priv_data, __priv_data::ref_counter, ref_log, astobj2_rwlock::rwlock, and __priv_data::weakptr.

Referenced by __ao2_cleanup_debug(), __ao2_container_clone(), __ao2_get_weakproxy(), __ao2_global_obj_ref(), __ao2_global_obj_replace(), __ao2_global_obj_replace_unref(), __ao2_iterator_next(), __ao2_weakproxy_get_object(), __ao2_weakproxy_ref_object(), __ao2_weakproxy_set_object(), __ast_format_cap_append(), __ast_module_ref(), __ast_module_unref(), __container_unlink_node_debug(), __find_call(), _mohclass_unref(), hash_ao2_new_node(), internal_ao2_traverse(), and rb_ao2_new_node().

 {
  struct astobj2 *obj = __INTERNAL_OBJ_CHECK(user_data, file, line, func);
  struct astobj2_lock *obj_mutex;
  struct astobj2_rwlock *obj_rwlock;
  struct astobj2_lockobj *obj_lockobj;
  int32_t current_value;
  int32_t ret;
  struct ao2_weakproxy *weakproxy = NULL;
  const char *lock_state;
 
  if (obj == NULL) {
  if (ref_log && user_data) {
  fprintf(ref_log, "%p,%d,%d,%s,%d,%s,**invalid**,%s\n",
  user_data, delta, ast_get_tid(), file, line, func, tag ?: "");
  fflush(ref_log);
  }
  return -1;
  }
 
  /* if delta is 0, just return the refcount */
  if (delta == 0) {
  return obj->priv_data.ref_counter;
  }
 
  if (delta < 0 && obj->priv_data.magic == AO2_MAGIC && (weakproxy = obj->priv_data.weakptr)) {
  ao2_lock(weakproxy);
  }
 
  /* we modify with an atomic operation the reference counter */
  ret = ast_atomic_fetch_add(&obj->priv_data.ref_counter, delta, __ATOMIC_RELAXED);
  current_value = ret + delta;
 
 #ifdef AO2_DEBUG
  ast_atomic_fetchadd_int(&ao2.total_refs, delta);
 #endif
 
  if (weakproxy) {
  struct ao2_weakproxy cbs;
 
  if (current_value == 1) {
  /* The only remaining reference is the one owned by the weak object */
  struct astobj2 *internal_weakproxy;
 
  internal_weakproxy = INTERNAL_OBJ_CHECK(weakproxy);
 
  /* Unlink the obj from the weak proxy */
  internal_weakproxy->priv_data.weakptr = NULL;
  obj->priv_data.weakptr = NULL;
 
  /* transfer list to local copy so callbacks are run with weakproxy unlocked. */
  cbs.destroyed_cb = weakproxy->destroyed_cb;
  AST_LIST_HEAD_INIT_NOLOCK(&weakproxy->destroyed_cb);
 
  /* weak is already unlinked from obj so this won't recurse */
  ao2_ref(user_data, -1);
  }
 
  ao2_unlock(weakproxy);
 
  if (current_value == 1) {
  struct ao2_weakproxy_notification *destroyed_cb;
 
  /* Notify the subscribers that weakproxy now points to NULL. */
  while ((destroyed_cb = AST_LIST_REMOVE_HEAD(&cbs.destroyed_cb, list))) {
  destroyed_cb->cb(weakproxy, destroyed_cb->data);
  ast_free(destroyed_cb);
  }
 
  ao2_ref(weakproxy, -1);
  }
  }
 
  if (0 < current_value) {
  /* The object still lives. */
 #define EXCESSIVE_REF_COUNT 100000
 
  if (EXCESSIVE_REF_COUNT <= current_value && ret < EXCESSIVE_REF_COUNT) {
  char excessive_ref_buf[100];
 
  /* We just reached or went over the excessive ref count trigger */
  snprintf(excessive_ref_buf, sizeof(excessive_ref_buf),
  "Excessive refcount %d reached on ao2 object %p",
  (int)current_value, user_data);
  ast_log(__LOG_ERROR, file, line, func, "%s\n", excessive_ref_buf);
 
  __ast_assert_failed(0, excessive_ref_buf, file, line, func);
  }
 
  if (ref_log && !(obj->priv_data.options & AO2_ALLOC_OPT_NO_REF_DEBUG)) {
  fprintf(ref_log, "%p,%s%d,%d,%s,%d,%s,%d,%s\n", user_data,
  (delta < 0 ? "" : "+"), delta, ast_get_tid(),
  file, line, func, (int)ret, tag ?: "");
  fflush(ref_log);
  }
  return ret;
  }
 
  /* this case must never happen */
  if (current_value < 0) {
  ast_log(__LOG_ERROR, file, line, func,
  "Invalid refcount %d on ao2 object %p\n", (int)current_value, user_data);
  if (ref_log) {
  /* Log to ref_log even if AO2_ALLOC_OPT_NO_REF_DEBUG */
  fprintf(ref_log, "%p,%d,%d,%s,%d,%s,**invalid**,%s\n",
  user_data, delta, ast_get_tid(), file, line, func, tag ?: "");
  fflush(ref_log);
  }
  ast_assert(0);
  /* stop here even if assert doesn't DO_CRASH */
  return -1;
  }
 
  /* last reference, destroy the object */
  if (obj->priv_data.destructor_fn != NULL) {
  obj->priv_data.destructor_fn(user_data);
  }
 
 #ifdef AO2_DEBUG
  ast_atomic_fetchadd_int(&ao2.total_mem, - obj->priv_data.data_size);
  ast_atomic_fetchadd_int(&ao2.total_objects, -1);
 #endif
 
  /* In case someone uses an object after it's been freed */
  obj->priv_data.magic = 0;
 
  switch (obj->priv_data.options & AO2_ALLOC_OPT_LOCK_MASK) {
  case AO2_ALLOC_OPT_LOCK_MUTEX:
  obj_mutex = INTERNAL_OBJ_MUTEX(user_data);
  lock_state = obj->priv_data.lockused ? "used" : "unused";
  ast_mutex_destroy(&obj_mutex->mutex.lock);
 
  ast_free(obj_mutex);
  break;
  case AO2_ALLOC_OPT_LOCK_RWLOCK:
  obj_rwlock = INTERNAL_OBJ_RWLOCK(user_data);
  lock_state = obj->priv_data.lockused ? "used" : "unused";
  ast_rwlock_destroy(&obj_rwlock->rwlock.lock);
 
  ast_free(obj_rwlock);
  break;
  case AO2_ALLOC_OPT_LOCK_NOLOCK:
  lock_state = "none";
  ast_free(obj);
  break;
  case AO2_ALLOC_OPT_LOCK_OBJ:
  obj_lockobj = INTERNAL_OBJ_LOCKOBJ(user_data);
  lock_state = obj->priv_data.lockused ? "used" : "unused";
  ao2_t_ref(obj_lockobj->lockobj.lock, -1, "release lockobj");
 
  ast_free(obj_lockobj);
  break;
  default:
  ast_log(__LOG_ERROR, file, line, func,
  "Invalid lock option on ao2 object %p\n", user_data);
  lock_state = "invalid";
  break;
  }
 
  if (ref_log && !(obj->priv_data.options & AO2_ALLOC_OPT_NO_REF_DEBUG)) {
  fprintf(ref_log, "%p,%d,%d,%s,%d,%s,**destructor**lock-state:%s**,%s\n",
  user_data, delta, ast_get_tid(), file, line, func, lock_state, tag ?: "");
  fflush(ref_log);
  }
 
  return ret;
 }

◆ __ao2_trylock()

int __ao2_trylock	(	void *	a,
		enum ao2_lock_req	lock_how,
		const char *	file,
		const char *	func,
		int	line,
		const char *	var
	)

Try locking– (don't block if fail)

Parameters

a	A pointer to the object we want to lock.
lock_how,file,func,line,var

Returns: 0 on success, other values on error.

Definition at line 342 of file astobj2.c.

References __ast_pthread_mutex_trylock(), __ast_rwlock_tryrdlock(), __ast_rwlock_trywrlock(), __INTERNAL_OBJ_CHECK, __LOG_ERROR, AO2_ALLOC_OPT_LOCK_MASK, AO2_ALLOC_OPT_LOCK_MUTEX, AO2_ALLOC_OPT_LOCK_NOLOCK, AO2_ALLOC_OPT_LOCK_OBJ, AO2_ALLOC_OPT_LOCK_RWLOCK, AO2_LOCK_REQ_MUTEX, AO2_LOCK_REQ_RDLOCK, AO2_LOCK_REQ_WRLOCK, ast_atomic_fetchadd_int(), ast_log, INTERNAL_OBJ_LOCKOBJ, INTERNAL_OBJ_MUTEX, INTERNAL_OBJ_RWLOCK, ao2_lock_priv::lock, ao2_rwlock_priv::lock, ao2_lockobj_priv::lock, astobj2_lockobj::lockobj, __priv_data::lockused, astobj2_lock::mutex, NULL, ao2_rwlock_priv::num_lockers, __priv_data::options, astobj2::priv_data, ref_log, and astobj2_rwlock::rwlock.

Referenced by _ast_bridge_channel_trylock(), and _ast_bridge_trylock().

 {
  struct astobj2 *obj = __INTERNAL_OBJ_CHECK(user_data, file, line, func);
  struct astobj2_lock *obj_mutex;
  struct astobj2_rwlock *obj_rwlock;
  struct astobj2_lockobj *obj_lockobj;
  int res = 0;
 
  if (obj == NULL) {
  return -1;
  }
 
  if (ref_log) {
  obj->priv_data.lockused = 1;
  }
 
  switch (obj->priv_data.options & AO2_ALLOC_OPT_LOCK_MASK) {
  case AO2_ALLOC_OPT_LOCK_MUTEX:
  obj_mutex = INTERNAL_OBJ_MUTEX(user_data);
  res = __ast_pthread_mutex_trylock(file, line, func, var, &obj_mutex->mutex.lock);
 #ifdef AO2_DEBUG
  if (!res) {
  ast_atomic_fetchadd_int(&ao2.total_locked, 1);
  }
 #endif
  break;
  case AO2_ALLOC_OPT_LOCK_RWLOCK:
  obj_rwlock = INTERNAL_OBJ_RWLOCK(user_data);
  switch (lock_how) {
  case AO2_LOCK_REQ_MUTEX:
  case AO2_LOCK_REQ_WRLOCK:
  res = __ast_rwlock_trywrlock(file, line, func, &obj_rwlock->rwlock.lock, var);
  if (!res) {
  ast_atomic_fetchadd_int(&obj_rwlock->rwlock.num_lockers, -1);
 #ifdef AO2_DEBUG
  ast_atomic_fetchadd_int(&ao2.total_locked, 1);
 #endif
  }
  break;
  case AO2_LOCK_REQ_RDLOCK:
  res = __ast_rwlock_tryrdlock(file, line, func, &obj_rwlock->rwlock.lock, var);
  if (!res) {
  ast_atomic_fetchadd_int(&obj_rwlock->rwlock.num_lockers, +1);
 #ifdef AO2_DEBUG
  ast_atomic_fetchadd_int(&ao2.total_locked, 1);
 #endif
  }
  break;
  }
  break;
  case AO2_ALLOC_OPT_LOCK_NOLOCK:
  /* The ao2 object has no lock. */
  return 0;
  case AO2_ALLOC_OPT_LOCK_OBJ:
  obj_lockobj = INTERNAL_OBJ_LOCKOBJ(user_data);
  res = __ao2_trylock(obj_lockobj->lockobj.lock, lock_how, file, func, line, var);
  break;
  default:
  ast_log(__LOG_ERROR, file, line, func, "Invalid lock option on ao2 object %p\n",
  user_data);
  return -1;
  }
 
  return res;
 }

◆ __ao2_unlock()

int __ao2_unlock	(	void *	a,
		const char *	file,
		const char *	func,
		int	line,
		const char *	var
	)

Unlock an object.

Parameters

a	A pointer to the object we want unlock.
file,func,line,var

Returns: 0 on success, other values on error.

Definition at line 288 of file astobj2.c.

References __ast_pthread_mutex_unlock(), __ast_rwlock_unlock(), __INTERNAL_OBJ_CHECK, __LOG_ERROR, AO2_ALLOC_OPT_LOCK_MASK, AO2_ALLOC_OPT_LOCK_MUTEX, AO2_ALLOC_OPT_LOCK_NOLOCK, AO2_ALLOC_OPT_LOCK_OBJ, AO2_ALLOC_OPT_LOCK_RWLOCK, ast_atomic_fetchadd_int(), ast_log, INTERNAL_OBJ_LOCKOBJ, INTERNAL_OBJ_MUTEX, INTERNAL_OBJ_RWLOCK, ao2_lock_priv::lock, ao2_rwlock_priv::lock, ao2_lockobj_priv::lock, astobj2_lockobj::lockobj, astobj2_lock::mutex, NULL, ao2_rwlock_priv::num_lockers, __priv_data::options, astobj2::priv_data, and astobj2_rwlock::rwlock.

Referenced by _agent_unlock(), _ast_bridge_channel_unlock(), and _ast_bridge_unlock().

 {
  struct astobj2 *obj = __INTERNAL_OBJ_CHECK(user_data, file, line, func);
  struct astobj2_lock *obj_mutex;
  struct astobj2_rwlock *obj_rwlock;
  struct astobj2_lockobj *obj_lockobj;
  int res = 0;
  int current_value;
 
  if (obj == NULL) {
  return -1;
  }
 
  switch (obj->priv_data.options & AO2_ALLOC_OPT_LOCK_MASK) {
  case AO2_ALLOC_OPT_LOCK_MUTEX:
  obj_mutex = INTERNAL_OBJ_MUTEX(user_data);
  res = __ast_pthread_mutex_unlock(file, line, func, var, &obj_mutex->mutex.lock);
 #ifdef AO2_DEBUG
  if (!res) {
  ast_atomic_fetchadd_int(&ao2.total_locked, -1);
  }
 #endif
  break;
  case AO2_ALLOC_OPT_LOCK_RWLOCK:
  obj_rwlock = INTERNAL_OBJ_RWLOCK(user_data);
 
  current_value = ast_atomic_fetchadd_int(&obj_rwlock->rwlock.num_lockers, -1) - 1;
  if (current_value < 0) {
  /* It was a WRLOCK that we are unlocking. Fix the count. */
  ast_atomic_fetchadd_int(&obj_rwlock->rwlock.num_lockers, -current_value);
  }
  res = __ast_rwlock_unlock(file, line, func, &obj_rwlock->rwlock.lock, var);
 #ifdef AO2_DEBUG
  if (!res) {
  ast_atomic_fetchadd_int(&ao2.total_locked, -1);
  }
 #endif
  break;
  case AO2_ALLOC_OPT_LOCK_NOLOCK:
  /* The ao2 object has no lock. */
  break;
  case AO2_ALLOC_OPT_LOCK_OBJ:
  obj_lockobj = INTERNAL_OBJ_LOCKOBJ(user_data);
  res = __ao2_unlock(obj_lockobj->lockobj.lock, file, func, line, var);
  break;
  default:
  ast_log(__LOG_ERROR, file, line, func, "Invalid lock option on ao2 object %p\n",
  user_data);
  res = -1;
  break;
  }
  return res;
 }

◆ __ao2_weakproxy_alloc()

void* __ao2_weakproxy_alloc	(	size_t	data_size,
		ao2_destructor_fn	destructor_fn,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

Allocate an ao2_weakproxy object.

Since: 14.0.0

Parameters

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

Note: "struct ao2_weakproxy" must be the first field of any object. This can be done by using AO2_WEAKPROXY to declare your structure.

Definition at line 790 of file astobj2.c.

References __ao2_alloc(), AO2_ALLOC_OPT_LOCK_MUTEX, AO2_WEAK, ast_assert, ast_log, INTERNAL_OBJ, LOG_ERROR, __priv_data::magic, NULL, and astobj2::priv_data.

 {
  struct ao2_weakproxy *weakproxy;
 
  if (data_size < sizeof(*weakproxy)) {
  ast_assert(0);
  ast_log(LOG_ERROR, "Requested data_size smaller than minimum.\n");
  return NULL;
  }
 
  weakproxy = __ao2_alloc(data_size, destructor_fn, AO2_ALLOC_OPT_LOCK_MUTEX,
  tag, file, line, func);
 
  if (weakproxy) {
  struct astobj2 *weakproxy_internal;
 
  /* Just created weakproxy, no need to check if it's valid. */
  weakproxy_internal = INTERNAL_OBJ(weakproxy);
  weakproxy_internal->priv_data.magic = AO2_WEAK;
  }
 
  return weakproxy;
 }

◆ __ao2_weakproxy_get_object()

void* __ao2_weakproxy_get_object	(	void *	weakproxy,
		int	flags,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

Get the object associated with weakproxy.

Since: 14.0.0

Parameters

weakproxy	The weakproxy to read from.
flags	OBJ_NOLOCK to avoid locking weakproxy.

Returns: A reference to the object previously set by ao2_weakproxy_set_object.

Return values

NULL	Either no object was set or the previously set object has been freed.

Definition at line 886 of file astobj2.c.

References __ao2_ref(), __INTERNAL_OBJ_CHECK, ao2_lock, ao2_unlock, AO2_WEAK, NULL, and OBJ_NOLOCK.

Referenced by __ao2_weakproxy_find().

 {
  struct astobj2 *internal = __INTERNAL_OBJ_CHECK(weakproxy, file, line, func);
  void *obj;
 
  if (!internal || internal->priv_data.magic != AO2_WEAK) {
  /* This method is meant to be run on weakproxy objects! */
  return NULL;
  }
 
  /* We have a weak object, grab reference to object within lock */
  if (!(flags & OBJ_NOLOCK)) {
  ao2_lock(weakproxy);
  }
 
  obj = internal->priv_data.weakptr;
  if (obj) {
  __ao2_ref(obj, +1, tag, file, line, func);
  }
 
  if (!(flags & OBJ_NOLOCK)) {
  ao2_unlock(weakproxy);
  }
 
  return obj;
 }

◆ __ao2_weakproxy_ref_object()

int __ao2_weakproxy_ref_object	(	void *	weakproxy,
		int	delta,
		int	flags,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

Run ao2_t_ref on the object associated with weakproxy.

Since: 14.0.0

Parameters

weakproxy	The weakproxy to read from.
delta	Value to add to the reference counter.
flags	OBJ_NOLOCK to avoid locking weakproxy.

Return values

-2	weakproxy is not a valid ao2_weakproxy.
-1	weakproxy has no associated object.

Returns: The value of the reference counter before the operation.

Definition at line 859 of file astobj2.c.

References __ao2_ref(), __INTERNAL_OBJ_CHECK, ao2_lock, ao2_unlock, AO2_WEAK, and OBJ_NOLOCK.

 {
  struct astobj2 *internal = __INTERNAL_OBJ_CHECK(weakproxy, file, line, func);
  int ret = -1;
 
  if (!internal || internal->priv_data.magic != AO2_WEAK) {
  /* This method is meant to be run on weakproxy objects! */
  return -2;
  }
 
  /* We have a weak object, grab lock. */
  if (!(flags & OBJ_NOLOCK)) {
  ao2_lock(weakproxy);
  }
 
  if (internal->priv_data.weakptr) {
  ret = __ao2_ref(internal->priv_data.weakptr, delta, tag, file, line, func);
  }
 
  if (!(flags & OBJ_NOLOCK)) {
  ao2_unlock(weakproxy);
  }
 
  return ret;
 }

◆ __ao2_weakproxy_set_object()

int __ao2_weakproxy_set_object	(	void *	weakproxy,
		void *	obj,
		int	flags,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

Associate weakproxy with obj.

Since: 14.0.0

Parameters

weakproxy	An object created by ao2_weakproxy_alloc.
obj	An ao2 object not created by ao2_weakproxy_alloc.
flags	OBJ_NOLOCK to avoid locking weakproxy.

Return values

0	Success
-1	Failure

Note: obj must be newly created, this procedure is not thread safe if any other code can reach obj before this procedure ends.; weakproxy may be previously existing, but must not currently have an object set.; The only way to unset an object is for it to be destroyed. Any call to this function while an object is already set will fail.

Definition at line 815 of file astobj2.c.

References __ao2_ref(), __INTERNAL_OBJ_CHECK, ao2_lock, AO2_MAGIC, ao2_unlock, AO2_WEAK, __priv_data::magic, OBJ_NOLOCK, astobj2::priv_data, and __priv_data::weakptr.

 {
  struct astobj2 *weakproxy_internal = __INTERNAL_OBJ_CHECK(weakproxy, file, line, func);
  struct astobj2 *obj_internal = __INTERNAL_OBJ_CHECK(obj, file, line, func);
  int ret = -1;
 
  if (!weakproxy_internal
  || weakproxy_internal->priv_data.magic != AO2_WEAK) {
  return -1;
  }
 
  if (!obj_internal
  || obj_internal->priv_data.weakptr
  || obj_internal->priv_data.magic != AO2_MAGIC) {
  return -1;
  }
 
  if (!(flags & OBJ_NOLOCK)) {
  ao2_lock(weakproxy);
  }
 
  if (!weakproxy_internal->priv_data.weakptr) {
  __ao2_ref(obj, +1, tag, file, line, func);
  __ao2_ref(weakproxy, +1, tag, file, line, func);
 
  weakproxy_internal->priv_data.weakptr = obj;
  obj_internal->priv_data.weakptr = weakproxy;
 
  ret = 0;
  }
 
  if (!(flags & OBJ_NOLOCK)) {
  ao2_unlock(weakproxy);
  /* It is possible for obj to be accessed now. It's allowed
  * for weakproxy to already be in a container. Another thread
  * could have been waiting for a lock on weakproxy to retrieve
  * the object.
  */
  }
 
  return ret;
 }

◆ ao2_object_get_lockaddr()

void* ao2_object_get_lockaddr ( void * obj )

Return the mutex lock address of an object.

Parameters

[in] obj A pointer to the object we want.

Returns: the address of the mutex 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.

Warning: AO2 lock objects do not include tracking fields when DEBUG_THREADS is not enabled.

Since: 1.6.1

Definition at line 476 of file astobj2.c.

References AO2_ALLOC_OPT_LOCK_MASK, AO2_ALLOC_OPT_LOCK_MUTEX, INTERNAL_OBJ_CHECK, INTERNAL_OBJ_MUTEX, ao2_lock_priv::lock, astobj2_lock::mutex, NULL, __priv_data::options, and astobj2::priv_data.

Referenced by ast_rtp_ice_turn_request(), ast_serializer_shutdown_group_join(), ast_sip_session_suspend(), bridge_channel_wait(), bridge_manager_thread(), consumer_should_stay(), consumer_wait_for(), consumer_wait_for_completion(), control_wait(), db_sync_thread(), ice_reset_session(), pbx_outgoing_attempt(), rtp_deallocate_transport(), sip_session_suspend_task(), stasis_subscription_join(), and wait_for_stimulus().

 {
  struct astobj2 *obj;
  struct astobj2_lock *obj_mutex;
 
  obj = INTERNAL_OBJ_CHECK(user_data);
 
  if (obj == NULL) {
  return NULL;
  }
 
  switch (obj->priv_data.options & AO2_ALLOC_OPT_LOCK_MASK) {
  case AO2_ALLOC_OPT_LOCK_MUTEX:
  obj_mutex = INTERNAL_OBJ_MUTEX(user_data);
  return &obj_mutex->mutex.lock;
  default:
  break;
  }
 
  return NULL;
 }

◆ ao2_options_get()

unsigned int ao2_options_get ( void * obj )

Retrieve the ao2 options used to create the object.

Parameters

obj	pointer to the (user-defined part) of an object.

Returns: options from enum ao2_alloc_opts.

Definition at line 778 of file astobj2.c.

References INTERNAL_OBJ_CHECK, __priv_data::options, and astobj2::priv_data.

Referenced by __ast_named_lock_get(), hash_ao2_alloc_empty_clone(), and rb_ao2_alloc_empty_clone().

 {
  struct astobj2 *orig_obj;
 
  orig_obj = INTERNAL_OBJ_CHECK(obj);
  if (!orig_obj) {
  return 0;
  }
  return orig_obj->priv_data.options;
 }

◆ ao2_weakproxy_subscribe()

int ao2_weakproxy_subscribe	(	void *	weakproxy,
		ao2_weakproxy_notification_cb	cb,
		void *	data,
		int	flags
	)

Request notification when weakproxy points to NULL.

Since: 14.0.0

Parameters

weakproxy	The weak object
cb	Procedure to call when no real object is associated
data	Passed to cb
flags	OBJ_NOLOCK to avoid locking weakproxy.

Return values

0	Success
-1	Failure

Note: Callbacks are run in the reverse order of subscriptions.; This procedure will allow the same cb / data pair to be added to the same weakproxy multiple times.; It is the caller's responsibility to ensure that *data is valid until after cb() is run or ao2_weakproxy_unsubscribe is called.; If the weakproxy currently points to NULL the callback will be run immediately, without being added to the subscriber list.

Definition at line 931 of file astobj2.c.

References ao2_lock, ao2_unlock, AO2_WEAK, ast_calloc, AST_LIST_INSERT_HEAD, ao2_weakproxy_notification::cb, ao2_weakproxy_notification::data, ao2_weakproxy::destroyed_cb, INTERNAL_OBJ_CHECK, ao2_weakproxy_notification::list, __priv_data::magic, NULL, OBJ_NOLOCK, astobj2::priv_data, sub, and __priv_data::weakptr.

Referenced by __ast_named_lock_get(), __ast_sorcery_open(), AST_TEST_DEFINE(), link_topic_proxy(), and state_alloc().

 {
  struct astobj2 *weakproxy_internal = INTERNAL_OBJ_CHECK(weakproxy);
  int ret = -1;
  int hasobj;
 
  if (!weakproxy_internal || weakproxy_internal->priv_data.magic != AO2_WEAK) {
  return -1;
  }
 
  if (!(flags & OBJ_NOLOCK)) {
  ao2_lock(weakproxy);
  }
 
  hasobj = weakproxy_internal->priv_data.weakptr != NULL;
  if (hasobj) {
  struct ao2_weakproxy *weak = weakproxy;
  struct ao2_weakproxy_notification *sub = ast_calloc(1, sizeof(*sub));
 
  if (sub) {
  sub->cb = cb;
  sub->data = data;
  AST_LIST_INSERT_HEAD(&weak->destroyed_cb, sub, list);
  ret = 0;
  }
  }
 
  if (!(flags & OBJ_NOLOCK)) {
  ao2_unlock(weakproxy);
  }
 
  if (!hasobj) {
  cb(weakproxy, data);
  ret = 0;
  }
 
  return ret;
 }

◆ ao2_weakproxy_unsubscribe()

int ao2_weakproxy_unsubscribe	(	void *	weakproxy,
		ao2_weakproxy_notification_cb	cb,
		void *	data,
		int	flags
	)

Remove notification of real object destruction.

Since: 14.0.0

Parameters

weakproxy	The weak object
cb	Callback to remove from destroy notification list
data	Data pointer to match
flags	OBJ_NOLOCK to avoid locking weakproxy. OBJ_MULTIPLE to remove all copies of the same cb / data pair.

Returns: The number of subscriptions removed.

Return values

0	cb / data pair not found, nothing removed.
-1	Failure due to invalid parameters.

Note: Unless flags includes OBJ_MULTIPLE, this will only remove a single copy of the cb / data pair. If it was subscribed multiple times it must be unsubscribed as many times. The OBJ_MULTIPLE flag can be used to remove matching subscriptions.; When it's time to run callbacks they are copied to a temporary list so the weakproxy can be unlocked before running. That means it's possible for this function to find nothing before the callback is run in another thread.

Definition at line 970 of file astobj2.c.

References a, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_clone, ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_link, ao2_lock, ao2_t_alloc, ao2_t_callback, ao2_t_container_alloc_list, ao2_t_iterator_next, ao2_t_ref, ao2_t_unlink, ao2_unlock, AO2_WEAK, ast_cli_args::argc, ast_cli_args::argv, ast_add_profile(), ast_cli(), AST_CLI_DEFINE, ast_free, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_mark(), ast_verbose(), ao2_weakproxy_notification::cb, CLI_GENERATE, CLI_HANDLER, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ao2_weakproxy_notification::data, ao2_weakproxy::destroyed_cb, ast_cli_args::fd, INTERNAL_OBJ_CHECK, ao2_weakproxy_notification::list, __priv_data::magic, NULL, OBJ_MULTIPLE, OBJ_NOLOCK, astobj2::priv_data, sub, and ast_cli_entry::usage.

Referenced by AST_TEST_DEFINE().

 {
  struct astobj2 *internal_weakproxy = INTERNAL_OBJ_CHECK(weakproxy);
  struct ao2_weakproxy *weak;
  struct ao2_weakproxy_notification *sub;
  int ret = 0;
 
  if (!internal_weakproxy || internal_weakproxy->priv_data.magic != AO2_WEAK || !destroyed_cb) {
  return -1;
  }
 
  if (!(flags & OBJ_NOLOCK)) {
  ao2_lock(weakproxy);
  }
 
  weak = weakproxy;
  AST_LIST_TRAVERSE_SAFE_BEGIN(&weak->destroyed_cb, sub, list) {
  if (sub->cb == destroyed_cb && sub->data == data) {
  AST_LIST_REMOVE_CURRENT(list);
  ast_free(sub);
  ret++;
  if (!(flags & OBJ_MULTIPLE)) {
  break;
  }
  }
  }
  AST_LIST_TRAVERSE_SAFE_END;
 
  if (!(flags & OBJ_NOLOCK)) {
  ao2_unlock(weakproxy);
  }
 
  return ret;
 }

◆ astobj2_cleanup()

static void astobj2_cleanup ( void )

static

Definition at line 1154 of file astobj2.c.

References ARRAY_LEN, ast_cli_unregister_multiple(), ast_opt_ref_debug, NULL, and ref_log.

Referenced by astobj2_init().

 {
 #if defined(AO2_DEBUG)
  ast_cli_unregister_multiple(cli_astobj2, ARRAY_LEN(cli_astobj2));
 #endif
 
  if (ast_opt_ref_debug) {
  fclose(ref_log);
  ref_log = NULL;
  }
 }

◆ astobj2_init()

int astobj2_init ( void )

Provided by astobj2.c

Definition at line 1166 of file astobj2.c.

References ARRAY_LEN, ast_cli_register_multiple, ast_config_AST_LOG_DIR, ast_log, ast_opt_ref_debug, ast_register_cleanup(), astobj2_cleanup(), container_init(), LOG_ERROR, NULL, and ref_log.

Referenced by asterisk_daemon().

 {
  char ref_filename[1024];
 
  if (ast_opt_ref_debug) {
  snprintf(ref_filename, sizeof(ref_filename), "%s/refs", ast_config_AST_LOG_DIR);
  ref_log = fopen(ref_filename, "w");
  if (!ref_log) {
  ast_log(LOG_ERROR, "Could not open ref debug log file: %s\n", ref_filename);
  }
  }
 
  ast_register_cleanup(astobj2_cleanup);
 
  if (container_init() != 0) {
  fclose(ref_log);
  ref_log = NULL;
  return -1;
  }
 
 #if defined(AO2_DEBUG)
  ast_cli_register_multiple(cli_astobj2, ARRAY_LEN(cli_astobj2));
 #endif /* defined(AO2_DEBUG) */
 
  return 0;
 }

◆ internal_ao2_alloc()

static void* internal_ao2_alloc	(	size_t	data_size,
		ao2_destructor_fn	destructor_fn,
		unsigned int	options,
		void *	lockobj,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

static

Definition at line 681 of file astobj2.c.

References __ast_calloc(), __LOG_DEBUG, __LOG_ERROR, AO2_ALLOC_OPT_LOCK_MASK, AO2_ALLOC_OPT_LOCK_MUTEX, AO2_ALLOC_OPT_LOCK_NOLOCK, AO2_ALLOC_OPT_LOCK_OBJ, AO2_ALLOC_OPT_LOCK_RWLOCK, AO2_ALLOC_OPT_NO_REF_DEBUG, AO2_MAGIC, ao2_t_bump, ao2_t_ref, ast_atomic_fetchadd_int(), ast_get_tid(), ast_log, ast_mutex_init, ast_rwlock_init, __priv_data::destructor_fn, EXTERNAL_OBJ, ao2_lock_priv::lock, ao2_rwlock_priv::lock, ao2_lockobj_priv::lock, astobj2_lockobj::lockobj, __priv_data::magic, astobj2_lock::mutex, NULL, __priv_data::options, astobj2::priv_data, astobj2_lock::priv_data, astobj2_rwlock::priv_data, astobj2_lockobj::priv_data, __priv_data::ref_counter, ref_log, and astobj2_rwlock::rwlock.

Referenced by __ao2_alloc(), and __ao2_alloc_with_lockobj().

 {
  /* allocation */
  struct astobj2 *obj;
  struct astobj2_lock *obj_mutex;
  struct astobj2_rwlock *obj_rwlock;
  struct astobj2_lockobj *obj_lockobj;
  size_t overhead;
 
  switch (options & AO2_ALLOC_OPT_LOCK_MASK) {
  case AO2_ALLOC_OPT_LOCK_MUTEX:
  overhead = sizeof(*obj_mutex);
  obj_mutex = __ast_calloc(1, overhead + data_size, file, line, func);
  if (obj_mutex == NULL) {
  return NULL;
  }
 
  ast_mutex_init(&obj_mutex->mutex.lock);
  obj = (struct astobj2 *) &obj_mutex->priv_data;
  break;
  case AO2_ALLOC_OPT_LOCK_RWLOCK:
  overhead = sizeof(*obj_rwlock);
  obj_rwlock = __ast_calloc(1, overhead + data_size, file, line, func);
  if (obj_rwlock == NULL) {
  return NULL;
  }
 
  ast_rwlock_init(&obj_rwlock->rwlock.lock);
  obj = (struct astobj2 *) &obj_rwlock->priv_data;
  break;
  case AO2_ALLOC_OPT_LOCK_NOLOCK:
  overhead = sizeof(*obj);
  obj = __ast_calloc(1, overhead + data_size, file, line, func);
  if (obj == NULL) {
  return NULL;
  }
  break;
  case AO2_ALLOC_OPT_LOCK_OBJ:
  lockobj = ao2_t_bump(lockobj, "set lockobj");
  if (!lockobj) {
  ast_log(__LOG_ERROR, file, line, func, "AO2_ALLOC_OPT_LOCK_OBJ requires a non-NULL lockobj.\n");
  return NULL;
  }
 
  overhead = sizeof(*obj_lockobj);
  obj_lockobj = __ast_calloc(1, overhead + data_size, file, line, func);
  if (obj_lockobj == NULL) {
  ao2_t_ref(lockobj, -1, "release lockobj for failed alloc");
  return NULL;
  }
 
  obj_lockobj->lockobj.lock = lockobj;
  obj = (struct astobj2 *) &obj_lockobj->priv_data;
  break;
  default:
  /* Invalid option value. */
  ast_log(__LOG_DEBUG, file, line, func, "Invalid lock option requested\n");
  return NULL;
  }
 
  /* Initialize common ao2 values. */
  obj->priv_data.destructor_fn = destructor_fn; /* can be NULL */
  obj->priv_data.ref_counter = 1;
  obj->priv_data.options = options;
  obj->priv_data.magic = AO2_MAGIC;
 
 #ifdef AO2_DEBUG
  obj->priv_data.data_size = data_size;
  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
 
  if (ref_log && !(obj->priv_data.options & AO2_ALLOC_OPT_NO_REF_DEBUG)) {
  fprintf(ref_log, "%p,+1,%d,%s,%d,%s,**constructor**%zu**%zu**,%s\n",
  EXTERNAL_OBJ(obj), ast_get_tid(), file, line, func, overhead, data_size, tag ?: "");
  fflush(ref_log);
  }
 
  /* return a pointer to the user data */
  return EXTERNAL_OBJ(obj);
 }

◆ internal_is_ao2_object()

int internal_is_ao2_object ( void * user_data )

Definition at line 193 of file astobj2.c.

References INTERNAL_OBJ, and IS_AO2_MAGIC_BAD.

 {
  struct astobj2 *p;
 
  if (!user_data) {
  return 0;
  }
 
  p = INTERNAL_OBJ(user_data);
 
  return !p || IS_AO2_MAGIC_BAD(p) ? 0 : 1;
 }

◆ log_bad_ao2()

void log_bad_ao2	(	void *	user_data,
		const char *	file,
		int	line,
		const char *	func
	)

Definition at line 206 of file astobj2.c.

References __ast_assert_failed(), INTERNAL_OBJ, __priv_data::magic, and astobj2::priv_data.

 {
  struct astobj2 *p;
  char bad_magic[100];
 
  if (!user_data) {
  __ast_assert_failed(0, "user_data is NULL", file, line, func);
  return;
  }
 
  p = INTERNAL_OBJ(user_data);
  snprintf(bad_magic, sizeof(bad_magic), "bad magic number 0x%x for object %p",
  p->priv_data.magic, user_data);
  __ast_assert_failed(0, bad_magic, file, line, func);
 }

Variable Documentation

◆ ref_log

FILE* ref_log

static

Definition at line 44 of file astobj2.c.

Referenced by __ao2_lock(), __ao2_ref(), __ao2_trylock(), astobj2_cleanup(), astobj2_init(), and internal_ao2_alloc().

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ __INTERNAL_OBJ_CHECK

◆ AO2_MAGIC

◆ AO2_WEAK

◆ ast_log

◆ DEBUG_THREADS_LOOSE_ABI

◆ EXCESSIVE_REF_COUNT

◆ EXTERNAL_OBJ

◆ INTERNAL_OBJ

◆ INTERNAL_OBJ_CHECK

◆ INTERNAL_OBJ_LOCKOBJ

◆ INTERNAL_OBJ_MUTEX

◆ INTERNAL_OBJ_RWLOCK

◆ IS_AO2_MAGIC_BAD

Function Documentation

◆ __adjust_lock()

◆ __ao2_alloc()

◆ __ao2_alloc_with_lockobj()

◆ __ao2_cleanup()

◆ __ao2_cleanup_debug()

◆ __ao2_get_weakproxy()

◆ __ao2_lock()

◆ __ao2_ref()

◆ __ao2_trylock()

◆ __ao2_unlock()

◆ __ao2_weakproxy_alloc()

◆ __ao2_weakproxy_get_object()

◆ __ao2_weakproxy_ref_object()

◆ __ao2_weakproxy_set_object()

◆ ao2_object_get_lockaddr()

◆ ao2_options_get()

◆ ao2_weakproxy_subscribe()

◆ ao2_weakproxy_unsubscribe()

◆ astobj2_cleanup()

◆ astobj2_init()

◆ internal_ao2_alloc()

◆ internal_is_ao2_object()

◆ log_bad_ao2()

Variable Documentation

◆ ref_log