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