astobj2: Remove legacy ao2_container_alloc routine.
Replace usage of ao2_container_alloc with ao2_container_alloc_hash or ao2_container_alloc_list. Remove ao2_container_alloc macro. Change-Id: I0907d78bc66efc775672df37c8faad00f2f6c088
This commit is contained in:
parent
b7af9c8b19
commit
021ce938ca
|
@ -4196,8 +4196,9 @@ static int load_module(void)
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Create a container to hold the conference bridges */
|
/* Create a container to hold the conference bridges */
|
||||||
conference_bridges = ao2_container_alloc(CONFERENCE_BRIDGE_BUCKETS,
|
conference_bridges = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
conference_bridge_hash_cb, conference_bridge_cmp_cb);
|
CONFERENCE_BRIDGE_BUCKETS,
|
||||||
|
conference_bridge_hash_cb, NULL, conference_bridge_cmp_cb);
|
||||||
if (!conference_bridges) {
|
if (!conference_bridges) {
|
||||||
unload_module();
|
unload_module();
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
|
|
|
@ -1624,8 +1624,14 @@ static struct ast_conference *build_conf(const char *confno, const char *pin,
|
||||||
|
|
||||||
ast_format_cap_append(cap_slin, ast_format_slin, 0);
|
ast_format_cap_append(cap_slin, ast_format_slin, 0);
|
||||||
/* Make a new one */
|
/* Make a new one */
|
||||||
if (!(cnf = ast_calloc(1, sizeof(*cnf))) ||
|
cnf = ast_calloc(1, sizeof(*cnf));
|
||||||
!(cnf->usercontainer = ao2_container_alloc(1, NULL, user_no_cmp))) {
|
if (!cnf) {
|
||||||
|
goto cnfout;
|
||||||
|
}
|
||||||
|
|
||||||
|
cnf->usercontainer = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
NULL, user_no_cmp);
|
||||||
|
if (!cnf->usercontainer) {
|
||||||
goto cnfout;
|
goto cnfout;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -7395,13 +7401,6 @@ static void sla_station_destructor(void *obj)
|
||||||
ast_string_field_free_memory(station);
|
ast_string_field_free_memory(station);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int sla_trunk_hash(const void *obj, const int flags)
|
|
||||||
{
|
|
||||||
const struct sla_trunk *trunk = obj;
|
|
||||||
|
|
||||||
return ast_str_case_hash(trunk->name);
|
|
||||||
}
|
|
||||||
|
|
||||||
static int sla_trunk_cmp(void *obj, void *arg, int flags)
|
static int sla_trunk_cmp(void *obj, void *arg, int flags)
|
||||||
{
|
{
|
||||||
struct sla_trunk *trunk = obj, *trunk2 = arg;
|
struct sla_trunk *trunk = obj, *trunk2 = arg;
|
||||||
|
@ -7409,13 +7408,6 @@ static int sla_trunk_cmp(void *obj, void *arg, int flags)
|
||||||
return !strcasecmp(trunk->name, trunk2->name) ? CMP_MATCH | CMP_STOP : 0;
|
return !strcasecmp(trunk->name, trunk2->name) ? CMP_MATCH | CMP_STOP : 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int sla_station_hash(const void *obj, const int flags)
|
|
||||||
{
|
|
||||||
const struct sla_station *station = obj;
|
|
||||||
|
|
||||||
return ast_str_case_hash(station->name);
|
|
||||||
}
|
|
||||||
|
|
||||||
static int sla_station_cmp(void *obj, void *arg, int flags)
|
static int sla_station_cmp(void *obj, void *arg, int flags)
|
||||||
{
|
{
|
||||||
struct sla_station *station = obj, *station2 = arg;
|
struct sla_station *station = obj, *station2 = arg;
|
||||||
|
@ -7869,8 +7861,10 @@ static int sla_load_config(int reload)
|
||||||
if (!reload) {
|
if (!reload) {
|
||||||
ast_mutex_init(&sla.lock);
|
ast_mutex_init(&sla.lock);
|
||||||
ast_cond_init(&sla.cond, NULL);
|
ast_cond_init(&sla.cond, NULL);
|
||||||
sla_trunks = ao2_container_alloc(1, sla_trunk_hash, sla_trunk_cmp);
|
sla_trunks = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
sla_stations = ao2_container_alloc(1, sla_station_hash, sla_station_cmp);
|
NULL, sla_trunk_cmp);
|
||||||
|
sla_stations = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
NULL, sla_station_cmp);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(cfg = ast_config_load(SLA_CONFIG_FILE, config_flags))) {
|
if (!(cfg = ast_config_load(SLA_CONFIG_FILE, config_flags))) {
|
||||||
|
|
|
@ -2800,10 +2800,11 @@ static void init_queue(struct call_queue *q)
|
||||||
q->autopausedelay = 0;
|
q->autopausedelay = 0;
|
||||||
if (!q->members) {
|
if (!q->members) {
|
||||||
if (q->strategy == QUEUE_STRATEGY_LINEAR || q->strategy == QUEUE_STRATEGY_RRORDERED) {
|
if (q->strategy == QUEUE_STRATEGY_LINEAR || q->strategy == QUEUE_STRATEGY_RRORDERED) {
|
||||||
/* linear strategy depends on order, so we have to place all members in a single bucket */
|
/* linear strategy depends on order, so we have to place all members in a list */
|
||||||
q->members = ao2_container_alloc(1, member_hash_fn, member_cmp_fn);
|
q->members = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, member_cmp_fn);
|
||||||
} else {
|
} else {
|
||||||
q->members = ao2_container_alloc(37, member_hash_fn, member_cmp_fn);
|
q->members = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
|
||||||
|
member_hash_fn, NULL, member_cmp_fn);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
q->found = 1;
|
q->found = 1;
|
||||||
|
@ -11240,13 +11241,14 @@ static int load_module(void)
|
||||||
struct stasis_topic *queue_topic;
|
struct stasis_topic *queue_topic;
|
||||||
struct stasis_topic *manager_topic;
|
struct stasis_topic *manager_topic;
|
||||||
|
|
||||||
queues = ao2_container_alloc(MAX_QUEUE_BUCKETS, queue_hash_cb, queue_cmp_cb);
|
queues = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_QUEUE_BUCKETS,
|
||||||
|
queue_hash_cb, NULL, queue_cmp_cb);
|
||||||
if (!queues) {
|
if (!queues) {
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
||||||
pending_members = ao2_container_alloc(
|
pending_members = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
MAX_CALL_ATTEMPT_BUCKETS, pending_members_hash, pending_members_cmp);
|
MAX_CALL_ATTEMPT_BUCKETS, pending_members_hash, NULL, pending_members_cmp);
|
||||||
if (!pending_members) {
|
if (!pending_members) {
|
||||||
unload_module();
|
unload_module();
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
|
|
|
@ -580,7 +580,9 @@ static void *skel_config_alloc(void)
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(cfg->levels = ao2_container_alloc(LEVEL_BUCKETS, skel_level_hash, skel_level_cmp))) {
|
cfg->levels = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, LEVEL_BUCKETS,
|
||||||
|
skel_level_hash, NULL, skel_level_cmp);
|
||||||
|
if (!cfg->levels) {
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -725,7 +727,9 @@ static int load_module(void)
|
||||||
if (aco_info_init(&cfg_info)) {
|
if (aco_info_init(&cfg_info)) {
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
if (!(games = ao2_container_alloc(1, NULL, NULL))) {
|
|
||||||
|
games = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
|
||||||
|
if (!games) {
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -15066,11 +15066,14 @@ static int load_module(void)
|
||||||
my_umask = umask(0);
|
my_umask = umask(0);
|
||||||
umask(my_umask);
|
umask(my_umask);
|
||||||
|
|
||||||
if (!(inprocess_container = ao2_container_alloc(573, inprocess_hash_fn, inprocess_cmp_fn))) {
|
inprocess_container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 573,
|
||||||
|
inprocess_hash_fn, NULL, inprocess_cmp_fn);
|
||||||
|
if (!inprocess_container) {
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
||||||
poll_list = ao2_container_alloc(POLL_LIST_BUCKETS, poll_state_hash_fn, poll_state_cmp_fn);
|
poll_list = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, POLL_LIST_BUCKETS,
|
||||||
|
poll_state_hash_fn, NULL, poll_state_cmp_fn);
|
||||||
if (!poll_list) {
|
if (!poll_list) {
|
||||||
ast_log(LOG_ERROR, "Unable to create poll_list container\n");
|
ast_log(LOG_ERROR, "Unable to create poll_list container\n");
|
||||||
ao2_cleanup(inprocess_container);
|
ao2_cleanup(inprocess_container);
|
||||||
|
|
|
@ -1987,15 +1987,21 @@ void *confbridge_cfg_alloc(void)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(cfg->user_profiles = ao2_container_alloc(283, user_hash_cb, user_cmp_cb))) {
|
cfg->user_profiles = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 283,
|
||||||
|
user_hash_cb, NULL, user_cmp_cb);
|
||||||
|
if (!cfg->user_profiles) {
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(cfg->bridge_profiles = ao2_container_alloc(283, bridge_hash_cb, bridge_cmp_cb))) {
|
cfg->bridge_profiles = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 283,
|
||||||
|
bridge_hash_cb, NULL, bridge_cmp_cb);
|
||||||
|
if (!cfg->bridge_profiles) {
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(cfg->menus = ao2_container_alloc(283, menu_hash_cb, menu_cmp_cb))) {
|
cfg->menus = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 283,
|
||||||
|
menu_hash_cb, NULL, menu_cmp_cb);
|
||||||
|
if (!cfg->menus) {
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -1534,7 +1534,9 @@ static int load_module(void)
|
||||||
|
|
||||||
init_pvt(&globals, NULL);
|
init_pvt(&globals, NULL);
|
||||||
|
|
||||||
if (!(pvts = ao2_container_alloc(NUM_PVT_BUCKETS, pvt_hash_cb, pvt_cmp_cb)))
|
pvts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NUM_PVT_BUCKETS,
|
||||||
|
pvt_hash_cb, NULL, pvt_cmp_cb);
|
||||||
|
if (!pvts)
|
||||||
goto return_error;
|
goto return_error;
|
||||||
|
|
||||||
if (load_config(0))
|
if (load_config(0))
|
||||||
|
|
|
@ -14714,23 +14714,54 @@ static int load_objects(void)
|
||||||
peers = users = iax_peercallno_pvts = iax_transfercallno_pvts = NULL;
|
peers = users = iax_peercallno_pvts = iax_transfercallno_pvts = NULL;
|
||||||
peercnts = callno_limits = calltoken_ignores = NULL;
|
peercnts = callno_limits = calltoken_ignores = NULL;
|
||||||
|
|
||||||
if (!(peers = ao2_container_alloc(MAX_PEER_BUCKETS, peer_hash_cb, peer_cmp_cb))) {
|
peers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_PEER_BUCKETS,
|
||||||
|
peer_hash_cb, NULL, peer_cmp_cb);
|
||||||
|
if (!peers) {
|
||||||
goto container_fail;
|
goto container_fail;
|
||||||
} else if (!(users = ao2_container_alloc(MAX_USER_BUCKETS, user_hash_cb, user_cmp_cb))) {
|
}
|
||||||
|
|
||||||
|
users = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_USER_BUCKETS,
|
||||||
|
user_hash_cb, NULL, user_cmp_cb);
|
||||||
|
if (!users) {
|
||||||
goto container_fail;
|
goto container_fail;
|
||||||
} else if (!(iax_peercallno_pvts = ao2_container_alloc(IAX_MAX_CALLS, pvt_hash_cb, pvt_cmp_cb))) {
|
}
|
||||||
|
|
||||||
|
iax_peercallno_pvts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
IAX_MAX_CALLS, pvt_hash_cb, NULL, pvt_cmp_cb);
|
||||||
|
if (!iax_peercallno_pvts) {
|
||||||
goto container_fail;
|
goto container_fail;
|
||||||
} else if (!(iax_transfercallno_pvts = ao2_container_alloc(IAX_MAX_CALLS, transfercallno_pvt_hash_cb, transfercallno_pvt_cmp_cb))) {
|
}
|
||||||
|
|
||||||
|
iax_transfercallno_pvts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
IAX_MAX_CALLS, transfercallno_pvt_hash_cb, NULL, transfercallno_pvt_cmp_cb);
|
||||||
|
if (!iax_transfercallno_pvts) {
|
||||||
goto container_fail;
|
goto container_fail;
|
||||||
} else if (!(peercnts = ao2_container_alloc(MAX_PEER_BUCKETS, peercnt_hash_cb, peercnt_cmp_cb))) {
|
}
|
||||||
|
|
||||||
|
peercnts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_PEER_BUCKETS,
|
||||||
|
peercnt_hash_cb, NULL, peercnt_cmp_cb);
|
||||||
|
if (!peercnts) {
|
||||||
goto container_fail;
|
goto container_fail;
|
||||||
} else if (!(callno_limits = ao2_container_alloc(MAX_PEER_BUCKETS, addr_range_hash_cb, addr_range_cmp_cb))) {
|
}
|
||||||
|
|
||||||
|
callno_limits = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
MAX_PEER_BUCKETS, addr_range_hash_cb, NULL, addr_range_cmp_cb);
|
||||||
|
if (!callno_limits) {
|
||||||
goto container_fail;
|
goto container_fail;
|
||||||
} else if (!(calltoken_ignores = ao2_container_alloc(MAX_PEER_BUCKETS, addr_range_hash_cb, addr_range_cmp_cb))) {
|
}
|
||||||
|
|
||||||
|
calltoken_ignores = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
MAX_PEER_BUCKETS, addr_range_hash_cb, NULL, addr_range_cmp_cb);
|
||||||
|
if (!calltoken_ignores) {
|
||||||
goto container_fail;
|
goto container_fail;
|
||||||
} else if (create_callno_pools()) {
|
}
|
||||||
|
|
||||||
|
if (create_callno_pools()) {
|
||||||
goto container_fail;
|
goto container_fail;
|
||||||
} else if (!(transmit_processor = ast_taskprocessor_get("iax2_transmit", TPS_REF_DEFAULT))) {
|
}
|
||||||
|
|
||||||
|
transmit_processor = ast_taskprocessor_get("iax2_transmit", TPS_REF_DEFAULT);
|
||||||
|
if (!transmit_processor) {
|
||||||
goto container_fail;
|
goto container_fail;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -471,7 +471,9 @@ static struct jingle_endpoint_state *jingle_endpoint_state_create(void)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(state->sessions = ao2_container_alloc(SESSION_BUCKETS, jingle_session_hash, jingle_session_cmp))) {
|
state->sessions = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
SESSION_BUCKETS, jingle_session_hash, NULL, jingle_session_cmp);
|
||||||
|
if (!state->sessions) {
|
||||||
ao2_ref(state, -1);
|
ao2_ref(state, -1);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
@ -601,7 +603,9 @@ static void *jingle_config_alloc(void)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(cfg->endpoints = ao2_container_alloc(ENDPOINT_BUCKETS, jingle_endpoint_hash, jingle_endpoint_cmp))) {
|
cfg->endpoints = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
ENDPOINT_BUCKETS, jingle_endpoint_hash, NULL, jingle_endpoint_cmp);
|
||||||
|
if (!cfg->endpoints) {
|
||||||
ao2_ref(cfg, -1);
|
ao2_ref(cfg, -1);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1815,8 +1815,9 @@ static int initialize_escs(void)
|
||||||
{
|
{
|
||||||
int i, res = 0;
|
int i, res = 0;
|
||||||
for (i = 0; i < ARRAY_LEN(event_state_compositors); i++) {
|
for (i = 0; i < ARRAY_LEN(event_state_compositors); i++) {
|
||||||
if (!((event_state_compositors[i].compositor) =
|
event_state_compositors[i].compositor = ao2_container_alloc_hash(
|
||||||
ao2_container_alloc(ESC_MAX_BUCKETS, esc_hash_fn, esc_cmp_fn))) {
|
AO2_ALLOC_OPT_LOCK_MUTEX, 0, ESC_MAX_BUCKETS, esc_hash_fn, NULL, esc_cmp_fn);
|
||||||
|
if (!event_state_compositors[i].compositor) {
|
||||||
res = -1;
|
res = -1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -35548,7 +35549,9 @@ static int load_module(void)
|
||||||
unload_module();
|
unload_module();
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
if (!(sip_monitor_instances = ao2_container_alloc(37, sip_monitor_instance_hash_fn, sip_monitor_instance_cmp_fn))) {
|
sip_monitor_instances = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
|
||||||
|
sip_monitor_instance_hash_fn, NULL, sip_monitor_instance_cmp_fn);
|
||||||
|
if (!sip_monitor_instances) {
|
||||||
unload_module();
|
unload_module();
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
|
@ -813,7 +813,9 @@ static const char *ustmtext(const char *str, struct unistimsession *pte)
|
||||||
char tmp[1024], *p, *p_orig = NULL, *p_trans = NULL;
|
char tmp[1024], *p, *p_orig = NULL, *p_trans = NULL;
|
||||||
FILE *f;
|
FILE *f;
|
||||||
|
|
||||||
if (!(lang->trans = ao2_container_alloc(8, lang_hash_fn, lang_cmp_fn))) {
|
lang->trans = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 8,
|
||||||
|
lang_hash_fn, NULL, lang_cmp_fn);
|
||||||
|
if (!lang->trans) {
|
||||||
ast_log(LOG_ERROR, "Unable to allocate container for translation!\n");
|
ast_log(LOG_ERROR, "Unable to allocate container for translation!\n");
|
||||||
return str;
|
return str;
|
||||||
}
|
}
|
||||||
|
|
|
@ -10133,8 +10133,8 @@ int sig_pri_load(const char *cc_type_name)
|
||||||
|
|
||||||
#if defined(HAVE_PRI_CCSS)
|
#if defined(HAVE_PRI_CCSS)
|
||||||
sig_pri_cc_type_name = cc_type_name;
|
sig_pri_cc_type_name = cc_type_name;
|
||||||
sig_pri_cc_monitors = ao2_container_alloc(37, sig_pri_cc_monitor_instance_hash_fn,
|
sig_pri_cc_monitors = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
|
||||||
sig_pri_cc_monitor_instance_cmp_fn);
|
sig_pri_cc_monitor_instance_hash_fn, NULL, sig_pri_cc_monitor_instance_cmp_fn);
|
||||||
if (!sig_pri_cc_monitors) {
|
if (!sig_pri_cc_monitors) {
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
|
@ -221,7 +221,8 @@ static int dialgroup_write(struct ast_channel *chan, const char *cmd, char *data
|
||||||
grhead = ao2_alloc(sizeof(*grhead), group_destroy);
|
grhead = ao2_alloc(sizeof(*grhead), group_destroy);
|
||||||
if (!grhead)
|
if (!grhead)
|
||||||
return -1;
|
return -1;
|
||||||
grhead->entries = ao2_container_alloc(37, entry_hash_fn, entry_cmp_fn);
|
grhead->entries = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
|
||||||
|
entry_hash_fn, NULL, entry_cmp_fn);
|
||||||
if (!grhead->entries) {
|
if (!grhead->entries) {
|
||||||
ao2_ref(grhead, -1);
|
ao2_ref(grhead, -1);
|
||||||
return -1;
|
return -1;
|
||||||
|
@ -236,7 +237,9 @@ static int dialgroup_write(struct ast_channel *chan, const char *cmd, char *data
|
||||||
|
|
||||||
/* Remove all existing */
|
/* Remove all existing */
|
||||||
ao2_ref(grhead->entries, -1);
|
ao2_ref(grhead->entries, -1);
|
||||||
if (!(grhead->entries = ao2_container_alloc(37, entry_hash_fn, entry_cmp_fn))) {
|
grhead->entries = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
|
||||||
|
entry_hash_fn, NULL, entry_cmp_fn);
|
||||||
|
if (!grhead->entries) {
|
||||||
ao2_unlink(group_container, grhead);
|
ao2_unlink(group_container, grhead);
|
||||||
ao2_ref(grhead, -1);
|
ao2_ref(grhead, -1);
|
||||||
return -1;
|
return -1;
|
||||||
|
@ -297,7 +300,9 @@ static int load_module(void)
|
||||||
struct ast_db_entry *dbtree, *tmp;
|
struct ast_db_entry *dbtree, *tmp;
|
||||||
char groupname[AST_MAX_EXTENSION], *ptr;
|
char groupname[AST_MAX_EXTENSION], *ptr;
|
||||||
|
|
||||||
if ((group_container = ao2_container_alloc(37, group_hash_fn, group_cmp_fn))) {
|
group_container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
|
||||||
|
group_hash_fn, NULL, group_cmp_fn);
|
||||||
|
if (group_container) {
|
||||||
/* Refresh groups from astdb */
|
/* Refresh groups from astdb */
|
||||||
if ((dbtree = ast_db_gettree("dialgroup", NULL))) {
|
if ((dbtree = ast_db_gettree("dialgroup", NULL))) {
|
||||||
for (tmp = dbtree; tmp; tmp = tmp->next) {
|
for (tmp = dbtree; tmp; tmp = tmp->next) {
|
||||||
|
|
|
@ -215,12 +215,6 @@ static void *lock_broker(void *unused)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int ast_channel_hash_cb(const void *obj, const int flags)
|
|
||||||
{
|
|
||||||
const struct ast_channel *chan = obj;
|
|
||||||
return ast_str_case_hash(ast_channel_name(chan));
|
|
||||||
}
|
|
||||||
|
|
||||||
static int ast_channel_cmp_cb(void *obj, void *arg, int flags)
|
static int ast_channel_cmp_cb(void *obj, void *arg, int flags)
|
||||||
{
|
{
|
||||||
struct ast_channel *chan = obj, *cmp_args = arg;
|
struct ast_channel *chan = obj, *cmp_args = arg;
|
||||||
|
@ -296,7 +290,9 @@ static int get_lock(struct ast_channel *chan, char *lockname, int trylock)
|
||||||
AST_LIST_UNLOCK(&locklist);
|
AST_LIST_UNLOCK(&locklist);
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
if (!(current->requesters = ao2_container_alloc(1, ast_channel_hash_cb, ast_channel_cmp_cb))) {
|
current->requesters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
NULL, ast_channel_cmp_cb);
|
||||||
|
if (!current->requesters) {
|
||||||
ast_mutex_destroy(¤t->mutex);
|
ast_mutex_destroy(¤t->mutex);
|
||||||
ast_cond_destroy(¤t->cond);
|
ast_cond_destroy(¤t->cond);
|
||||||
ast_free(current);
|
ast_free(current);
|
||||||
|
|
|
@ -1793,7 +1793,8 @@ static int load_module(void)
|
||||||
dsns = NULL;
|
dsns = NULL;
|
||||||
|
|
||||||
if (single_db_connection) {
|
if (single_db_connection) {
|
||||||
dsns = ao2_container_alloc(DSN_BUCKETS, dsn_hash, dsn_cmp);
|
dsns = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, DSN_BUCKETS,
|
||||||
|
dsn_hash, NULL, dsn_cmp);
|
||||||
if (!dsns) {
|
if (!dsns) {
|
||||||
ast_log(LOG_ERROR, "Could not initialize DSN container\n");
|
ast_log(LOG_ERROR, "Could not initialize DSN container\n");
|
||||||
ast_rwlock_unlock(&single_db_connection_lock);
|
ast_rwlock_unlock(&single_db_connection_lock);
|
||||||
|
@ -1891,7 +1892,8 @@ static int reload(void)
|
||||||
}
|
}
|
||||||
|
|
||||||
if (single_db_connection) {
|
if (single_db_connection) {
|
||||||
dsns = ao2_container_alloc(DSN_BUCKETS, dsn_hash, dsn_cmp);
|
dsns = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, DSN_BUCKETS,
|
||||||
|
dsn_hash, NULL, dsn_cmp);
|
||||||
if (!dsns) {
|
if (!dsns) {
|
||||||
ast_log(LOG_ERROR, "Could not initialize DSN container\n");
|
ast_log(LOG_ERROR, "Could not initialize DSN container\n");
|
||||||
ast_rwlock_unlock(&single_db_connection_lock);
|
ast_rwlock_unlock(&single_db_connection_lock);
|
||||||
|
|
|
@ -93,7 +93,8 @@ parameters. At the moment, this is done as follows:
|
||||||
|
|
||||||
struct ao2_container *c;
|
struct ao2_container *c;
|
||||||
|
|
||||||
c = ao2_container_alloc(MAX_BUCKETS, my_hash_fn, my_cmp_fn);
|
c = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_BUCKETS,
|
||||||
|
my_hash_fn, NULL, my_cmp_fn);
|
||||||
\endcode
|
\endcode
|
||||||
|
|
||||||
where
|
where
|
||||||
|
@ -109,7 +110,7 @@ A container knows little or nothing about the objects it stores,
|
||||||
other than the fact that they have been created by ao2_alloc().
|
other than the fact that they have been created by ao2_alloc().
|
||||||
All knowledge of the (user-defined) internals of the objects
|
All knowledge of the (user-defined) internals of the objects
|
||||||
is left to the (user-supplied) functions passed as arguments
|
is left to the (user-supplied) functions passed as arguments
|
||||||
to ao2_container_alloc().
|
to ao2_container_alloc_hash().
|
||||||
|
|
||||||
If we want to insert an object in a container, we should
|
If we want to insert an object in a container, we should
|
||||||
initialize its fields -- especially, those used by my_hash_fn() --
|
initialize its fields -- especially, those used by my_hash_fn() --
|
||||||
|
@ -936,20 +937,8 @@ and perform various operations on them.
|
||||||
Internally, objects are stored in lists, hash tables or other
|
Internally, objects are stored in lists, hash tables or other
|
||||||
data structures depending on the needs.
|
data structures depending on the needs.
|
||||||
|
|
||||||
\note NOTA BENE: at the moment the only container we support is the
|
|
||||||
hash table and its degenerate form, the list.
|
|
||||||
|
|
||||||
Operations on container include:
|
Operations on container include:
|
||||||
|
|
||||||
- c = \b ao2_container_alloc(size, hash_fn, cmp_fn)
|
|
||||||
allocate a container with desired size and default compare
|
|
||||||
and hash function
|
|
||||||
-The compare function returns an int, which
|
|
||||||
can be 0 for not found, CMP_STOP to stop end a traversal,
|
|
||||||
or CMP_MATCH if they are equal
|
|
||||||
-The hash function returns an int. The hash function
|
|
||||||
takes two argument, the object pointer and a flags field,
|
|
||||||
|
|
||||||
- \b ao2_find(c, arg, flags)
|
- \b ao2_find(c, arg, flags)
|
||||||
returns zero or more elements matching a given criteria
|
returns zero or more elements matching a given criteria
|
||||||
(specified as arg). 'c' is the container pointer. Flags
|
(specified as arg). 'c' is the container pointer. Flags
|
||||||
|
@ -1297,26 +1286,6 @@ typedef int (ao2_sort_fn)(const void *obj_left, const void *obj_right, int flags
|
||||||
/*@{ */
|
/*@{ */
|
||||||
struct ao2_container;
|
struct ao2_container;
|
||||||
|
|
||||||
/*!
|
|
||||||
* \deprecated
|
|
||||||
* \brief Allocate and initialize a hash container with the desired number of buckets.
|
|
||||||
*
|
|
||||||
* \details
|
|
||||||
* We allocate space for a struct astobj_container, struct container
|
|
||||||
* and the buckets[] array.
|
|
||||||
*
|
|
||||||
* \param n_buckets Number of buckets for hash
|
|
||||||
* \param hash_fn Pointer to a function computing a hash value. (NULL if everyting goes in first bucket.)
|
|
||||||
* \param cmp_fn Pointer to a compare function used by ao2_find. (NULL to match everything)
|
|
||||||
*
|
|
||||||
* \return A pointer to a struct container.
|
|
||||||
*
|
|
||||||
* \note Destructor is set implicitly.
|
|
||||||
* \note This is legacy container creation that is mapped to the new method.
|
|
||||||
*/
|
|
||||||
#define ao2_container_alloc(n_buckets, hash_fn, cmp_fn) \
|
|
||||||
ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, (n_buckets), (hash_fn), NULL, (cmp_fn))
|
|
||||||
|
|
||||||
/*!
|
/*!
|
||||||
* \brief Allocate and initialize a hash container with the desired number of buckets.
|
* \brief Allocate and initialize a hash container with the desired number of buckets.
|
||||||
*
|
*
|
||||||
|
|
10
main/cel.c
10
main/cel.c
|
@ -1561,15 +1561,16 @@ static int load_module(void)
|
||||||
{
|
{
|
||||||
struct ao2_container *container;
|
struct ao2_container *container;
|
||||||
|
|
||||||
container = ao2_container_alloc(NUM_APP_BUCKETS, cel_linkedid_hash_fn, cel_linkedid_cmp_fn);
|
container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
NUM_APP_BUCKETS, cel_linkedid_hash_fn, NULL, cel_linkedid_cmp_fn);
|
||||||
ao2_global_obj_replace_unref(cel_linkedids, container);
|
ao2_global_obj_replace_unref(cel_linkedids, container);
|
||||||
ao2_cleanup(container);
|
ao2_cleanup(container);
|
||||||
if (!container) {
|
if (!container) {
|
||||||
return AST_MODULE_LOAD_FAILURE;
|
return AST_MODULE_LOAD_FAILURE;
|
||||||
}
|
}
|
||||||
|
|
||||||
container = ao2_container_alloc(NUM_DIALSTATUS_BUCKETS,
|
container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
cel_dialstatus_hash_fn, cel_dialstatus_cmp_fn);
|
NUM_DIALSTATUS_BUCKETS, cel_dialstatus_hash_fn, NULL, cel_dialstatus_cmp_fn);
|
||||||
ao2_global_obj_replace_unref(cel_dialstatus_store, container);
|
ao2_global_obj_replace_unref(cel_dialstatus_store, container);
|
||||||
ao2_cleanup(container);
|
ao2_cleanup(container);
|
||||||
if (!container) {
|
if (!container) {
|
||||||
|
@ -1584,7 +1585,8 @@ static int load_module(void)
|
||||||
return AST_MODULE_LOAD_FAILURE;
|
return AST_MODULE_LOAD_FAILURE;
|
||||||
}
|
}
|
||||||
|
|
||||||
container = ao2_container_alloc(BACKEND_BUCKETS, cel_backend_hash_fn, cel_backend_cmp_fn);
|
container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, BACKEND_BUCKETS,
|
||||||
|
cel_backend_hash_fn, NULL, cel_backend_cmp_fn);
|
||||||
ao2_global_obj_replace_unref(cel_backends, container);
|
ao2_global_obj_replace_unref(cel_backends, container);
|
||||||
ao2_cleanup(container);
|
ao2_cleanup(container);
|
||||||
if (!container) {
|
if (!container) {
|
||||||
|
|
|
@ -7856,8 +7856,8 @@ static void channels_shutdown(void)
|
||||||
|
|
||||||
int ast_channels_init(void)
|
int ast_channels_init(void)
|
||||||
{
|
{
|
||||||
channels = ao2_container_alloc(NUM_CHANNEL_BUCKETS,
|
channels = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NUM_CHANNEL_BUCKETS,
|
||||||
ast_channel_hash_cb, ast_channel_cmp_cb);
|
ast_channel_hash_cb, NULL, ast_channel_cmp_cb);
|
||||||
if (!channels) {
|
if (!channels) {
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1302,7 +1302,9 @@ struct ast_channel *__ast_channel_internal_alloc(void (*destructor)(void *obj),
|
||||||
return ast_channel_unref(tmp);
|
return ast_channel_unref(tmp);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(tmp->dialed_causes = ao2_container_alloc(DIALED_CAUSES_BUCKETS, pvt_cause_hash_fn, pvt_cause_cmp_fn))) {
|
tmp->dialed_causes = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
DIALED_CAUSES_BUCKETS, pvt_cause_hash_fn, NULL, pvt_cause_cmp_fn);
|
||||||
|
if (!tmp->dialed_causes) {
|
||||||
return ast_channel_unref(tmp);
|
return ast_channel_unref(tmp);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -2536,7 +2536,8 @@ int ast_config_text_file_save2(const char *configfile, const struct ast_config *
|
||||||
struct ao2_container *fileset;
|
struct ao2_container *fileset;
|
||||||
struct inclfile *fi;
|
struct inclfile *fi;
|
||||||
|
|
||||||
fileset = ao2_container_alloc(1023, hash_string, hashtab_compare_strings);
|
fileset = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 1023,
|
||||||
|
hash_string, NULL, hashtab_compare_strings);
|
||||||
if (!fileset) {
|
if (!fileset) {
|
||||||
/* Container creation failed. */
|
/* Container creation failed. */
|
||||||
return -1;
|
return -1;
|
||||||
|
@ -4104,8 +4105,12 @@ int ast_config_hook_register(const char *name,
|
||||||
config_hook_cb hook_cb)
|
config_hook_cb hook_cb)
|
||||||
{
|
{
|
||||||
struct cfg_hook *hook;
|
struct cfg_hook *hook;
|
||||||
if (!cfg_hooks && !(cfg_hooks = ao2_container_alloc(17, hook_hash, hook_cmp))) {
|
if (!cfg_hooks) {
|
||||||
return -1;
|
cfg_hooks = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 17,
|
||||||
|
hook_hash, NULL, hook_cmp);
|
||||||
|
if (!cfg_hooks) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(hook = ao2_alloc(sizeof(*hook), hook_destroy))) {
|
if (!(hook = ao2_alloc(sizeof(*hook), hook_destroy))) {
|
||||||
|
|
|
@ -405,7 +405,8 @@ static struct aco_option *aco_option_find(struct aco_type *type, const char *nam
|
||||||
|
|
||||||
struct ao2_container *aco_option_container_alloc(void)
|
struct ao2_container *aco_option_container_alloc(void)
|
||||||
{
|
{
|
||||||
return ao2_container_alloc(CONFIG_OPT_BUCKETS, config_opt_hash, config_opt_cmp);
|
return ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, CONFIG_OPT_BUCKETS,
|
||||||
|
config_opt_hash, NULL, config_opt_cmp);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int internal_aco_type_category_check(struct aco_type *match, const char *category)
|
static int internal_aco_type_category_check(struct aco_type *match, const char *category)
|
||||||
|
|
|
@ -94,7 +94,8 @@ AO2_STRING_FIELD_CMP_FN(ast_datastore, uid);
|
||||||
|
|
||||||
struct ao2_container *ast_datastores_alloc(void)
|
struct ao2_container *ast_datastores_alloc(void)
|
||||||
{
|
{
|
||||||
return ao2_container_alloc(DATASTORE_BUCKETS, ast_datastore_hash_fn, ast_datastore_cmp_fn);
|
return ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
DATASTORE_BUCKETS, ast_datastore_hash_fn, NULL, ast_datastore_cmp_fn);
|
||||||
}
|
}
|
||||||
|
|
||||||
int ast_datastores_add(struct ao2_container *datastores, struct ast_datastore *datastore)
|
int ast_datastores_add(struct ao2_container *datastores, struct ast_datastore *datastore)
|
||||||
|
|
|
@ -482,14 +482,14 @@ int ast_endpoint_init(void)
|
||||||
{
|
{
|
||||||
ast_register_cleanup(endpoint_cleanup);
|
ast_register_cleanup(endpoint_cleanup);
|
||||||
|
|
||||||
endpoints = ao2_container_alloc(ENDPOINT_BUCKETS, ast_endpoint_hash_fn,
|
endpoints = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, ENDPOINT_BUCKETS,
|
||||||
ast_endpoint_cmp_fn);
|
ast_endpoint_hash_fn, NULL, ast_endpoint_cmp_fn);
|
||||||
if (!endpoints) {
|
if (!endpoints) {
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
tech_endpoints = ao2_container_alloc(TECH_ENDPOINT_BUCKETS, ast_endpoint_hash_fn,
|
tech_endpoints = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
ast_endpoint_cmp_fn);
|
TECH_ENDPOINT_BUCKETS, ast_endpoint_hash_fn, NULL, ast_endpoint_cmp_fn);
|
||||||
if (!tech_endpoints) {
|
if (!tech_endpoints) {
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1133,8 +1133,8 @@ static int unload_module(void)
|
||||||
/*! \brief Load indications module */
|
/*! \brief Load indications module */
|
||||||
static int load_module(void)
|
static int load_module(void)
|
||||||
{
|
{
|
||||||
ast_tone_zones = ao2_container_alloc(NUM_TONE_ZONE_BUCKETS,
|
ast_tone_zones = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
ast_tone_zone_hash, ast_tone_zone_cmp);
|
NUM_TONE_ZONE_BUCKETS, ast_tone_zone_hash, NULL, ast_tone_zone_cmp);
|
||||||
if (!ast_tone_zones) {
|
if (!ast_tone_zones) {
|
||||||
return AST_MODULE_LOAD_FAILURE;
|
return AST_MODULE_LOAD_FAILURE;
|
||||||
}
|
}
|
||||||
|
|
|
@ -2224,8 +2224,8 @@ static struct mansession_session *build_mansession(const struct ast_sockaddr *ad
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
newsession->whitefilters = ao2_container_alloc(1, NULL, NULL);
|
newsession->whitefilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
|
||||||
newsession->blackfilters = ao2_container_alloc(1, NULL, NULL);
|
newsession->blackfilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
|
||||||
if (!newsession->whitefilters || !newsession->blackfilters) {
|
if (!newsession->whitefilters || !newsession->blackfilters) {
|
||||||
ao2_ref(newsession, -1);
|
ao2_ref(newsession, -1);
|
||||||
return NULL;
|
return NULL;
|
||||||
|
@ -7639,7 +7639,8 @@ static void xml_translate(struct ast_str **out, char *in, struct ast_variable *g
|
||||||
if (xml) {
|
if (xml) {
|
||||||
ast_str_append(out, 0, "<response type='object' id='%s'><%s", dest, objtype);
|
ast_str_append(out, 0, "<response type='object' id='%s'><%s", dest, objtype);
|
||||||
}
|
}
|
||||||
vco = ao2_container_alloc(37, variable_count_hash_fn, variable_count_cmp_fn);
|
vco = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
|
||||||
|
variable_count_hash_fn, NULL, variable_count_cmp_fn);
|
||||||
inobj = 1;
|
inobj = 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -9067,7 +9068,7 @@ static int __init_manager(int reload, int by_external_config)
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* If you have a NULL hash fn, you only need a single bucket */
|
/* If you have a NULL hash fn, you only need a single bucket */
|
||||||
sessions = ao2_container_alloc(1, NULL, mansession_cmp_fn);
|
sessions = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, mansession_cmp_fn);
|
||||||
if (!sessions) {
|
if (!sessions) {
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
@ -9323,8 +9324,8 @@ static int __init_manager(int reload, int by_external_config)
|
||||||
/* Default allowmultiplelogin from [general] */
|
/* Default allowmultiplelogin from [general] */
|
||||||
user->allowmultiplelogin = allowmultiplelogin;
|
user->allowmultiplelogin = allowmultiplelogin;
|
||||||
user->writetimeout = 100;
|
user->writetimeout = 100;
|
||||||
user->whitefilters = ao2_container_alloc(1, NULL, NULL);
|
user->whitefilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
|
||||||
user->blackfilters = ao2_container_alloc(1, NULL, NULL);
|
user->blackfilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
|
||||||
if (!user->whitefilters || !user->blackfilters) {
|
if (!user->whitefilters || !user->blackfilters) {
|
||||||
manager_free_user(user);
|
manager_free_user(user);
|
||||||
break;
|
break;
|
||||||
|
|
|
@ -121,7 +121,8 @@ static struct media_info *media_info_alloc(const char *name)
|
||||||
|
|
||||||
memcpy(info->name, name, name_sz);
|
memcpy(info->name, name, name_sz);
|
||||||
|
|
||||||
info->variants = ao2_container_alloc(VARIANT_BUCKETS, media_variant_hash, media_variant_cmp);
|
info->variants = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
VARIANT_BUCKETS, media_variant_hash, NULL, media_variant_cmp);
|
||||||
if (!info->variants) {
|
if (!info->variants) {
|
||||||
ao2_ref(info, -1);
|
ao2_ref(info, -1);
|
||||||
|
|
||||||
|
@ -169,7 +170,8 @@ struct ast_media_index *ast_media_index_create(const char *base_dir)
|
||||||
|
|
||||||
memcpy(index->base_dir, base_dir, base_dir_sz);
|
memcpy(index->base_dir, base_dir, base_dir_sz);
|
||||||
|
|
||||||
index->index = ao2_container_alloc(INDEX_BUCKETS, media_info_hash, media_info_cmp);
|
index->index = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, INDEX_BUCKETS,
|
||||||
|
media_info_hash, NULL, media_info_cmp);
|
||||||
if (!index->index) {
|
if (!index->index) {
|
||||||
ao2_ref(index, -1);
|
ao2_ref(index, -1);
|
||||||
|
|
||||||
|
|
|
@ -367,12 +367,6 @@ static void msg_ds_destroy(void *data)
|
||||||
ao2_ref(msg, -1);
|
ao2_ref(msg, -1);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int msg_data_hash_fn(const void *obj, const int flags)
|
|
||||||
{
|
|
||||||
const struct msg_data *data = obj;
|
|
||||||
return ast_str_case_hash(data->name);
|
|
||||||
}
|
|
||||||
|
|
||||||
static int msg_data_cmp_fn(void *obj, void *arg, int flags)
|
static int msg_data_cmp_fn(void *obj, void *arg, int flags)
|
||||||
{
|
{
|
||||||
const struct msg_data *one = obj, *two = arg;
|
const struct msg_data *one = obj, *two = arg;
|
||||||
|
@ -406,7 +400,9 @@ struct ast_msg *ast_msg_alloc(void)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(msg->vars = ao2_container_alloc(1, msg_data_hash_fn, msg_data_cmp_fn))) {
|
msg->vars = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
NULL, msg_data_cmp_fn);
|
||||||
|
if (!msg->vars) {
|
||||||
ao2_ref(msg, -1);
|
ao2_ref(msg, -1);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
|
@ -131,7 +131,9 @@ static void *named_acl_config_alloc(void)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(cfg->named_acl_list = ao2_container_alloc(37, named_acl_hash_fn, named_acl_cmp_fn))) {
|
cfg->named_acl_list = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
|
||||||
|
named_acl_hash_fn, NULL, named_acl_cmp_fn);
|
||||||
|
if (!cfg->named_acl_list) {
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
10
main/pbx.c
10
main/pbx.c
|
@ -3953,7 +3953,7 @@ static int ast_add_hint(struct ast_exten *e)
|
||||||
AST_VECTOR_INIT(&hint_new->devices, 8);
|
AST_VECTOR_INIT(&hint_new->devices, 8);
|
||||||
|
|
||||||
/* Initialize new hint. */
|
/* Initialize new hint. */
|
||||||
hint_new->callbacks = ao2_container_alloc(1, NULL, hint_id_cmp);
|
hint_new->callbacks = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, hint_id_cmp);
|
||||||
if (!hint_new->callbacks) {
|
if (!hint_new->callbacks) {
|
||||||
ao2_ref(hint_new, -1);
|
ao2_ref(hint_new, -1);
|
||||||
return -1;
|
return -1;
|
||||||
|
@ -8912,11 +8912,13 @@ static void print_statecbs_key(void *v_obj, void *where, ao2_prnt_fn *prnt)
|
||||||
|
|
||||||
int ast_pbx_init(void)
|
int ast_pbx_init(void)
|
||||||
{
|
{
|
||||||
hints = ao2_container_alloc(HASH_EXTENHINT_SIZE, hint_hash, hint_cmp);
|
hints = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
HASH_EXTENHINT_SIZE, hint_hash, NULL, hint_cmp);
|
||||||
if (hints) {
|
if (hints) {
|
||||||
ao2_container_register("hints", hints, print_hints_key);
|
ao2_container_register("hints", hints, print_hints_key);
|
||||||
}
|
}
|
||||||
hintdevices = ao2_container_alloc(HASH_EXTENHINT_SIZE, hintdevice_hash_cb, hintdevice_cmp_multiple);
|
hintdevices = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
HASH_EXTENHINT_SIZE, hintdevice_hash_cb, NULL, hintdevice_cmp_multiple);
|
||||||
if (hintdevices) {
|
if (hintdevices) {
|
||||||
ao2_container_register("hintdevices", hintdevices, print_hintdevices_key);
|
ao2_container_register("hintdevices", hintdevices, print_hintdevices_key);
|
||||||
}
|
}
|
||||||
|
@ -8926,7 +8928,7 @@ int ast_pbx_init(void)
|
||||||
if (autohints) {
|
if (autohints) {
|
||||||
ao2_container_register("autohints", autohints, print_autohint_key);
|
ao2_container_register("autohints", autohints, print_autohint_key);
|
||||||
}
|
}
|
||||||
statecbs = ao2_container_alloc(1, NULL, statecbs_cmp);
|
statecbs = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, statecbs_cmp);
|
||||||
if (statecbs) {
|
if (statecbs) {
|
||||||
ao2_container_register("statecbs", statecbs, print_statecbs_key);
|
ao2_container_register("statecbs", statecbs, print_statecbs_key);
|
||||||
}
|
}
|
||||||
|
|
|
@ -1284,8 +1284,8 @@ struct stasis_topic_pool *stasis_topic_pool_create(struct stasis_topic *pooled_t
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
pool->pool_container = ao2_container_alloc(TOPIC_POOL_BUCKETS,
|
pool->pool_container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
topic_pool_entry_hash, topic_pool_entry_cmp);
|
TOPIC_POOL_BUCKETS, topic_pool_entry_hash, NULL, topic_pool_entry_cmp);
|
||||||
if (!pool->pool_container) {
|
if (!pool->pool_container) {
|
||||||
ao2_cleanup(pool);
|
ao2_cleanup(pool);
|
||||||
return NULL;
|
return NULL;
|
||||||
|
|
|
@ -615,8 +615,8 @@ struct ast_multi_channel_blob *ast_multi_channel_blob_create(struct ast_json *bl
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
obj->channel_snapshots = ao2_container_alloc(NUM_MULTI_CHANNEL_BLOB_BUCKETS,
|
obj->channel_snapshots = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
channel_role_hash_cb, channel_role_cmp_cb);
|
NUM_MULTI_CHANNEL_BLOB_BUCKETS, channel_role_hash_cb, NULL, channel_role_cmp_cb);
|
||||||
if (!obj->channel_snapshots) {
|
if (!obj->channel_snapshots) {
|
||||||
ao2_ref(obj, -1);
|
ao2_ref(obj, -1);
|
||||||
return NULL;
|
return NULL;
|
||||||
|
@ -719,8 +719,9 @@ struct ao2_container *ast_multi_channel_blob_get_channels(struct ast_multi_chann
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
ret_container = ao2_container_alloc(NUM_MULTI_CHANNEL_BLOB_BUCKETS,
|
ret_container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
channel_snapshot_hash_cb, channel_snapshot_cmp_cb);
|
NUM_MULTI_CHANNEL_BLOB_BUCKETS,
|
||||||
|
channel_snapshot_hash_cb, NULL, channel_snapshot_cmp_cb);
|
||||||
if (!ret_container) {
|
if (!ret_container) {
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
|
@ -278,7 +278,9 @@ static void tps_shutdown(void)
|
||||||
/* initialize the taskprocessor container and register CLI operations */
|
/* initialize the taskprocessor container and register CLI operations */
|
||||||
int ast_tps_init(void)
|
int ast_tps_init(void)
|
||||||
{
|
{
|
||||||
if (!(tps_singletons = ao2_container_alloc(TPS_MAX_BUCKETS, tps_hash_cb, tps_cmp_cb))) {
|
tps_singletons = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
TPS_MAX_BUCKETS, tps_hash_cb, NULL, tps_cmp_cb);
|
||||||
|
if (!tps_singletons) {
|
||||||
ast_log(LOG_ERROR, "taskprocessor container failed to initialize!\n");
|
ast_log(LOG_ERROR, "taskprocessor container failed to initialize!\n");
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
|
@ -420,15 +420,18 @@ static struct ast_threadpool *threadpool_alloc(const char *name, const struct as
|
||||||
if (!pool->control_tps) {
|
if (!pool->control_tps) {
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
pool->active_threads = ao2_container_alloc(THREAD_BUCKETS, worker_thread_hash, worker_thread_cmp);
|
pool->active_threads = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
THREAD_BUCKETS, worker_thread_hash, NULL, worker_thread_cmp);
|
||||||
if (!pool->active_threads) {
|
if (!pool->active_threads) {
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
pool->idle_threads = ao2_container_alloc(THREAD_BUCKETS, worker_thread_hash, worker_thread_cmp);
|
pool->idle_threads = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
THREAD_BUCKETS, worker_thread_hash, NULL, worker_thread_cmp);
|
||||||
if (!pool->idle_threads) {
|
if (!pool->idle_threads) {
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
pool->zombie_threads = ao2_container_alloc(THREAD_BUCKETS, worker_thread_hash, worker_thread_cmp);
|
pool->zombie_threads = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
THREAD_BUCKETS, worker_thread_hash, NULL, worker_thread_cmp);
|
||||||
if (!pool->zombie_threads) {
|
if (!pool->zombie_threads) {
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
|
@ -2657,7 +2657,9 @@ struct ao2_container *ast_xmldoc_build_documentation(const char *type)
|
||||||
struct documentation_tree *doctree;
|
struct documentation_tree *doctree;
|
||||||
const char *name;
|
const char *name;
|
||||||
|
|
||||||
if (!(docs = ao2_container_alloc(127, ast_xml_doc_item_hash, ast_xml_doc_item_cmp))) {
|
docs = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 127,
|
||||||
|
ast_xml_doc_item_hash, NULL, ast_xml_doc_item_cmp);
|
||||||
|
if (!docs) {
|
||||||
ast_log(AST_LOG_ERROR, "Failed to create container for xml document item instances\n");
|
ast_log(AST_LOG_ERROR, "Failed to create container for xml document item instances\n");
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
|
@ -401,7 +401,9 @@ static int unload_module(void)
|
||||||
|
|
||||||
static int load_module(void)
|
static int load_module(void)
|
||||||
{
|
{
|
||||||
if (!(cache = ao2_container_alloc(573, cache_hash, cache_cmp))) {
|
cache = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 573,
|
||||||
|
cache_hash, NULL, cache_cmp);
|
||||||
|
if (!cache) {
|
||||||
return AST_MODULE_LOAD_FAILURE;
|
return AST_MODULE_LOAD_FAILURE;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -467,9 +467,8 @@ void ast_ari_websocket_events_event_websocket_dtor(void)
|
||||||
int ast_ari_websocket_events_event_websocket_init(void)
|
int ast_ari_websocket_events_event_websocket_init(void)
|
||||||
{
|
{
|
||||||
/* Try to instantiate the registry */
|
/* Try to instantiate the registry */
|
||||||
event_session_registry = ao2_container_alloc(EVENT_SESSION_NUM_BUCKETS,
|
event_session_registry = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
event_session_hash,
|
EVENT_SESSION_NUM_BUCKETS, event_session_hash, NULL, event_session_compare);
|
||||||
event_session_compare);
|
|
||||||
if (!event_session_registry) {
|
if (!event_session_registry) {
|
||||||
/* This is bad, bad. */
|
/* This is bad, bad. */
|
||||||
ast_log(LOG_WARNING,
|
ast_log(LOG_WARNING,
|
||||||
|
|
|
@ -415,7 +415,9 @@ static struct ast_calendar *build_calendar(struct ast_config *cfg, const char *c
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(cal->events = ao2_container_alloc(CALENDAR_BUCKETS, event_hash_fn, event_cmp_fn))) {
|
cal->events = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
CALENDAR_BUCKETS, event_hash_fn, NULL, event_cmp_fn);
|
||||||
|
if (!cal->events) {
|
||||||
ast_log(LOG_ERROR, "Could not allocate events container for %s\n", cat);
|
ast_log(LOG_ERROR, "Could not allocate events container for %s\n", cat);
|
||||||
cal = unref_calendar(cal);
|
cal = unref_calendar(cal);
|
||||||
return NULL;
|
return NULL;
|
||||||
|
@ -686,7 +688,8 @@ struct ast_calendar_event *ast_calendar_event_alloc(struct ast_calendar *cal)
|
||||||
|
|
||||||
struct ao2_container *ast_calendar_event_container_alloc(void)
|
struct ao2_container *ast_calendar_event_container_alloc(void)
|
||||||
{
|
{
|
||||||
return ao2_container_alloc(CALENDAR_BUCKETS, event_hash_fn, event_cmp_fn);
|
return ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, CALENDAR_BUCKETS,
|
||||||
|
event_hash_fn, NULL, event_cmp_fn);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void event_notification_destroy(void *data)
|
static void event_notification_destroy(void *data)
|
||||||
|
@ -1896,7 +1899,9 @@ static int unload_module(void)
|
||||||
*/
|
*/
|
||||||
static int load_module(void)
|
static int load_module(void)
|
||||||
{
|
{
|
||||||
if (!(calendars = ao2_container_alloc(CALENDAR_BUCKETS, calendar_hash_fn, calendar_cmp_fn))) {
|
calendars = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, CALENDAR_BUCKETS,
|
||||||
|
calendar_hash_fn, NULL, calendar_cmp_fn);
|
||||||
|
if (!calendars) {
|
||||||
ast_log(LOG_ERROR, "Unable to allocate calendars container!\n");
|
ast_log(LOG_ERROR, "Unable to allocate calendars container!\n");
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
|
@ -282,7 +282,9 @@ static int unload_module(void)
|
||||||
*/
|
*/
|
||||||
static int load_module(void)
|
static int load_module(void)
|
||||||
{
|
{
|
||||||
if (!(cli_aliases = ao2_container_alloc(MAX_ALIAS_BUCKETS, alias_hash_cb, alias_cmp_cb))) {
|
cli_aliases = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
MAX_ALIAS_BUCKETS, alias_hash_cb, NULL, alias_cmp_cb);
|
||||||
|
if (!cli_aliases) {
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -1194,7 +1194,9 @@ static int realtime_sqlite3_require(const char *database, const char *table, va_
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(columns = ao2_container_alloc(31, str_hash_fn, str_cmp_fn))) {
|
columns = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 31,
|
||||||
|
str_hash_fn, NULL, str_cmp_fn);
|
||||||
|
if (!columns) {
|
||||||
unref_db(&db);
|
unref_db(&db);
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
@ -1369,7 +1371,9 @@ static int load_module(void)
|
||||||
{
|
{
|
||||||
discover_sqlite3_caps();
|
discover_sqlite3_caps();
|
||||||
|
|
||||||
if (!((databases = ao2_container_alloc(DB_BUCKETS, db_hash_fn, db_cmp_fn)))) {
|
databases = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, DB_BUCKETS,
|
||||||
|
db_hash_fn, NULL, db_cmp_fn);
|
||||||
|
if (!databases) {
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -1125,7 +1125,8 @@ static int load_module(void)
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
||||||
nodes = ao2_container_alloc(23, corosync_node_hash_fn, corosync_node_cmp_fn);
|
nodes = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 23,
|
||||||
|
corosync_node_hash_fn, NULL, corosync_node_cmp_fn);
|
||||||
if (!nodes) {
|
if (!nodes) {
|
||||||
goto failed;
|
goto failed;
|
||||||
}
|
}
|
||||||
|
|
|
@ -4724,7 +4724,9 @@ static int load_module(void)
|
||||||
/* initialize the registry */
|
/* initialize the registry */
|
||||||
faxregistry.active_sessions = 0;
|
faxregistry.active_sessions = 0;
|
||||||
faxregistry.reserved_sessions = 0;
|
faxregistry.reserved_sessions = 0;
|
||||||
if (!(faxregistry.container = ao2_container_alloc(FAX_MAXBUCKETS, session_hash_cb, session_cmp_cb))) {
|
faxregistry.container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
FAX_MAXBUCKETS, session_hash_cb, NULL, session_cmp_cb);
|
||||||
|
if (!faxregistry.container) {
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -147,7 +147,8 @@ static struct ast_websocket_server *websocket_server_create_impl(void)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
server->protocols = ao2_container_alloc(MAX_PROTOCOL_BUCKETS, protocol_hash_fn, protocol_cmp_fn);
|
server->protocols = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
MAX_PROTOCOL_BUCKETS, protocol_hash_fn, NULL, protocol_cmp_fn);
|
||||||
if (!server->protocols) {
|
if (!server->protocols) {
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
|
@ -178,11 +178,6 @@ static void odbc_class_destructor(void *data)
|
||||||
ast_cond_destroy(&class->cond);
|
ast_cond_destroy(&class->cond);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int null_hash_fn(const void *obj, const int flags)
|
|
||||||
{
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static void odbc_obj_destructor(void *data)
|
static void odbc_obj_destructor(void *data)
|
||||||
{
|
{
|
||||||
struct odbc_obj *obj = data;
|
struct odbc_obj *obj = data;
|
||||||
|
@ -1001,7 +996,8 @@ static int unload_module(void)
|
||||||
|
|
||||||
static int load_module(void)
|
static int load_module(void)
|
||||||
{
|
{
|
||||||
if (!(class_container = ao2_container_alloc(1, null_hash_fn, ao2_match_by_addr))) {
|
class_container = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, ao2_match_by_addr);
|
||||||
|
if (!class_container) {
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -382,7 +382,9 @@ static void *parking_config_alloc(void)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(cfg->parking_lots = ao2_container_alloc(37, parking_lot_cfg_hash_fn, parking_lot_cfg_cmp_fn))) {
|
cfg->parking_lots = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
|
||||||
|
parking_lot_cfg_hash_fn, NULL, parking_lot_cfg_cmp_fn);
|
||||||
|
if (!cfg->parking_lots) {
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -1413,13 +1413,15 @@ static int unload_module(void)
|
||||||
*/
|
*/
|
||||||
static int load_module(void)
|
static int load_module(void)
|
||||||
{
|
{
|
||||||
profiles = ao2_container_alloc(MAX_PROFILE_BUCKETS, phone_profile_hash_fn, phone_profile_cmp_fn);
|
profiles = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_PROFILE_BUCKETS,
|
||||||
|
phone_profile_hash_fn, NULL, phone_profile_cmp_fn);
|
||||||
if (!profiles) {
|
if (!profiles) {
|
||||||
ast_log(LOG_ERROR, "Unable to allocate profiles container.\n");
|
ast_log(LOG_ERROR, "Unable to allocate profiles container.\n");
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
||||||
http_routes = ao2_container_alloc(MAX_ROUTE_BUCKETS, http_route_hash_fn, http_route_cmp_fn);
|
http_routes = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_ROUTE_BUCKETS,
|
||||||
|
http_route_hash_fn, NULL, http_route_cmp_fn);
|
||||||
if (!http_routes) {
|
if (!http_routes) {
|
||||||
ast_log(LOG_ERROR, "Unable to allocate routes container.\n");
|
ast_log(LOG_ERROR, "Unable to allocate routes container.\n");
|
||||||
goto error;
|
goto error;
|
||||||
|
@ -1430,13 +1432,15 @@ static int load_module(void)
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
|
|
||||||
users = ao2_container_alloc(MAX_USER_BUCKETS, user_hash_fn, user_cmp_fn);
|
users = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MAX_USER_BUCKETS,
|
||||||
|
user_hash_fn, NULL, user_cmp_fn);
|
||||||
if (!users) {
|
if (!users) {
|
||||||
ast_log(LOG_ERROR, "Unable to allocate users container.\n");
|
ast_log(LOG_ERROR, "Unable to allocate users container.\n");
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
|
|
||||||
providers = ao2_container_alloc(MAX_PROVIDER_BUCKETS, phoneprov_provider_hash_fn, phoneprov_provider_cmp_fn);
|
providers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
MAX_PROVIDER_BUCKETS, phoneprov_provider_hash_fn, NULL, phoneprov_provider_cmp_fn);
|
||||||
if (!providers) {
|
if (!providers) {
|
||||||
ast_log(LOG_ERROR, "Unable to allocate providers container.\n");
|
ast_log(LOG_ERROR, "Unable to allocate providers container.\n");
|
||||||
goto error;
|
goto error;
|
||||||
|
|
|
@ -1575,7 +1575,8 @@ static int populate_transport_states(void *obj, void *arg, int flags)
|
||||||
|
|
||||||
struct ao2_container *ast_sip_get_transport_states(void)
|
struct ao2_container *ast_sip_get_transport_states(void)
|
||||||
{
|
{
|
||||||
struct ao2_container *states = ao2_container_alloc(DEFAULT_STATE_BUCKETS, transport_state_hash, transport_state_cmp);
|
struct ao2_container *states = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
DEFAULT_STATE_BUCKETS, transport_state_hash, NULL, transport_state_cmp);
|
||||||
|
|
||||||
if (!states) {
|
if (!states) {
|
||||||
return NULL;
|
return NULL;
|
||||||
|
@ -1592,7 +1593,8 @@ int ast_sip_initialize_sorcery_transport(void)
|
||||||
struct ao2_container *transports = NULL;
|
struct ao2_container *transports = NULL;
|
||||||
|
|
||||||
/* Create outbound registration states container. */
|
/* Create outbound registration states container. */
|
||||||
transport_states = ao2_container_alloc(DEFAULT_STATE_BUCKETS, internal_state_hash, internal_state_cmp);
|
transport_states = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
DEFAULT_STATE_BUCKETS, internal_state_hash, NULL, internal_state_cmp);
|
||||||
if (!transport_states) {
|
if (!transport_states) {
|
||||||
ast_log(LOG_ERROR, "Unable to allocate transport states container\n");
|
ast_log(LOG_ERROR, "Unable to allocate transport states container\n");
|
||||||
return -1;
|
return -1;
|
||||||
|
|
|
@ -354,8 +354,8 @@ int ast_sip_initialize_transport_management(void)
|
||||||
{
|
{
|
||||||
struct ao2_container *transports;
|
struct ao2_container *transports;
|
||||||
|
|
||||||
transports = ao2_container_alloc(TRANSPORTS_BUCKETS, monitored_transport_hash_fn,
|
transports = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, TRANSPORTS_BUCKETS,
|
||||||
monitored_transport_cmp_fn);
|
monitored_transport_hash_fn, NULL, monitored_transport_cmp_fn);
|
||||||
if (!transports) {
|
if (!transports) {
|
||||||
ast_log(LOG_ERROR, "Could not create container for transports to perform keepalive on.\n");
|
ast_log(LOG_ERROR, "Could not create container for transports to perform keepalive on.\n");
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
|
|
|
@ -959,8 +959,8 @@ static int unload_module(void)
|
||||||
|
|
||||||
static int load_module(void)
|
static int load_module(void)
|
||||||
{
|
{
|
||||||
publishers = ao2_container_alloc(PUBLISHER_BUCKETS, exten_state_publisher_hash,
|
publishers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
exten_state_publisher_cmp);
|
PUBLISHER_BUCKETS, exten_state_publisher_hash, NULL, exten_state_publisher_cmp);
|
||||||
if (!publishers) {
|
if (!publishers) {
|
||||||
ast_log(LOG_WARNING, "Unable to create container to store extension state publishers\n");
|
ast_log(LOG_WARNING, "Unable to create container to store extension state publishers\n");
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
|
|
|
@ -361,7 +361,8 @@ static struct mwi_subscription *mwi_subscription_alloc(struct ast_sip_endpoint *
|
||||||
sub->sip_sub = sip_sub;
|
sub->sip_sub = sip_sub;
|
||||||
}
|
}
|
||||||
|
|
||||||
sub->stasis_subs = ao2_container_alloc(STASIS_BUCKETS, stasis_sub_hash, stasis_sub_cmp);
|
sub->stasis_subs = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
STASIS_BUCKETS, stasis_sub_hash, NULL, stasis_sub_cmp);
|
||||||
if (!sub->stasis_subs) {
|
if (!sub->stasis_subs) {
|
||||||
ao2_cleanup(sub);
|
ao2_cleanup(sub);
|
||||||
return NULL;
|
return NULL;
|
||||||
|
|
|
@ -1437,14 +1437,16 @@ static struct ast_sip_outbound_publish_state *sip_outbound_publish_state_alloc(
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
state->client->datastores = ao2_container_alloc(DATASTORE_BUCKETS, datastore_hash, datastore_cmp);
|
state->client->datastores = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
DATASTORE_BUCKETS, datastore_hash, NULL, datastore_cmp);
|
||||||
if (!state->client->datastores) {
|
if (!state->client->datastores) {
|
||||||
ao2_ref(state, -1);
|
ao2_ref(state, -1);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
state->client->publishers = ao2_container_alloc(DATASTORE_BUCKETS, sip_outbound_publisher_hash_fn,
|
state->client->publishers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
sip_outbound_publisher_cmp_fn);
|
DATASTORE_BUCKETS,
|
||||||
|
sip_outbound_publisher_hash_fn, NULL, sip_outbound_publisher_cmp_fn);
|
||||||
if (!state->client->publishers) {
|
if (!state->client->publishers) {
|
||||||
ao2_ref(state, -1);
|
ao2_ref(state, -1);
|
||||||
return NULL;
|
return NULL;
|
||||||
|
|
|
@ -2444,8 +2444,8 @@ static int load_module(void)
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Create outbound registration states container. */
|
/* Create outbound registration states container. */
|
||||||
new_states = ao2_container_alloc(DEFAULT_STATE_BUCKETS,
|
new_states = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
registration_state_hash, registration_state_cmp);
|
DEFAULT_STATE_BUCKETS, registration_state_hash, NULL, registration_state_cmp);
|
||||||
if (!new_states) {
|
if (!new_states) {
|
||||||
ast_log(LOG_ERROR, "Unable to allocate registration states container\n");
|
ast_log(LOG_ERROR, "Unable to allocate registration states container\n");
|
||||||
unload_module();
|
unload_module();
|
||||||
|
|
|
@ -2676,8 +2676,9 @@ int ast_sip_register_publish_handler(struct ast_sip_publish_handler *handler)
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(handler->publications = ao2_container_alloc(PUBLICATIONS_BUCKETS,
|
handler->publications = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
publication_hash_fn, publication_cmp_fn))) {
|
PUBLICATIONS_BUCKETS, publication_hash_fn, NULL, publication_cmp_fn);
|
||||||
|
if (!handler->publications) {
|
||||||
ast_log(LOG_ERROR, "Could not allocate publications container for event '%s'\n",
|
ast_log(LOG_ERROR, "Could not allocate publications container for event '%s'\n",
|
||||||
handler->event_name);
|
handler->event_name);
|
||||||
return -1;
|
return -1;
|
||||||
|
|
|
@ -2181,7 +2181,8 @@ struct ast_sip_session *ast_sip_session_alloc(struct ast_sip_endpoint *endpoint,
|
||||||
if (!session->direct_media_cap) {
|
if (!session->direct_media_cap) {
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
session->datastores = ao2_container_alloc(DATASTORE_BUCKETS, datastore_hash, datastore_cmp);
|
session->datastores = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
DATASTORE_BUCKETS, datastore_hash, NULL, datastore_cmp);
|
||||||
if (!session->datastores) {
|
if (!session->datastores) {
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
@ -4271,8 +4272,8 @@ static int load_module(void)
|
||||||
}
|
}
|
||||||
nat_hook->outgoing_external_message = session_outgoing_nat_hook;
|
nat_hook->outgoing_external_message = session_outgoing_nat_hook;
|
||||||
ast_sorcery_create(ast_sip_get_sorcery(), nat_hook);
|
ast_sorcery_create(ast_sip_get_sorcery(), nat_hook);
|
||||||
sdp_handlers = ao2_container_alloc(SDP_HANDLER_BUCKETS,
|
sdp_handlers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
sdp_handler_list_hash, sdp_handler_list_cmp);
|
SDP_HANDLER_BUCKETS, sdp_handler_list_hash, NULL, sdp_handler_list_cmp);
|
||||||
if (!sdp_handlers) {
|
if (!sdp_handlers) {
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
|
@ -686,9 +686,12 @@ static void ast_rtp_ice_add_remote_candidate(struct ast_rtp_instance *instance,
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!rtp->ice_proposed_remote_candidates &&
|
if (!rtp->ice_proposed_remote_candidates) {
|
||||||
!(rtp->ice_proposed_remote_candidates = ao2_container_alloc(1, NULL, ice_candidate_cmp))) {
|
rtp->ice_proposed_remote_candidates = ao2_container_alloc_list(
|
||||||
return;
|
AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, ice_candidate_cmp);
|
||||||
|
if (!rtp->ice_proposed_remote_candidates) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/* If this is going to exceed the maximum number of ICE candidates don't even add it */
|
/* If this is going to exceed the maximum number of ICE candidates don't even add it */
|
||||||
|
@ -1103,8 +1106,12 @@ static void ast_rtp_ice_add_cand(struct ast_rtp_instance *instance, struct ast_r
|
||||||
|
|
||||||
pj_ice_calc_foundation(rtp->ice->real_ice->pool, &foundation, type, addr);
|
pj_ice_calc_foundation(rtp->ice->real_ice->pool, &foundation, type, addr);
|
||||||
|
|
||||||
if (!rtp->ice_local_candidates && !(rtp->ice_local_candidates = ao2_container_alloc(1, NULL, ice_candidate_cmp))) {
|
if (!rtp->ice_local_candidates) {
|
||||||
return;
|
rtp->ice_local_candidates = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
NULL, ice_candidate_cmp);
|
||||||
|
if (!rtp->ice_local_candidates) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(candidate = ao2_alloc(sizeof(*candidate), ast_rtp_ice_candidate_destroy))) {
|
if (!(candidate = ao2_alloc(sizeof(*candidate), ast_rtp_ice_candidate_destroy))) {
|
||||||
|
|
|
@ -250,7 +250,8 @@ static int sorcery_memory_delete(const struct ast_sorcery *sorcery, void *data,
|
||||||
|
|
||||||
static void *sorcery_memory_open(const char *data)
|
static void *sorcery_memory_open(const char *data)
|
||||||
{
|
{
|
||||||
return ao2_container_alloc(OBJECT_BUCKETS, sorcery_memory_hash, sorcery_memory_cmp);
|
return ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, OBJECT_BUCKETS,
|
||||||
|
sorcery_memory_hash, NULL, sorcery_memory_cmp);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void sorcery_memory_close(void *data)
|
static void sorcery_memory_close(void *data)
|
||||||
|
|
|
@ -3528,7 +3528,8 @@ static int load_module(void)
|
||||||
{
|
{
|
||||||
int res;
|
int res;
|
||||||
|
|
||||||
caches = ao2_container_alloc(CACHES_CONTAINER_BUCKET_SIZE, sorcery_memory_cache_hash,
|
caches = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
CACHES_CONTAINER_BUCKET_SIZE, sorcery_memory_cache_hash, NULL,
|
||||||
sorcery_memory_cache_cmp);
|
sorcery_memory_cache_cmp);
|
||||||
if (!caches) {
|
if (!caches) {
|
||||||
ast_log(LOG_ERROR, "Failed to create container for configured caches\n");
|
ast_log(LOG_ERROR, "Failed to create container for configured caches\n");
|
||||||
|
|
|
@ -2167,9 +2167,12 @@ static int load_module(void)
|
||||||
if (STASIS_MESSAGE_TYPE_INIT(end_message_type) != 0) {
|
if (STASIS_MESSAGE_TYPE_INIT(end_message_type) != 0) {
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
apps_registry = ao2_container_alloc(APPS_NUM_BUCKETS, app_hash, app_compare);
|
apps_registry = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
app_controls = ao2_container_alloc(CONTROLS_NUM_BUCKETS, control_hash, control_compare);
|
APPS_NUM_BUCKETS, app_hash, NULL, app_compare);
|
||||||
app_bridges = ao2_container_alloc(BRIDGES_NUM_BUCKETS, bridges_hash, bridges_compare);
|
app_controls = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
CONTROLS_NUM_BUCKETS, control_hash, NULL, control_compare);
|
||||||
|
app_bridges = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
BRIDGES_NUM_BUCKETS, bridges_hash, NULL, bridges_compare);
|
||||||
app_bridges_moh = ao2_container_alloc_hash(
|
app_bridges_moh = ao2_container_alloc_hash(
|
||||||
AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
37, bridges_channel_hash_fn, NULL, NULL);
|
37, bridges_channel_hash_fn, NULL, NULL);
|
||||||
|
|
|
@ -461,9 +461,10 @@ static int load_module(void)
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(device_state_subscriptions = ao2_container_alloc(
|
device_state_subscriptions = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
DEVICE_STATE_BUCKETS, device_state_subscriptions_hash,
|
DEVICE_STATE_BUCKETS, device_state_subscriptions_hash, NULL,
|
||||||
device_state_subscriptions_cmp))) {
|
device_state_subscriptions_cmp);
|
||||||
|
if (!device_state_subscriptions) {
|
||||||
ast_devstate_prov_del(DEVICE_STATE_PROVIDER_STASIS);
|
ast_devstate_prov_del(DEVICE_STATE_PROVIDER_STASIS);
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
|
@ -738,8 +738,8 @@ static int load_module(void)
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
||||||
playbacks = ao2_container_alloc(PLAYBACK_BUCKETS, playback_hash,
|
playbacks = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, PLAYBACK_BUCKETS,
|
||||||
playback_cmp);
|
playback_hash, NULL, playback_cmp);
|
||||||
if (!playbacks) {
|
if (!playbacks) {
|
||||||
STASIS_MESSAGE_TYPE_CLEANUP(stasis_app_playback_snapshot_type);
|
STASIS_MESSAGE_TYPE_CLEANUP(stasis_app_playback_snapshot_type);
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
|
|
|
@ -634,8 +634,8 @@ static int load_module(void)
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
||||||
recordings = ao2_container_alloc(RECORDING_BUCKETS, recording_hash,
|
recordings = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, RECORDING_BUCKETS,
|
||||||
recording_cmp);
|
recording_hash, NULL, recording_cmp);
|
||||||
if (!recordings) {
|
if (!recordings) {
|
||||||
STASIS_MESSAGE_TYPE_CLEANUP(stasis_app_recording_snapshot_type);
|
STASIS_MESSAGE_TYPE_CLEANUP(stasis_app_recording_snapshot_type);
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
|
|
|
@ -440,8 +440,9 @@ static int init_timing_thread(void)
|
||||||
|
|
||||||
static int load_module(void)
|
static int load_module(void)
|
||||||
{
|
{
|
||||||
if (!(pthread_timers = ao2_container_alloc(PTHREAD_TIMER_BUCKETS,
|
pthread_timers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
pthread_timer_hash, pthread_timer_cmp))) {
|
PTHREAD_TIMER_BUCKETS, pthread_timer_hash, NULL, pthread_timer_cmp);
|
||||||
|
if (!pthread_timers) {
|
||||||
return AST_MODULE_LOAD_DECLINE;
|
return AST_MODULE_LOAD_DECLINE;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -614,7 +614,9 @@ static struct ast_xmpp_client *xmpp_client_alloc(const char *name)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(client->buddies = ao2_container_alloc(BUDDY_BUCKETS, xmpp_buddy_hash, xmpp_buddy_cmp))) {
|
client->buddies = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, BUDDY_BUCKETS,
|
||||||
|
xmpp_buddy_hash, NULL, xmpp_buddy_cmp);
|
||||||
|
if (!client->buddies) {
|
||||||
ast_log(LOG_ERROR, "Could not initialize buddy container for '%s'\n", name);
|
ast_log(LOG_ERROR, "Could not initialize buddy container for '%s'\n", name);
|
||||||
ao2_ref(client, -1);
|
ao2_ref(client, -1);
|
||||||
return NULL;
|
return NULL;
|
||||||
|
@ -680,7 +682,9 @@ static void *ast_xmpp_client_config_alloc(const char *cat)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(cfg->buddies = ao2_container_alloc(BUDDY_BUCKETS, xmpp_buddy_hash, xmpp_buddy_cmp))) {
|
cfg->buddies = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, BUDDY_BUCKETS,
|
||||||
|
xmpp_buddy_hash, NULL, xmpp_buddy_cmp);
|
||||||
|
if (!cfg->buddies) {
|
||||||
ao2_ref(cfg, -1);
|
ao2_ref(cfg, -1);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
@ -698,14 +702,6 @@ static void xmpp_config_destructor(void *obj)
|
||||||
ao2_cleanup(cfg->clients);
|
ao2_cleanup(cfg->clients);
|
||||||
}
|
}
|
||||||
|
|
||||||
/*! \brief Hashing function for configuration */
|
|
||||||
static int xmpp_config_hash(const void *obj, const int flags)
|
|
||||||
{
|
|
||||||
const struct ast_xmpp_client_config *cfg = obj;
|
|
||||||
const char *name = (flags & OBJ_KEY) ? obj : cfg->name;
|
|
||||||
return ast_str_case_hash(name);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*! \brief Comparator function for configuration */
|
/*! \brief Comparator function for configuration */
|
||||||
static int xmpp_config_cmp(void *obj, void *arg, int flags)
|
static int xmpp_config_cmp(void *obj, void *arg, int flags)
|
||||||
{
|
{
|
||||||
|
@ -727,7 +723,9 @@ static void *xmpp_config_alloc(void)
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(cfg->clients = ao2_container_alloc(1, xmpp_config_hash, xmpp_config_cmp))) {
|
cfg->clients = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
NULL, xmpp_config_cmp);
|
||||||
|
if (!cfg->clients) {
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -2169,7 +2167,9 @@ static struct ast_xmpp_buddy *xmpp_client_create_buddy(struct ao2_container *con
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!(buddy->resources = ao2_container_alloc(RESOURCE_BUCKETS, xmpp_resource_hash, xmpp_resource_cmp))) {
|
buddy->resources = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
|
RESOURCE_BUCKETS, xmpp_resource_hash, NULL, xmpp_resource_cmp);
|
||||||
|
if (!buddy->resources) {
|
||||||
ao2_ref(buddy, -1);
|
ao2_ref(buddy, -1);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
|
@ -712,9 +712,9 @@ AST_TEST_DEFINE(astobj2_test_2)
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
c = ao2_container_alloc(1, NULL, test_cmp_cb);
|
c = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, test_cmp_cb);
|
||||||
if (!c) {
|
if (!c) {
|
||||||
ast_test_status_update(test, "ao2_container_alloc failed.\n");
|
ast_test_status_update(test, "ao2_container_alloc_list failed.\n");
|
||||||
res = AST_TEST_FAIL;
|
res = AST_TEST_FAIL;
|
||||||
goto cleanup;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
|
|
@ -267,8 +267,8 @@ AST_TEST_DEFINE(hash_test)
|
||||||
data.preload = MAX_HASH_ENTRIES / 2;
|
data.preload = MAX_HASH_ENTRIES / 2;
|
||||||
data.max_grow = MAX_HASH_ENTRIES - data.preload;
|
data.max_grow = MAX_HASH_ENTRIES - data.preload;
|
||||||
data.deadline = ast_tvadd(ast_tvnow(), ast_tv(MAX_TEST_SECONDS, 0));
|
data.deadline = ast_tvadd(ast_tvnow(), ast_tv(MAX_TEST_SECONDS, 0));
|
||||||
data.to_be_thrashed = ao2_container_alloc(HASH_BUCKETS, hash_string,
|
data.to_be_thrashed = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
|
||||||
compare_strings);
|
HASH_BUCKETS, hash_string, NULL, compare_strings);
|
||||||
|
|
||||||
if (data.to_be_thrashed == NULL) {
|
if (data.to_be_thrashed == NULL) {
|
||||||
ast_test_status_update(test, "Allocation failed\n");
|
ast_test_status_update(test, "Allocation failed\n");
|
||||||
|
|
|
@ -1837,8 +1837,8 @@ static int test_cel_init_cb(struct ast_test_info *info, struct ast_test *test)
|
||||||
ast_cel_set_config(cel_test_config);
|
ast_cel_set_config(cel_test_config);
|
||||||
|
|
||||||
/* init CEL event storage (degenerate hash table becomes a linked list) */
|
/* init CEL event storage (degenerate hash table becomes a linked list) */
|
||||||
cel_received_events = ao2_container_alloc(1, NULL, NULL);
|
cel_received_events = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
|
||||||
cel_expected_events = ao2_container_alloc(1, NULL, NULL);
|
cel_expected_events = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
|
||||||
|
|
||||||
/* start the CEL event callback */
|
/* start the CEL event callback */
|
||||||
if (ast_cel_backend_register(TEST_BACKEND_NAME, test_sub)) {
|
if (ast_cel_backend_register(TEST_BACKEND_NAME, test_sub)) {
|
||||||
|
|
|
@ -1364,12 +1364,6 @@ struct test_config {
|
||||||
struct ao2_container *items;
|
struct ao2_container *items;
|
||||||
};
|
};
|
||||||
|
|
||||||
static int test_item_hash(const void *obj, const int flags)
|
|
||||||
{
|
|
||||||
const struct test_item *item = obj;
|
|
||||||
const char *name = (flags & OBJ_KEY) ? obj : item->name;
|
|
||||||
return ast_str_case_hash(name);
|
|
||||||
}
|
|
||||||
static int test_item_cmp(void *obj, void *arg, int flags)
|
static int test_item_cmp(void *obj, void *arg, int flags)
|
||||||
{
|
{
|
||||||
struct test_item *one = obj, *two = arg;
|
struct test_item *one = obj, *two = arg;
|
||||||
|
@ -1422,7 +1416,8 @@ static void *test_config_alloc(void)
|
||||||
if (!(cfg->global_defaults = test_item_alloc("global_defaults"))) {
|
if (!(cfg->global_defaults = test_item_alloc("global_defaults"))) {
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
if (!(cfg->items = ao2_container_alloc(1, test_item_hash, test_item_cmp))) {
|
cfg->items = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, test_item_cmp);
|
||||||
|
if (!cfg->items) {
|
||||||
goto error;
|
goto error;
|
||||||
}
|
}
|
||||||
return cfg;
|
return cfg;
|
||||||
|
|
|
@ -199,8 +199,8 @@ AST_TEST_DEFINE(cleanup_order)
|
||||||
enum ast_test_result_state res = AST_TEST_PASS;
|
enum ast_test_result_state res = AST_TEST_PASS;
|
||||||
struct ao2_iterator iter;
|
struct ao2_iterator iter;
|
||||||
struct test_struct *object_iter;
|
struct test_struct *object_iter;
|
||||||
RAII_VAR(struct ao2_container*, container, ao2_container_alloc(13, NULL, NULL), ao2_cleanup);
|
RAII_VAR(struct ao2_container*, container, NULL, ao2_cleanup);
|
||||||
RAII_VAR(struct test_struct *, object, ao2_alloc(sizeof(*object), NULL), ao2_cleanup);
|
RAII_VAR(struct test_struct *, object, NULL, ao2_cleanup);
|
||||||
|
|
||||||
switch(cmd) {
|
switch(cmd) {
|
||||||
case TEST_INIT:
|
case TEST_INIT:
|
||||||
|
@ -216,6 +216,8 @@ AST_TEST_DEFINE(cleanup_order)
|
||||||
}
|
}
|
||||||
current_test = test;
|
current_test = test;
|
||||||
|
|
||||||
|
container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 13, NULL, NULL, NULL);
|
||||||
|
object = ao2_alloc(sizeof(*object), NULL);
|
||||||
if (!object || !container) {
|
if (!object || !container) {
|
||||||
/* Allocation failure. We can't even pretend to do this test properly */
|
/* Allocation failure. We can't even pretend to do this test properly */
|
||||||
return AST_TEST_FAIL;
|
return AST_TEST_FAIL;
|
||||||
|
|
Loading…
Reference in New Issue