Hash table functions implementing astobj2 containers. More...

#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/astobj2.h"
#include "astobj2_private.h"
#include "astobj2_container_private.h"
#include "asterisk/dlinkedlists.h"
#include "asterisk/utils.h"

Include dependency graph for astobj2_hash.c:

Go to the source code of this file.

Data Structures
struct	ao2_container_hash

struct	hash_bucket

struct	hash_bucket_node

struct	hash_traversal_state

struct	hash_traversal_state_check

Functions
struct ao2_container *	__ao2_container_alloc_hash (unsigned int ao2_options, unsigned int container_options, unsigned int n_buckets, ao2_hash_fn hash_fn, ao2_sort_fn sort_fn, ao2_callback_fn cmp_fn, const char tag, const char file, int line, const char func)

struct ao2_container *	__ao2_container_alloc_list (unsigned int ao2_options, unsigned int container_options, ao2_sort_fn sort_fn, ao2_callback_fn cmp_fn, const char tag, const char file, int line, const char *func)

static struct ao2_container *	hash_ao2_alloc_empty_clone (struct ao2_container_hash self, const char tag, const char file, int line, const char func)

static struct ao2_container *	hash_ao2_container_init (struct ao2_container_hash self, unsigned int options, unsigned int n_buckets, ao2_hash_fn hash_fn, ao2_sort_fn sort_fn, ao2_callback_fn cmp_fn)
	Initialize a hash container with the desired number of buckets. More...

static void	hash_ao2_destroy (struct ao2_container_hash *self)

static struct hash_bucket_node *	hash_ao2_find_first (struct ao2_container_hash self, enum search_flags flags, void arg, struct hash_traversal_state *state)

static struct hash_bucket_node *	hash_ao2_find_next (struct ao2_container_hash self, struct hash_traversal_state state, struct hash_bucket_node *prev)

static enum ao2_container_insert	hash_ao2_insert_node (struct ao2_container_hash self, struct hash_bucket_node node)

static struct hash_bucket_node *	hash_ao2_iterator_next (struct ao2_container_hash self, struct hash_bucket_node node, enum ao2_iterator_flags flags)

static struct hash_bucket_node *	hash_ao2_new_node (struct ao2_container_hash self, void obj_new, const char tag, const char file, int line, const char *func)

static void	hash_ao2_node_destructor (void *v_doomed)

static int	hash_zero (const void *user_obj, const int flags)
	always zero hash function More...

Variables
static const struct ao2_container_methods	v_table_hash

Detailed Description

Hash table functions implementing astobj2 containers.

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

Definition in file astobj2_hash.c.

Function Documentation

◆ __ao2_container_alloc_hash()

struct ao2_container * __ao2_container_alloc_hash	(	unsigned int	ao2_options,
		unsigned int	container_options,
		unsigned int	n_buckets,
		ao2_hash_fn *	hash_fn,
		ao2_sort_fn *	sort_fn,
		ao2_callback_fn *	cmp_fn,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

Definition at line 1067 of file astobj2_hash.c.

{
    unsigned int num_buckets;
    size_t container_size;
    struct ao2_container_hash *self;
 
    num_buckets = hash_fn ? n_buckets : 1;
    container_size = sizeof(struct ao2_container_hash) + num_buckets * sizeof(struct hash_bucket);
 
    self = __ao2_alloc(container_size, container_destruct, ao2_options,
        tag ?: __PRETTY_FUNCTION__, file, line, func);
    return hash_ao2_container_init(self, container_options, num_buckets, hash_fn,
        sort_fn, cmp_fn);
}

References __ao2_alloc(), container_destruct(), make_ari_stubs::file, hash_ao2_container_init(), ao2_container_hash::hash_fn, and ao2_container_hash::n_buckets.

Referenced by __ao2_container_alloc_list(), and hash_ao2_alloc_empty_clone().

◆ __ao2_container_alloc_list()

struct ao2_container * __ao2_container_alloc_list	(	unsigned int	ao2_options,
		unsigned int	container_options,
		ao2_sort_fn *	sort_fn,
		ao2_callback_fn *	cmp_fn,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

Definition at line 1085 of file astobj2_hash.c.

{
    return __ao2_container_alloc_hash(ao2_options, container_options, 1, NULL,
        sort_fn, cmp_fn, tag, file, line, func);
}

References __ao2_container_alloc_hash(), ao2_container::cmp_fn, make_ari_stubs::file, NULL, and ao2_container::sort_fn.

◆ hash_ao2_alloc_empty_clone()

static struct ao2_container * hash_ao2_alloc_empty_clone	(	struct ao2_container_hash *	self,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

static

Definition at line 116 of file astobj2_hash.c.

{
    if (!__is_ao2_object(self, file, line, func)) {
        return NULL;
    }
 
    return __ao2_container_alloc_hash(ao2_options_get(self), self->common.options,
        self->n_buckets, self->hash_fn, self->common.sort_fn, self->common.cmp_fn,
        tag, file, line, func);
}

References __ao2_container_alloc_hash(), __is_ao2_object, ao2_options_get(), ao2_container::cmp_fn, ao2_container_hash::common, make_ari_stubs::file, ao2_container_hash::hash_fn, ao2_container_hash::n_buckets, NULL, ao2_container::options, and ao2_container::sort_fn.

◆ hash_ao2_container_init()

static struct ao2_container * hash_ao2_container_init	(	struct ao2_container_hash *	self,
		unsigned int	options,
		unsigned int	n_buckets,
		ao2_hash_fn *	hash_fn,
		ao2_sort_fn *	sort_fn,
		ao2_callback_fn *	cmp_fn
	)

static

Initialize a hash container with the desired number of buckets.

Parameters

self	Container to initialize.
options	Container behaviour options (See enum ao2_container_opts)
n_buckets	Number of buckets for hash
hash_fn	Pointer to a function computing a hash value.
sort_fn	Pointer to a sort function.
cmp_fn	Pointer to a compare function used by ao2_find.

Returns: A pointer to a struct container.

Definition at line 1045 of file astobj2_hash.c.

{
    if (!self) {
        return NULL;
    }
 
    self->common.v_table = &v_table_hash;
    self->common.sort_fn = sort_fn;
    self->common.cmp_fn = cmp_fn;
    self->common.options = options;
    self->hash_fn = hash_fn ? hash_fn : hash_zero;
    self->n_buckets = n_buckets;
 
#ifdef AO2_DEBUG
    ast_atomic_fetchadd_int(&ao2.total_containers, 1);
#endif  /* defined(AO2_DEBUG) */
 
    return (struct ao2_container *) self;
}

References ast_atomic_fetchadd_int(), ao2_container::cmp_fn, ao2_container_hash::common, ao2_container_hash::hash_fn, hash_zero(), ao2_container_hash::n_buckets, NULL, ao2_container::options, options, ao2_container::sort_fn, ao2_container::v_table, and v_table_hash.

Referenced by __ao2_container_alloc_hash().

◆ hash_ao2_destroy()

static void hash_ao2_destroy ( struct ao2_container_hash * self )

static

Definition at line 731 of file astobj2_hash.c.

{
    int idx;
 
    /* Check that the container no longer has any nodes */
    for (idx = self->n_buckets; idx--;) {
        if (!AST_DLLIST_EMPTY(&self->buckets[idx].list)) {
            ast_log(LOG_ERROR, "Node ref leak.  Hash container still has nodes!\n");
            ast_assert(0);
            break;
        }
    }
}

References ast_assert, AST_DLLIST_EMPTY, ast_log, ao2_container_hash::buckets, hash_bucket::list, LOG_ERROR, and ao2_container_hash::n_buckets.

◆ hash_ao2_find_first()

static struct hash_bucket_node * hash_ao2_find_first	(	struct ao2_container_hash *	self,
		enum search_flags	flags,
		void *	arg,
		struct hash_traversal_state *	state
	)

static

Definition at line 333 of file astobj2_hash.c.

{
    struct hash_bucket_node *node;
    int bucket_cur;
    int cmp;
 
    memset(state, 0, sizeof(*state));
    state->arg = arg;
    state->flags = flags;
 
    /* Determine traversal order. */
    switch (flags & OBJ_ORDER_MASK) {
    case OBJ_ORDER_POST:
    case OBJ_ORDER_DESCENDING:
        state->descending = 1;
        break;
    case OBJ_ORDER_PRE:
    case OBJ_ORDER_ASCENDING:
    default:
        break;
    }
 
    /*
     * If lookup by pointer or search key, run the hash and optional
     * sort functions.  Otherwise, traverse the whole container.
     */
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
    case OBJ_SEARCH_KEY:
        /* we know hash can handle this case */
        bucket_cur = abs(self->hash_fn(arg, flags & OBJ_SEARCH_MASK)
                % self->n_buckets);
        state->sort_fn = self->common.sort_fn;
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        /* scan all buckets for partial key matches */
        bucket_cur = -1;
        state->sort_fn = self->common.sort_fn;
        break;
    default:
        /* don't know, let's scan all buckets */
        bucket_cur = -1;
        state->sort_fn = NULL;
        break;
    }
 
    if (state->descending) {
        /*
         * Determine the search boundaries of a descending traversal.
         *
         * bucket_cur downto state->bucket_last
         */
        if (bucket_cur < 0) {
            bucket_cur = self->n_buckets - 1;
            state->bucket_last = 0;
        } else {
            state->bucket_last = bucket_cur;
        }
        state->bucket_start = bucket_cur;
 
        /* For each bucket */
        for (; state->bucket_last <= bucket_cur; --bucket_cur) {
            /* For each node in the bucket. */
            for (node = AST_DLLIST_LAST(&self->buckets[bucket_cur].list);
                node;
                node = AST_DLLIST_PREV(node, links)) {
                if (!node->common.obj) {
                    /* Node is empty */
                    continue;
                }
 
                if (state->sort_fn) {
                    /* Filter node through the sort_fn */
                    cmp = state->sort_fn(node->common.obj, arg, flags & OBJ_SEARCH_MASK);
                    if (cmp > 0) {
                        continue;
                    }
                    if (cmp < 0) {
                        /* No more nodes in this bucket are possible to match. */
                        break;
                    }
                }
 
                /* We have the first traversal node */
                ao2_ref(node, +1);
                return node;
            }
        }
    } else {
        /*
         * Determine the search boundaries of an ascending traversal.
         *
         * bucket_cur to state->bucket_last-1
         */
        if (bucket_cur < 0) {
            bucket_cur = 0;
            state->bucket_last = self->n_buckets;
        } else {
            state->bucket_last = bucket_cur + 1;
        }
        state->bucket_start = bucket_cur;
 
        /* For each bucket */
        for (; bucket_cur < state->bucket_last; ++bucket_cur) {
            /* For each node in the bucket. */
            for (node = AST_DLLIST_FIRST(&self->buckets[bucket_cur].list);
                node;
                node = AST_DLLIST_NEXT(node, links)) {
                if (!node->common.obj) {
                    /* Node is empty */
                    continue;
                }
 
                if (state->sort_fn) {
                    /* Filter node through the sort_fn */
                    cmp = state->sort_fn(node->common.obj, arg, flags & OBJ_SEARCH_MASK);
                    if (cmp < 0) {
                        continue;
                    }
                    if (cmp > 0) {
                        /* No more nodes in this bucket are possible to match. */
                        break;
                    }
                }
 
                /* We have the first traversal node */
                ao2_ref(node, +1);
                return node;
            }
        }
    }
 
    return NULL;
}

References abs, ao2_ref, AST_DLLIST_FIRST, AST_DLLIST_LAST, AST_DLLIST_NEXT, AST_DLLIST_PREV, ao2_container_hash::buckets, ao2_container_hash::common, ao2_container_hash::hash_fn, hash_bucket_node::links, hash_bucket::list, ao2_container_hash::n_buckets, NULL, OBJ_ORDER_ASCENDING, OBJ_ORDER_DESCENDING, OBJ_ORDER_MASK, OBJ_ORDER_POST, OBJ_ORDER_PRE, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, and ao2_container::sort_fn.

◆ hash_ao2_find_next()

static struct hash_bucket_node * hash_ao2_find_next	(	struct ao2_container_hash *	self,
		struct hash_traversal_state *	state,
		struct hash_bucket_node *	prev
	)

static

Definition at line 481 of file astobj2_hash.c.

{
    struct hash_bucket_node *node;
    void *arg;
    enum search_flags flags;
    int bucket_cur;
    int cmp;
 
    arg = state->arg;
    flags = state->flags;
    bucket_cur = prev->my_bucket;
    node = prev;
 
    /*
     * This function is structured the same as hash_ao2_find_first()
     * intentionally.  We are resuming the search loops from
     * hash_ao2_find_first() in order to find the next node.  The
     * search loops must be resumed where hash_ao2_find_first()
     * returned with the first node.
     */
    if (state->descending) {
        goto hash_descending_resume;
 
        /* For each bucket */
        for (; state->bucket_last <= bucket_cur; --bucket_cur) {
            /* For each node in the bucket. */
            for (node = AST_DLLIST_LAST(&self->buckets[bucket_cur].list);
                node;
                node = AST_DLLIST_PREV(node, links)) {
                if (!node->common.obj) {
                    /* Node is empty */
                    continue;
                }
 
                if (state->sort_fn) {
                    /* Filter node through the sort_fn */
                    cmp = state->sort_fn(node->common.obj, arg, flags & OBJ_SEARCH_MASK);
                    if (cmp > 0) {
                        continue;
                    }
                    if (cmp < 0) {
                        /* No more nodes in this bucket are possible to match. */
                        break;
                    }
                }
 
                /* We have the next traversal node */
                ao2_ref(node, +1);
 
                /*
                 * Dereferencing the prev node may result in our next node
                 * object being removed by another thread.  This could happen if
                 * the container uses RW locks and the container was read
                 * locked.
                 */
                ao2_ref(prev, -1);
                if (node->common.obj) {
                    return node;
                }
                prev = node;
 
hash_descending_resume:;
            }
        }
    } else {
        goto hash_ascending_resume;
 
        /* For each bucket */
        for (; bucket_cur < state->bucket_last; ++bucket_cur) {
            /* For each node in the bucket. */
            for (node = AST_DLLIST_FIRST(&self->buckets[bucket_cur].list);
                node;
                node = AST_DLLIST_NEXT(node, links)) {
                if (!node->common.obj) {
                    /* Node is empty */
                    continue;
                }
 
                if (state->sort_fn) {
                    /* Filter node through the sort_fn */
                    cmp = state->sort_fn(node->common.obj, arg, flags & OBJ_SEARCH_MASK);
                    if (cmp < 0) {
                        continue;
                    }
                    if (cmp > 0) {
                        /* No more nodes in this bucket are possible to match. */
                        break;
                    }
                }
 
                /* We have the next traversal node */
                ao2_ref(node, +1);
 
                /*
                 * Dereferencing the prev node may result in our next node
                 * object being removed by another thread.  This could happen if
                 * the container uses RW locks and the container was read
                 * locked.
                 */
                ao2_ref(prev, -1);
                if (node->common.obj) {
                    return node;
                }
                prev = node;
 
hash_ascending_resume:;
            }
        }
    }
 
    /* No more nodes in the container left to traverse. */
    ao2_ref(prev, -1);
    return NULL;
}

References ao2_ref, AST_DLLIST_FIRST, AST_DLLIST_LAST, AST_DLLIST_NEXT, AST_DLLIST_PREV, ao2_container_hash::buckets, hash_bucket_node::links, hash_bucket::list, hash_bucket_node::my_bucket, NULL, and OBJ_SEARCH_MASK.

◆ hash_ao2_insert_node()

static enum ao2_container_insert hash_ao2_insert_node	(	struct ao2_container_hash *	self,
		struct hash_bucket_node *	node
	)

static

Definition at line 237 of file astobj2_hash.c.

{
    int cmp;
    struct hash_bucket *bucket;
    struct hash_bucket_node *cur;
    ao2_sort_fn *sort_fn;
    uint32_t options;
 
    bucket = &self->buckets[node->my_bucket];
    sort_fn = self->common.sort_fn;
    options = self->common.options;
 
    if (options & AO2_CONTAINER_ALLOC_OPT_INSERT_BEGIN) {
        if (sort_fn) {
            AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN(&bucket->list, cur, links) {
                cmp = sort_fn(cur->common.obj, node->common.obj, OBJ_SEARCH_OBJECT);
                if (cmp > 0) {
                    continue;
                }
                if (cmp < 0) {
                    AST_DLLIST_INSERT_AFTER_CURRENT(node, links);
                    return AO2_CONTAINER_INSERT_NODE_INSERTED;
                }
                switch (options & AO2_CONTAINER_ALLOC_OPT_DUPS_MASK) {
                default:
                case AO2_CONTAINER_ALLOC_OPT_DUPS_ALLOW:
                    break;
                case AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT:
                    /* Reject all objects with the same key. */
                    return AO2_CONTAINER_INSERT_NODE_REJECTED;
                case AO2_CONTAINER_ALLOC_OPT_DUPS_OBJ_REJECT:
                    if (cur->common.obj == node->common.obj) {
                        /* Reject inserting the same object */
                        return AO2_CONTAINER_INSERT_NODE_REJECTED;
                    }
                    break;
                case AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE:
                    SWAP(cur->common.obj, node->common.obj);
                    ao2_ref(node, -1);
                    return AO2_CONTAINER_INSERT_NODE_OBJ_REPLACED;
                }
            }
            AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END;
        }
        AST_DLLIST_INSERT_HEAD(&bucket->list, node, links);
    } else {
        if (sort_fn) {
            AST_DLLIST_TRAVERSE_SAFE_BEGIN(&bucket->list, cur, links) {
                cmp = sort_fn(cur->common.obj, node->common.obj, OBJ_SEARCH_OBJECT);
                if (cmp < 0) {
                    continue;
                }
                if (cmp > 0) {
                    AST_DLLIST_INSERT_BEFORE_CURRENT(node, links);
                    return AO2_CONTAINER_INSERT_NODE_INSERTED;
                }
                switch (options & AO2_CONTAINER_ALLOC_OPT_DUPS_MASK) {
                default:
                case AO2_CONTAINER_ALLOC_OPT_DUPS_ALLOW:
                    break;
                case AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT:
                    /* Reject all objects with the same key. */
                    return AO2_CONTAINER_INSERT_NODE_REJECTED;
                case AO2_CONTAINER_ALLOC_OPT_DUPS_OBJ_REJECT:
                    if (cur->common.obj == node->common.obj) {
                        /* Reject inserting the same object */
                        return AO2_CONTAINER_INSERT_NODE_REJECTED;
                    }
                    break;
                case AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE:
                    SWAP(cur->common.obj, node->common.obj);
                    ao2_ref(node, -1);
                    return AO2_CONTAINER_INSERT_NODE_OBJ_REPLACED;
                }
            }
            AST_DLLIST_TRAVERSE_SAFE_END;
        }
        AST_DLLIST_INSERT_TAIL(&bucket->list, node, links);
    }
    return AO2_CONTAINER_INSERT_NODE_INSERTED;
}

References AO2_CONTAINER_ALLOC_OPT_DUPS_ALLOW, AO2_CONTAINER_ALLOC_OPT_DUPS_MASK, AO2_CONTAINER_ALLOC_OPT_DUPS_OBJ_REJECT, AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT, AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, AO2_CONTAINER_ALLOC_OPT_INSERT_BEGIN, AO2_CONTAINER_INSERT_NODE_INSERTED, AO2_CONTAINER_INSERT_NODE_OBJ_REPLACED, AO2_CONTAINER_INSERT_NODE_REJECTED, ao2_ref, AST_DLLIST_INSERT_AFTER_CURRENT, AST_DLLIST_INSERT_BEFORE_CURRENT, AST_DLLIST_INSERT_HEAD, AST_DLLIST_INSERT_TAIL, AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN, AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END, AST_DLLIST_TRAVERSE_SAFE_BEGIN, AST_DLLIST_TRAVERSE_SAFE_END, ao2_container_hash::buckets, hash_bucket_node::common, ao2_container_hash::common, hash_bucket_node::links, hash_bucket::list, ao2_container_node::obj, OBJ_SEARCH_OBJECT, ao2_container::options, options, ao2_container::sort_fn, and SWAP.

◆ hash_ao2_iterator_next()

static struct hash_bucket_node * hash_ao2_iterator_next	(	struct ao2_container_hash *	self,
		struct hash_bucket_node *	node,
		enum ao2_iterator_flags	flags
	)

static

Definition at line 611 of file astobj2_hash.c.

{
    int cur_bucket;
 
    if (flags & AO2_ITERATOR_DESCENDING) {
        if (node) {
            cur_bucket = node->my_bucket;
 
            /* Find next non-empty node. */
            for (;;) {
                node = AST_DLLIST_PREV(node, links);
                if (!node) {
                    break;
                }
                if (node->common.obj) {
                    /* Found a non-empty node. */
                    return node;
                }
            }
        } else {
            /* Find first non-empty node. */
            cur_bucket = self->n_buckets;
        }
 
        /* Find a non-empty node in the remaining buckets */
        while (0 <= --cur_bucket) {
            node = AST_DLLIST_LAST(&self->buckets[cur_bucket].list);
            while (node) {
                if (node->common.obj) {
                    /* Found a non-empty node. */
                    return node;
                }
                node = AST_DLLIST_PREV(node, links);
            }
        }
    } else {
        if (node) {
            cur_bucket = node->my_bucket;
 
            /* Find next non-empty node. */
            for (;;) {
                node = AST_DLLIST_NEXT(node, links);
                if (!node) {
                    break;
                }
                if (node->common.obj) {
                    /* Found a non-empty node. */
                    return node;
                }
            }
        } else {
            /* Find first non-empty node. */
            cur_bucket = -1;
        }
 
        /* Find a non-empty node in the remaining buckets */
        while (++cur_bucket < self->n_buckets) {
            node = AST_DLLIST_FIRST(&self->buckets[cur_bucket].list);
            while (node) {
                if (node->common.obj) {
                    /* Found a non-empty node. */
                    return node;
                }
                node = AST_DLLIST_NEXT(node, links);
            }
        }
    }
 
    /* No more nodes to visit in the container. */
    return NULL;
}

References AO2_ITERATOR_DESCENDING, AST_DLLIST_FIRST, AST_DLLIST_LAST, AST_DLLIST_NEXT, AST_DLLIST_PREV, ao2_container_hash::buckets, hash_bucket_node::links, hash_bucket::list, ao2_container_hash::n_buckets, and NULL.

◆ hash_ao2_new_node()

static struct hash_bucket_node * hash_ao2_new_node	(	struct ao2_container_hash *	self,
		void *	obj_new,
		const char *	tag,
		const char *	file,
		int	line,
		const char *	func
	)

static

Definition at line 206 of file astobj2_hash.c.

{
    struct hash_bucket_node *node;
    int i;
 
    node = ao2_alloc_options(sizeof(*node), hash_ao2_node_destructor,
        AO2_ALLOC_OPT_LOCK_NOLOCK | AO2_ALLOC_OPT_NO_REF_DEBUG);
    if (!node) {
        return NULL;
    }
 
    i = abs(self->hash_fn(obj_new, OBJ_SEARCH_OBJECT) % self->n_buckets);
 
    __ao2_ref(obj_new, +1, tag ?: "Container node creation", file, line, func);
    node->common.obj = obj_new;
    node->common.my_container = (struct ao2_container *) self;
    node->my_bucket = i;
 
    return node;
}

References __ao2_ref(), abs, AO2_ALLOC_OPT_LOCK_NOLOCK, AO2_ALLOC_OPT_NO_REF_DEBUG, ao2_alloc_options, make_ari_stubs::file, hash_ao2_node_destructor(), ao2_container_hash::hash_fn, ao2_container_hash::n_buckets, NULL, and OBJ_SEARCH_OBJECT.

◆ hash_ao2_node_destructor()

static void hash_ao2_node_destructor ( void * v_doomed )

static

Definition at line 143 of file astobj2_hash.c.

{
    struct hash_bucket_node *doomed = v_doomed;
 
    if (doomed->common.is_linked) {
        struct ao2_container_hash *my_container;
        struct hash_bucket *bucket;
 
        /*
         * Promote to write lock if not already there.  Since
         * adjust_lock() can potentially release and block waiting for a
         * write lock, care must be taken to ensure that node references
         * are released before releasing the container references.
         *
         * Node references held by an iterator can only be held while
         * the iterator also holds a reference to the container.  These
         * node references must be unreferenced before the container can
         * be unreferenced to ensure that the node will not get a
         * negative reference and the destructor called twice for the
         * same node.
         */
        my_container = (struct ao2_container_hash *) doomed->common.my_container;
#ifdef AST_DEVMODE
        is_ao2_object(my_container);
#endif
 
        __adjust_lock(my_container, AO2_LOCK_REQ_WRLOCK, 1);
 
#if defined(AO2_DEBUG)
        if (!my_container->common.destroying
            && ao2_container_check(doomed->common.my_container, OBJ_NOLOCK)) {
            ast_log(LOG_ERROR, "Container integrity failed before node deletion.\n");
        }
#endif  /* defined(AO2_DEBUG) */
        bucket = &my_container->buckets[doomed->my_bucket];
        AST_DLLIST_REMOVE(&bucket->list, doomed, links);
        AO2_DEVMODE_STAT(--my_container->common.nodes);
    }
 
    /*
     * We could have an object in the node if the container is being
     * destroyed or the node had not been linked in yet.
     */
    if (doomed->common.obj) {
        __container_unlink_node(&doomed->common, AO2_UNLINK_NODE_UNLINK_OBJECT);
    }
}

References __adjust_lock(), __container_unlink_node, ao2_container_check(), AO2_DEVMODE_STAT, AO2_LOCK_REQ_WRLOCK, AO2_UNLINK_NODE_UNLINK_OBJECT, AST_DLLIST_REMOVE, ast_log, ao2_container_hash::buckets, hash_bucket_node::common, ao2_container_hash::common, ao2_container::destroying, is_ao2_object, ao2_container_node::is_linked, hash_bucket::list, LOG_ERROR, hash_bucket_node::my_bucket, ao2_container_node::my_container, ao2_container_node::obj, and OBJ_NOLOCK.

Referenced by hash_ao2_new_node().

◆ hash_zero()

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

static

always zero hash function

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

Return values

0

Definition at line 1028 of file astobj2_hash.c.

{
    return 0;
}

Referenced by hash_ao2_container_init().

Variable Documentation

◆ v_table_hash

const struct ao2_container_methods v_table_hash

static

Hash container virtual method table.

Definition at line 1002 of file astobj2_hash.c.

Referenced by hash_ao2_container_init().

Data Structures

Functions

Variables

Detailed Description

Function Documentation

◆ __ao2_container_alloc_hash()

◆ __ao2_container_alloc_list()

◆ hash_ao2_alloc_empty_clone()

◆ hash_ao2_container_init()

◆ hash_ao2_destroy()

◆ hash_ao2_find_first()

◆ hash_ao2_find_next()

◆ hash_ao2_insert_node()

◆ hash_ao2_iterator_next()

◆ hash_ao2_new_node()

◆ hash_ao2_node_destructor()

◆ hash_zero()

Variable Documentation

◆ v_table_hash