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)

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)

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

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

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

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.

◆ AO2_MAGIC

#define AO2_MAGIC 0xa70b123

Definition at line 96 of file astobj2.c.

◆ AO2_WEAK

#define AO2_WEAK 0xa70b122

Definition at line 97 of file astobj2.c.

◆ ast_log

#define ast_log ast_log_safe

Examples: app_skel.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

◆ 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.

◆ INTERNAL_OBJ

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

Definition at line 163 of file astobj2.c.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

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.

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

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, astobj2_rwlock::rwlock, astobj2::user_data, and astobj2_lockobj::user_data.

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().

◆ __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 768 of file astobj2.c.

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

References make_ari_stubs::file, internal_ao2_alloc(), NULL, and options.

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

◆ __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 774 of file astobj2.c.

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

References AO2_ALLOC_OPT_LOCK_OBJ, make_ari_stubs::file, and internal_ao2_alloc().

◆ __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 677 of file astobj2.c.

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

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(), parking_set_duration(), and speech_observer_loaded().

◆ __ao2_cleanup_debug()

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

Definition at line 670 of file astobj2.c.

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

References __ao2_ref(), and make_ari_stubs::file.

◆ __ao2_get_weakproxy()

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

Definition at line 917 of file astobj2.c.

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

References __ao2_ref(), __INTERNAL_OBJ_CHECK, AO2_MAGIC, make_ari_stubs::file, __priv_data::magic, NULL, astobj2::priv_data, and __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.

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

References __ao2_lock(), __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, make_ari_stubs::file, 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, astobj2_rwlock::rwlock, astobj2::user_data, astobj2_lockobj::user_data, and var.

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

◆ __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.

{
    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;
    uint32_t privdataoptions;
    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;
    /* Save the options locally so the ref_log print at the end doesn't access freed data */
    privdataoptions = obj->priv_data.options;
 
    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 && !(privdataoptions & 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;
}

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, make_ari_stubs::file, 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, astobj2::user_data, 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(), hash_ao2_new_node(), internal_ao2_traverse(), and rb_ao2_new_node().

◆ __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.

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

References __ao2_trylock(), __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, make_ari_stubs::file, 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, astobj2_rwlock::rwlock, astobj2::user_data, astobj2_lockobj::user_data, and var.

Referenced by __ao2_trylock(), _ast_bridge_channel_trylock(), and _ast_bridge_trylock().

◆ __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.

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

References __ao2_unlock(), __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, make_ari_stubs::file, 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, astobj2_rwlock::rwlock, astobj2::user_data, astobj2_lockobj::user_data, and var.

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

◆ __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
	)

Definition at line 793 of file astobj2.c.

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

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

◆ __ao2_weakproxy_get_object()

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

Definition at line 889 of file astobj2.c.

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

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

Referenced by __ao2_weakproxy_find().

◆ __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
	)

Definition at line 862 of file astobj2.c.

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

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

◆ __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
	)

Definition at line 818 of file astobj2.c.

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

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

◆ 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.

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

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, astobj2::priv_data, and astobj2_lock::user_data.

Referenced by 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(), pbx_outgoing_attempt(), rtp_deallocate_transport(), sip_session_suspend_task(), stasis_subscription_join(), transaction_wait(), and wait_for_stimulus().

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

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

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().

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

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

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().

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

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

References ao2_lock, ao2_unlock, AO2_WEAK, ast_free, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ao2_weakproxy_notification::data, ao2_weakproxy::destroyed_cb, INTERNAL_OBJ_CHECK, ao2_weakproxy_notification::list, __priv_data::magic, OBJ_MULTIPLE, OBJ_NOLOCK, astobj2::priv_data, and sub.

Referenced by AST_TEST_DEFINE().

◆ astobj2_cleanup()

static void astobj2_cleanup ( void )

static

Definition at line 1157 of file astobj2.c.

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

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

Referenced by astobj2_init().

◆ astobj2_init()

int astobj2_init ( void )

Provided by astobj2.c

Definition at line 1169 of file astobj2.c.

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

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().

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

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

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, make_ari_stubs::file, 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, 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().

◆ internal_is_ao2_object()

int internal_is_ao2_object ( void * user_data )

Definition at line 193 of file astobj2.c.

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

References INTERNAL_OBJ, IS_AO2_MAGIC_BAD, and astobj2::user_data.

◆ 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.

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

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

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