astobj2_hash.c File Reference

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 1079 of file astobj2_hash.c.

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

Referenced by __ao2_container_alloc_list(), and hash_ao2_alloc_empty_clone().

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

__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 1097 of file astobj2_hash.c.

References __ao2_container_alloc_hash(), and NULL.

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

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.

References __ao2_container_alloc_hash(), __is_ao2_object, ao2_options_get(), and NULL.

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

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 1057 of file astobj2_hash.c.

References ast_atomic_fetchadd_int(), ao2_container::cmp_fn, hash_zero(), NULL, options, ao2_container::sort_fn, and v_table_hash.

Referenced by __ao2_container_alloc_hash().

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

hash_ao2_destroy()

static void hash_ao2_destroy ( struct ao2_container_hash *  self )

static

Definition at line 739 of file astobj2_hash.c.

References abs, ao2_container_count(), ast_assert, AST_DLLIST_EMPTY, AST_DLLIST_FIRST, AST_DLLIST_LAST, AST_DLLIST_NEXT, AST_DLLIST_PREV, ast_log, hash_bucket_node::common, FORMAT, FORMAT2, hash_bucket_node::links, LOG_ERROR, hash_bucket_node::my_bucket, NULL, ao2_container_node::obj, and OBJ_SEARCH_OBJECT.

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

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 335 of file astobj2_hash.c.

References abs, ao2_ref, hash_traversal_state::arg, AST_DLLIST_FIRST, AST_DLLIST_LAST, AST_DLLIST_NEXT, AST_DLLIST_PREV, hash_traversal_state::bucket_last, hash_traversal_state::bucket_start, hash_bucket_node::common, hash_traversal_state::descending, hash_traversal_state::flags, hash_bucket_node::links, NULL, ao2_container_node::obj, 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 hash_traversal_state::sort_fn.

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

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 483 of file astobj2_hash.c.

References ao2_ref, hash_traversal_state::arg, AST_DLLIST_FIRST, AST_DLLIST_LAST, AST_DLLIST_NEXT, AST_DLLIST_PREV, hash_traversal_state::bucket_last, hash_bucket_node::common, hash_traversal_state::descending, hash_traversal_state::flags, hash_bucket_node::links, hash_bucket_node::my_bucket, NULL, ao2_container_node::obj, OBJ_SEARCH_MASK, and hash_traversal_state::sort_fn.

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

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 239 of file astobj2_hash.c.

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, hash_bucket_node::common, hash_bucket_node::links, hash_bucket::list, hash_bucket_node::my_bucket, ao2_container_node::obj, OBJ_SEARCH_OBJECT, options, and SWAP.

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

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 613 of file astobj2_hash.c.

References AO2_ITERATOR_DESCENDING, AST_DLLIST_FIRST, AST_DLLIST_LAST, AST_DLLIST_NEXT, AST_DLLIST_PREV, hash_bucket_node::common, hash_bucket_node::links, hash_bucket_node::my_bucket, NULL, and ao2_container_node::obj.

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

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 208 of file astobj2_hash.c.

References __ao2_ref(), abs, AO2_ALLOC_OPT_LOCK_NOLOCK, AO2_ALLOC_OPT_NO_REF_DEBUG, ao2_alloc_options, hash_bucket_node::common, hash_ao2_node_destructor(), hash_bucket_node::my_bucket, ao2_container_node::my_container, NULL, ao2_container_node::obj, and OBJ_SEARCH_OBJECT.

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

hash_ao2_node_destructor()

static void hash_ao2_node_destructor ( void *  v_doomed )

static

Definition at line 145 of file astobj2_hash.c.

References __adjust_lock(), __container_unlink_node, ao2_container_check(), AO2_DEVMODE_STAT, AO2_LOCK_REQ_WRLOCK, AO2_UNLINK_NODE_UNLINK_OBJECT, AST_DEVMODE, AST_DLLIST_REMOVE, ast_log, ao2_container_hash::buckets, ao2_container_hash::common, hash_bucket_node::common, ao2_container::destroying, is_ao2_object, ao2_container_node::is_linked, hash_bucket_node::links, 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().

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

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.

Returns

0

Definition at line 1040 of file astobj2_hash.c.

Referenced by hash_ao2_container_init().

{
 return 0;
}

Variable Documentation

v_table_hash

const struct ao2_container_methods v_table_hash

static

Hash container virtual method table.

Definition at line 1014 of file astobj2_hash.c.

Referenced by hash_ao2_container_init().