From 0a9904e1c618ff985efacb487ee00ea03fb22263 Mon Sep 17 00:00:00 2001 From: Corey Farrell Date: Mon, 19 Nov 2018 11:20:21 -0500 Subject: [PATCH] astobj2: Eliminate usage of legacy ao2_container_alloc routine. Replace usage of ao2_container_alloc with ao2_container_alloc_hash or ao2_container_alloc_list. ao2_container_alloc is now restricted to modules only and is being removed from Asterisk 17. Change-Id: I0907d78bc66efc775672df37c8faad00f2f6c088 --- apps/app_confbridge.c | 5 ++- apps/app_meetme.c | 30 ++++++------- apps/app_queue.c | 14 ++++--- apps/app_skel.c | 8 +++- apps/app_voicemail.c | 7 +++- apps/confbridge/conf_config_parser.c | 12 ++++-- channels/chan_console.c | 4 +- channels/chan_iax2.c | 49 ++++++++++++++++++---- channels/chan_motif.c | 8 +++- channels/chan_sip.c | 9 ++-- channels/chan_unistim.c | 4 +- channels/sig_pri.c | 4 +- funcs/func_dialgroup.c | 11 +++-- funcs/func_lock.c | 10 ++--- funcs/func_odbc.c | 6 ++- include/asterisk/astobj2.h | 29 ++++--------- main/cel.c | 10 +++-- main/channel.c | 4 +- main/channel_internal_api.c | 4 +- main/config.c | 11 +++-- main/config_options.c | 3 +- main/data.c | 22 +++++----- main/endpoints.c | 8 ++-- main/indications.c | 4 +- main/manager.c | 13 +++--- main/media_index.c | 6 ++- main/message.c | 10 ++--- main/named_acl.c | 4 +- main/pbx.c | 10 +++-- main/stasis.c | 4 +- main/stasis_channels.c | 9 ++-- main/taskprocessor.c | 4 +- main/threadpool.c | 9 ++-- main/xmldoc.c | 4 +- pbx/pbx_realtime.c | 4 +- res/res_calendar.c | 10 +++-- res/res_clialiases.c | 4 +- res/res_config_sqlite3.c | 8 +++- res/res_corosync.c | 3 +- res/res_fax.c | 4 +- res/res_http_websocket.c | 3 +- res/res_odbc.c | 8 +--- res/res_parking.c | 4 +- res/res_phoneprov.c | 12 ++++-- res/res_pjsip/config_transport.c | 6 ++- res/res_pjsip/pjsip_transport_management.c | 4 +- res/res_pjsip_mwi.c | 3 +- res/res_pjsip_outbound_publish.c | 3 +- res/res_pjsip_outbound_registration.c | 4 +- res/res_pjsip_pubsub.c | 12 ++++-- res/res_pjsip_session.c | 10 +++-- res/res_rtp_asterisk.c | 17 +++++--- res/res_sorcery_memory.c | 3 +- res/res_sorcery_memory_cache.c | 3 +- res/res_stasis.c | 9 ++-- res/res_stasis_device_state.c | 7 ++-- res/res_stasis_playback.c | 4 +- res/res_stasis_recording.c | 4 +- res/res_timing_pthread.c | 5 ++- res/res_xmpp.c | 24 +++++------ tests/test_astobj2.c | 4 +- tests/test_astobj2_thrash.c | 4 +- tests/test_cel.c | 4 +- tests/test_config.c | 9 +--- tests/test_scoped_lock.c | 6 ++- 65 files changed, 330 insertions(+), 224 deletions(-) diff --git a/apps/app_confbridge.c b/apps/app_confbridge.c index 9c6b690cf9..d07c1568b8 100644 --- a/apps/app_confbridge.c +++ b/apps/app_confbridge.c @@ -4093,8 +4093,9 @@ static int load_module(void) } /* Create a container to hold the conference bridges */ - conference_bridges = ao2_container_alloc(CONFERENCE_BRIDGE_BUCKETS, - conference_bridge_hash_cb, conference_bridge_cmp_cb); + conference_bridges = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + CONFERENCE_BRIDGE_BUCKETS, + conference_bridge_hash_cb, NULL, conference_bridge_cmp_cb); if (!conference_bridges) { unload_module(); return AST_MODULE_LOAD_DECLINE; diff --git a/apps/app_meetme.c b/apps/app_meetme.c index 9ef46212fe..d8493d0426 100644 --- a/apps/app_meetme.c +++ b/apps/app_meetme.c @@ -1627,8 +1627,14 @@ static struct ast_conference *build_conf(const char *confno, const char *pin, ast_format_cap_append(cap_slin, ast_format_slin, 0); /* Make a new one */ - if (!(cnf = ast_calloc(1, sizeof(*cnf))) || - !(cnf->usercontainer = ao2_container_alloc(1, NULL, user_no_cmp))) { + cnf = ast_calloc(1, sizeof(*cnf)); + 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; } @@ -7398,13 +7404,6 @@ static void sla_station_destructor(void *obj) 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) { struct sla_trunk *trunk = obj, *trunk2 = arg; @@ -7412,13 +7411,6 @@ static int sla_trunk_cmp(void *obj, void *arg, int flags) 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) { struct sla_station *station = obj, *station2 = arg; @@ -7872,8 +7864,10 @@ static int sla_load_config(int reload) if (!reload) { ast_mutex_init(&sla.lock); ast_cond_init(&sla.cond, NULL); - sla_trunks = ao2_container_alloc(1, sla_trunk_hash, sla_trunk_cmp); - sla_stations = ao2_container_alloc(1, sla_station_hash, sla_station_cmp); + sla_trunks = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + 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))) { diff --git a/apps/app_queue.c b/apps/app_queue.c index ce00b5e676..4f7c714d81 100644 --- a/apps/app_queue.c +++ b/apps/app_queue.c @@ -2699,10 +2699,11 @@ static void init_queue(struct call_queue *q) q->autopausedelay = 0; if (!q->members) { 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 */ - q->members = ao2_container_alloc(1, member_hash_fn, member_cmp_fn); + /* linear strategy depends on order, so we have to place all members in a list */ + q->members = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, member_cmp_fn); } 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; @@ -10925,13 +10926,14 @@ static int load_module(void) struct stasis_topic *queue_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) { return AST_MODULE_LOAD_DECLINE; } - pending_members = ao2_container_alloc( - MAX_CALL_ATTEMPT_BUCKETS, pending_members_hash, pending_members_cmp); + pending_members = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + MAX_CALL_ATTEMPT_BUCKETS, pending_members_hash, NULL, pending_members_cmp); if (!pending_members) { unload_module(); return AST_MODULE_LOAD_DECLINE; diff --git a/apps/app_skel.c b/apps/app_skel.c index ae50bb576d..f15c344d19 100644 --- a/apps/app_skel.c +++ b/apps/app_skel.c @@ -582,7 +582,9 @@ static void *skel_config_alloc(void) 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; } @@ -727,7 +729,9 @@ static int load_module(void) if (aco_info_init(&cfg_info)) { 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; } diff --git a/apps/app_voicemail.c b/apps/app_voicemail.c index aa114a8fe0..f45c596221 100644 --- a/apps/app_voicemail.c +++ b/apps/app_voicemail.c @@ -15018,11 +15018,14 @@ static int load_module(void) my_umask = umask(0); 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; } - 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) { ast_log(LOG_ERROR, "Unable to create poll_list container\n"); ao2_cleanup(inprocess_container); diff --git a/apps/confbridge/conf_config_parser.c b/apps/confbridge/conf_config_parser.c index d1406c14bd..9486260d5b 100644 --- a/apps/confbridge/conf_config_parser.c +++ b/apps/confbridge/conf_config_parser.c @@ -1822,15 +1822,21 @@ void *confbridge_cfg_alloc(void) 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; } - 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; } - 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; } diff --git a/channels/chan_console.c b/channels/chan_console.c index f09694bcf4..cdd7a25cbd 100644 --- a/channels/chan_console.c +++ b/channels/chan_console.c @@ -1536,7 +1536,9 @@ static int load_module(void) 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; if (load_config(0)) diff --git a/channels/chan_iax2.c b/channels/chan_iax2.c index d534c0003f..b485fd17fb 100644 --- a/channels/chan_iax2.c +++ b/channels/chan_iax2.c @@ -14858,23 +14858,54 @@ static int load_objects(void) peers = users = iax_peercallno_pvts = iax_transfercallno_pvts = 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; - } 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; - } 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; - } 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; - } 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; - } 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; - } 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; - } else if (create_callno_pools()) { + } + + if (create_callno_pools()) { 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; } diff --git a/channels/chan_motif.c b/channels/chan_motif.c index a80f8be2c3..97a56d5b30 100644 --- a/channels/chan_motif.c +++ b/channels/chan_motif.c @@ -473,7 +473,9 @@ static struct jingle_endpoint_state *jingle_endpoint_state_create(void) 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); return NULL; } @@ -607,7 +609,9 @@ static void *jingle_config_alloc(void) 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); return NULL; } diff --git a/channels/chan_sip.c b/channels/chan_sip.c index 49d5f64a5b..d90c1c7135 100644 --- a/channels/chan_sip.c +++ b/channels/chan_sip.c @@ -1768,8 +1768,9 @@ static int initialize_escs(void) { int i, res = 0; for (i = 0; i < ARRAY_LEN(event_state_compositors); i++) { - if (!((event_state_compositors[i].compositor) = - ao2_container_alloc(ESC_MAX_BUCKETS, esc_hash_fn, esc_cmp_fn))) { + event_state_compositors[i].compositor = ao2_container_alloc_hash( + AO2_ALLOC_OPT_LOCK_MUTEX, 0, ESC_MAX_BUCKETS, esc_hash_fn, NULL, esc_cmp_fn); + if (!event_state_compositors[i].compositor) { res = -1; } } @@ -35507,7 +35508,9 @@ static int load_module(void) unload_module(); 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(); return AST_MODULE_LOAD_DECLINE; } diff --git a/channels/chan_unistim.c b/channels/chan_unistim.c index 5d8e47c00d..1809c8ab47 100644 --- a/channels/chan_unistim.c +++ b/channels/chan_unistim.c @@ -815,7 +815,9 @@ static const char *ustmtext(const char *str, struct unistimsession *pte) char tmp[1024], *p, *p_orig = NULL, *p_trans = NULL; 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"); return str; } diff --git a/channels/sig_pri.c b/channels/sig_pri.c index 682abf37a4..69fe346105 100644 --- a/channels/sig_pri.c +++ b/channels/sig_pri.c @@ -10146,8 +10146,8 @@ int sig_pri_load(const char *cc_type_name) #if defined(HAVE_PRI_CCSS) 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_monitor_instance_cmp_fn); + sig_pri_cc_monitors = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37, + sig_pri_cc_monitor_instance_hash_fn, NULL, sig_pri_cc_monitor_instance_cmp_fn); if (!sig_pri_cc_monitors) { return -1; } diff --git a/funcs/func_dialgroup.c b/funcs/func_dialgroup.c index 37aba6afbe..01348b0762 100644 --- a/funcs/func_dialgroup.c +++ b/funcs/func_dialgroup.c @@ -223,7 +223,8 @@ static int dialgroup_write(struct ast_channel *chan, const char *cmd, char *data grhead = ao2_alloc(sizeof(*grhead), group_destroy); if (!grhead) 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) { ao2_ref(grhead, -1); return -1; @@ -238,7 +239,9 @@ static int dialgroup_write(struct ast_channel *chan, const char *cmd, char *data /* Remove all existing */ 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_ref(grhead, -1); return -1; @@ -299,7 +302,9 @@ static int load_module(void) struct ast_db_entry *dbtree, *tmp; 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 */ if ((dbtree = ast_db_gettree("dialgroup", NULL))) { for (tmp = dbtree; tmp; tmp = tmp->next) { diff --git a/funcs/func_lock.c b/funcs/func_lock.c index e56d56dcb7..a006a574eb 100644 --- a/funcs/func_lock.c +++ b/funcs/func_lock.c @@ -217,12 +217,6 @@ static void *lock_broker(void *unused) 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) { struct ast_channel *chan = obj, *cmp_args = arg; @@ -298,7 +292,9 @@ static int get_lock(struct ast_channel *chan, char *lockname, int trylock) AST_LIST_UNLOCK(&locklist); 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_cond_destroy(¤t->cond); ast_free(current); diff --git a/funcs/func_odbc.c b/funcs/func_odbc.c index f4821c0e6b..70f02b8570 100644 --- a/funcs/func_odbc.c +++ b/funcs/func_odbc.c @@ -1795,7 +1795,8 @@ static int load_module(void) dsns = NULL; 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) { ast_log(LOG_ERROR, "Could not initialize DSN container\n"); ast_rwlock_unlock(&single_db_connection_lock); @@ -1893,7 +1894,8 @@ static int reload(void) } 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) { ast_log(LOG_ERROR, "Could not initialize DSN container\n"); ast_rwlock_unlock(&single_db_connection_lock); diff --git a/include/asterisk/astobj2.h b/include/asterisk/astobj2.h index 0e32e893c9..4765fdc6ef 100644 --- a/include/asterisk/astobj2.h +++ b/include/asterisk/astobj2.h @@ -92,7 +92,8 @@ parameters. At the moment, this is done as follows: 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 where @@ -108,7 +109,7 @@ A container knows little or nothing about the objects it stores, other than the fact that they have been created by ao2_alloc(). All knowledge of the (user-defined) internals of the objects 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 initialize its fields -- especially, those used by my_hash_fn() -- @@ -856,20 +857,8 @@ and perform various operations on them. Internally, objects are stored in lists, hash tables or other 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: - - 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) returns zero or more elements matching a given criteria (specified as arg). 'c' is the container pointer. Flags @@ -1217,6 +1206,10 @@ typedef int (ao2_sort_fn)(const void *obj_left, const void *obj_right, int flags /*@{ */ struct ao2_container; +#ifndef AST_IN_CORE +/* These macros are removed from Asterisk 17. They are still available to modules + * but should only be used by third party modules that have not been updated. */ + /*! * \deprecated * \brief Allocate and initialize a hash container with the desired number of buckets. @@ -1236,17 +1229,13 @@ struct ao2_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)) - -#ifndef AST_IN_CORE -/* These macros are removed from Asterisk 17. They are still available to modules - * but should only be used by third party modules that have not been updated. */ #define ao2_t_container_alloc_options(options, n_buckets, hash_fn, cmp_fn, tag) \ ao2_t_container_alloc_hash((options), 0, (n_buckets), (hash_fn), NULL, (cmp_fn), (tag)) #define ao2_container_alloc_options(options, n_buckets, hash_fn, cmp_fn) \ ao2_container_alloc_hash((options), 0, (n_buckets), (hash_fn), NULL, (cmp_fn)) +#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)) #define ao2_t_container_alloc(n_buckets, hash_fn, cmp_fn, tag) \ ao2_t_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, (n_buckets), (hash_fn), NULL, (cmp_fn), (tag)) #endif diff --git a/main/cel.c b/main/cel.c index 45726e0702..4e675813a1 100644 --- a/main/cel.c +++ b/main/cel.c @@ -1561,15 +1561,16 @@ int ast_cel_engine_init(void) { 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_cleanup(container); if (!container) { return -1; } - container = ao2_container_alloc(NUM_DIALSTATUS_BUCKETS, - cel_dialstatus_hash_fn, cel_dialstatus_cmp_fn); + container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + NUM_DIALSTATUS_BUCKETS, cel_dialstatus_hash_fn, NULL, cel_dialstatus_cmp_fn); ao2_global_obj_replace_unref(cel_dialstatus_store, container); ao2_cleanup(container); if (!container) { @@ -1584,7 +1585,8 @@ int ast_cel_engine_init(void) return -1; } - 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_cleanup(container); if (!container) { diff --git a/main/channel.c b/main/channel.c index e5bd8794d6..c1eecdb019 100644 --- a/main/channel.c +++ b/main/channel.c @@ -8056,8 +8056,8 @@ static void channels_shutdown(void) int ast_channels_init(void) { - channels = ao2_container_alloc(NUM_CHANNEL_BUCKETS, - ast_channel_hash_cb, ast_channel_cmp_cb); + channels = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NUM_CHANNEL_BUCKETS, + ast_channel_hash_cb, NULL, ast_channel_cmp_cb); if (!channels) { return -1; } diff --git a/main/channel_internal_api.c b/main/channel_internal_api.c index 6e429b3db1..72ca1a9ce2 100644 --- a/main/channel_internal_api.c +++ b/main/channel_internal_api.c @@ -1462,7 +1462,9 @@ struct ast_channel *__ast_channel_internal_alloc(void (*destructor)(void *obj), 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); } diff --git a/main/config.c b/main/config.c index a8fae05add..d864af2e09 100644 --- a/main/config.c +++ b/main/config.c @@ -2545,7 +2545,8 @@ int ast_config_text_file_save2(const char *configfile, const struct ast_config * struct ao2_container *fileset; 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) { /* Container creation failed. */ return -1; @@ -4112,8 +4113,12 @@ int ast_config_hook_register(const char *name, config_hook_cb hook_cb) { struct cfg_hook *hook; - if (!cfg_hooks && !(cfg_hooks = ao2_container_alloc(17, hook_hash, hook_cmp))) { - return -1; + if (!cfg_hooks) { + 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))) { diff --git a/main/config_options.c b/main/config_options.c index f8b2be8290..75d5ad1be9 100644 --- a/main/config_options.c +++ b/main/config_options.c @@ -407,7 +407,8 @@ static struct aco_option *aco_option_find(struct aco_type *type, const char *nam 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) diff --git a/main/data.c b/main/data.c index 59729492c3..b703b56500 100644 --- a/main/data.c +++ b/main/data.c @@ -323,8 +323,9 @@ static struct data_provider *data_provider_new(const char *name, strcpy(node->name, name); /* initialize the childrens container. */ - if (!(node->children = ao2_container_alloc(NUM_DATA_NODE_BUCKETS, - data_provider_hash, data_provider_cmp))) { + node->children = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + NUM_DATA_NODE_BUCKETS, data_provider_hash, NULL, data_provider_cmp); + if (!node->children) { ao2_ref(node, -1); return NULL; } @@ -698,8 +699,8 @@ static struct ast_data_search *data_search_alloc(const char *name) return NULL; } - res->children = ao2_container_alloc(NUM_DATA_SEARCH_BUCKETS, data_search_hash, - data_search_cmp); + res->children = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + NUM_DATA_SEARCH_BUCKETS, data_search_hash, NULL, data_search_cmp); if (!res->children) { ao2_ref(res, -1); @@ -1418,8 +1419,8 @@ static struct ast_data *data_result_create(const char *name) strcpy(res->name, namelen ? name : ""); /* initialize the children container */ - res->children = ao2_container_alloc(NUM_DATA_RESULT_BUCKETS, data_result_hash, - data_result_cmp); + res->children = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + NUM_DATA_RESULT_BUCKETS, data_result_hash, NULL, data_result_cmp); if (!res->children) { ao2_ref(res, -1); return NULL; @@ -1656,8 +1657,8 @@ static struct data_filter *data_filter_alloc(const char *name) return NULL; } - res->children = ao2_container_alloc(NUM_DATA_FILTER_BUCKETS, data_filter_hash, - data_filter_cmp); + res->children = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + NUM_DATA_FILTER_BUCKETS, data_filter_hash, NULL, data_filter_cmp); if (!res->children) { ao2_ref(res, -1); @@ -3335,8 +3336,9 @@ int ast_data_init(void) ast_rwlock_init(&root_data.lock); - if (!(root_data.container = ao2_container_alloc(NUM_DATA_NODE_BUCKETS, - data_provider_hash, data_provider_cmp))) { + root_data.container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + NUM_DATA_NODE_BUCKETS, data_provider_hash, NULL, data_provider_cmp); + if (!root_data.container) { return -1; } diff --git a/main/endpoints.c b/main/endpoints.c index 69d022fb0a..b68f20758c 100644 --- a/main/endpoints.c +++ b/main/endpoints.c @@ -484,14 +484,14 @@ int ast_endpoint_init(void) { ast_register_cleanup(endpoint_cleanup); - endpoints = ao2_container_alloc(ENDPOINT_BUCKETS, ast_endpoint_hash_fn, - ast_endpoint_cmp_fn); + endpoints = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, ENDPOINT_BUCKETS, + ast_endpoint_hash_fn, NULL, ast_endpoint_cmp_fn); if (!endpoints) { return -1; } - tech_endpoints = ao2_container_alloc(TECH_ENDPOINT_BUCKETS, ast_endpoint_hash_fn, - ast_endpoint_cmp_fn); + tech_endpoints = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + TECH_ENDPOINT_BUCKETS, ast_endpoint_hash_fn, NULL, ast_endpoint_cmp_fn); if (!tech_endpoints) { return -1; } diff --git a/main/indications.c b/main/indications.c index e0ba59b727..f193792608 100644 --- a/main/indications.c +++ b/main/indications.c @@ -1174,8 +1174,8 @@ static void indications_shutdown(void) /*! \brief Load indications module */ int ast_indications_init(void) { - ast_tone_zones = ao2_container_alloc(NUM_TONE_ZONE_BUCKETS, - ast_tone_zone_hash, ast_tone_zone_cmp); + ast_tone_zones = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + NUM_TONE_ZONE_BUCKETS, ast_tone_zone_hash, NULL, ast_tone_zone_cmp); if (!ast_tone_zones) { return -1; } diff --git a/main/manager.c b/main/manager.c index 5b4cc3af34..47b31bbde6 100644 --- a/main/manager.c +++ b/main/manager.c @@ -2224,8 +2224,8 @@ static struct mansession_session *build_mansession(const struct ast_sockaddr *ad return NULL; } - newsession->whitefilters = ao2_container_alloc(1, NULL, NULL); - newsession->blackfilters = 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_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL); if (!newsession->whitefilters || !newsession->blackfilters) { ao2_ref(newsession, -1); return NULL; @@ -7612,7 +7612,8 @@ static void xml_translate(struct ast_str **out, char *in, struct ast_variable *g if (xml) { ast_str_append(out, 0, "<%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; } @@ -9052,7 +9053,7 @@ static int __init_manager(int reload, int by_external_config) #endif /* 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) { return -1; } @@ -9308,8 +9309,8 @@ static int __init_manager(int reload, int by_external_config) /* Default allowmultiplelogin from [general] */ user->allowmultiplelogin = allowmultiplelogin; user->writetimeout = 100; - user->whitefilters = ao2_container_alloc(1, NULL, NULL); - user->blackfilters = 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_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL); if (!user->whitefilters || !user->blackfilters) { manager_free_user(user); break; diff --git a/main/media_index.c b/main/media_index.c index bfaa58003c..2d1bc6bbd6 100644 --- a/main/media_index.c +++ b/main/media_index.c @@ -121,7 +121,8 @@ static struct media_info *media_info_alloc(const char *name) 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) { 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); - 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) { ao2_ref(index, -1); diff --git a/main/message.c b/main/message.c index 7ba2e26518..0543bf4aac 100644 --- a/main/message.c +++ b/main/message.c @@ -369,12 +369,6 @@ static void msg_ds_destroy(void *data) 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) { const struct msg_data *one = obj, *two = arg; @@ -408,7 +402,9 @@ struct ast_msg *ast_msg_alloc(void) 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); return NULL; } diff --git a/main/named_acl.c b/main/named_acl.c index 826313dcf7..e61bcba87b 100644 --- a/main/named_acl.c +++ b/main/named_acl.c @@ -128,7 +128,9 @@ static void *named_acl_config_alloc(void) 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; } diff --git a/main/pbx.c b/main/pbx.c index 434173d678..93bd9e6670 100644 --- a/main/pbx.c +++ b/main/pbx.c @@ -3907,7 +3907,7 @@ static int ast_add_hint(struct ast_exten *e) AST_VECTOR_INIT(&hint_new->devices, 8); /* 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) { ao2_ref(hint_new, -1); return -1; @@ -8753,15 +8753,17 @@ static void print_statecbs_key(void *v_obj, void *where, ao2_prnt_fn *prnt) 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) { 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) { ao2_container_register("hintdevices", hintdevices, print_hintdevices_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) { ao2_container_register("statecbs", statecbs, print_statecbs_key); } diff --git a/main/stasis.c b/main/stasis.c index 17055d8c16..f869821c3a 100644 --- a/main/stasis.c +++ b/main/stasis.c @@ -1286,8 +1286,8 @@ struct stasis_topic_pool *stasis_topic_pool_create(struct stasis_topic *pooled_t return NULL; } - pool->pool_container = ao2_container_alloc(TOPIC_POOL_BUCKETS, - topic_pool_entry_hash, topic_pool_entry_cmp); + pool->pool_container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + TOPIC_POOL_BUCKETS, topic_pool_entry_hash, NULL, topic_pool_entry_cmp); if (!pool->pool_container) { ao2_cleanup(pool); return NULL; diff --git a/main/stasis_channels.c b/main/stasis_channels.c index ed460cca4b..8c7a85f04c 100644 --- a/main/stasis_channels.c +++ b/main/stasis_channels.c @@ -613,8 +613,8 @@ struct ast_multi_channel_blob *ast_multi_channel_blob_create(struct ast_json *bl return NULL; } - obj->channel_snapshots = ao2_container_alloc(NUM_MULTI_CHANNEL_BLOB_BUCKETS, - channel_role_hash_cb, channel_role_cmp_cb); + obj->channel_snapshots = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + NUM_MULTI_CHANNEL_BLOB_BUCKETS, channel_role_hash_cb, NULL, channel_role_cmp_cb); if (!obj->channel_snapshots) { ao2_ref(obj, -1); return NULL; @@ -717,8 +717,9 @@ struct ao2_container *ast_multi_channel_blob_get_channels(struct ast_multi_chann return NULL; } - ret_container = ao2_container_alloc(NUM_MULTI_CHANNEL_BLOB_BUCKETS, - channel_snapshot_hash_cb, channel_snapshot_cmp_cb); + ret_container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + NUM_MULTI_CHANNEL_BLOB_BUCKETS, + channel_snapshot_hash_cb, NULL, channel_snapshot_cmp_cb); if (!ret_container) { return NULL; } diff --git a/main/taskprocessor.c b/main/taskprocessor.c index d475650a06..84c4d2bd16 100644 --- a/main/taskprocessor.c +++ b/main/taskprocessor.c @@ -280,7 +280,9 @@ static void tps_shutdown(void) /* initialize the taskprocessor container and register CLI operations */ 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"); return -1; } diff --git a/main/threadpool.c b/main/threadpool.c index 7729930545..2ab093663c 100644 --- a/main/threadpool.c +++ b/main/threadpool.c @@ -420,15 +420,18 @@ static struct ast_threadpool *threadpool_alloc(const char *name, const struct as if (!pool->control_tps) { 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) { 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) { 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) { return NULL; } diff --git a/main/xmldoc.c b/main/xmldoc.c index 37b2861523..27bf76bb60 100644 --- a/main/xmldoc.c +++ b/main/xmldoc.c @@ -2659,7 +2659,9 @@ struct ao2_container *ast_xmldoc_build_documentation(const char *type) struct documentation_tree *doctree; 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"); return NULL; } diff --git a/pbx/pbx_realtime.c b/pbx/pbx_realtime.c index 977898415c..e331781844 100644 --- a/pbx/pbx_realtime.c +++ b/pbx/pbx_realtime.c @@ -403,7 +403,9 @@ static int unload_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; } diff --git a/res/res_calendar.c b/res/res_calendar.c index e8ad499100..8962f47d79 100644 --- a/res/res_calendar.c +++ b/res/res_calendar.c @@ -409,7 +409,8 @@ static struct ast_calendar *build_calendar(struct ast_config *cfg, const char *c return NULL; } - if (!(cal->events = ao2_container_alloc(CALENDAR_BUCKETS, event_hash_fn, event_cmp_fn))) { + cal->events = ast_calendar_event_container_alloc(); + if (!cal->events) { ast_log(LOG_ERROR, "Could not allocate events container for %s\n", cat); cal = unref_calendar(cal); return NULL; @@ -672,7 +673,8 @@ struct ast_calendar_event *ast_calendar_event_alloc(struct ast_calendar *cal) 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) @@ -1865,7 +1867,9 @@ static int unload_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"); return AST_MODULE_LOAD_DECLINE; } diff --git a/res/res_clialiases.c b/res/res_clialiases.c index 355d437ab8..7032214872 100644 --- a/res/res_clialiases.c +++ b/res/res_clialiases.c @@ -284,7 +284,9 @@ static int unload_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; } diff --git a/res/res_config_sqlite3.c b/res/res_config_sqlite3.c index a033970344..6148d5d875 100644 --- a/res/res_config_sqlite3.c +++ b/res/res_config_sqlite3.c @@ -1185,7 +1185,9 @@ static int realtime_sqlite3_require(const char *database, const char *table, va_ 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); return -1; } @@ -1360,7 +1362,9 @@ static int load_module(void) { 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; } diff --git a/res/res_corosync.c b/res/res_corosync.c index af8afdb7f4..b1518c5feb 100644 --- a/res/res_corosync.c +++ b/res/res_corosync.c @@ -1127,7 +1127,8 @@ static int load_module(void) 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) { goto failed; } diff --git a/res/res_fax.c b/res/res_fax.c index ce5687da8c..b7aadc157d 100644 --- a/res/res_fax.c +++ b/res/res_fax.c @@ -4724,7 +4724,9 @@ static int load_module(void) /* initialize the registry */ faxregistry.active_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; } diff --git a/res/res_http_websocket.c b/res/res_http_websocket.c index 0ff876bfa6..d52e6b3383 100644 --- a/res/res_http_websocket.c +++ b/res/res_http_websocket.c @@ -154,7 +154,8 @@ static struct ast_websocket_server *websocket_server_create_impl(void (*dtor)(vo 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) { return NULL; } diff --git a/res/res_odbc.c b/res/res_odbc.c index 9622beb125..cd588ee69a 100644 --- a/res/res_odbc.c +++ b/res/res_odbc.c @@ -190,11 +190,6 @@ static void odbc_class_destructor(void *data) 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) { struct odbc_obj *obj = data; @@ -1066,7 +1061,8 @@ static int unload_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; if (load_odbc_config() == -1) return AST_MODULE_LOAD_DECLINE; diff --git a/res/res_parking.c b/res/res_parking.c index ddf8012454..f5279a8674 100644 --- a/res/res_parking.c +++ b/res/res_parking.c @@ -387,7 +387,9 @@ static void *parking_config_alloc(void) 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; } diff --git a/res/res_phoneprov.c b/res/res_phoneprov.c index 89fb29c2d4..7091b9be00 100644 --- a/res/res_phoneprov.c +++ b/res/res_phoneprov.c @@ -1414,13 +1414,15 @@ static int unload_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) { ast_log(LOG_ERROR, "Unable to allocate profiles container.\n"); 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) { ast_log(LOG_ERROR, "Unable to allocate routes container.\n"); goto error; @@ -1431,13 +1433,15 @@ static int load_module(void) 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) { ast_log(LOG_ERROR, "Unable to allocate users container.\n"); 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) { ast_log(LOG_ERROR, "Unable to allocate providers container.\n"); goto error; diff --git a/res/res_pjsip/config_transport.c b/res/res_pjsip/config_transport.c index 3ad4dcc42a..fed56f9dfa 100644 --- a/res/res_pjsip/config_transport.c +++ b/res/res_pjsip/config_transport.c @@ -1376,7 +1376,8 @@ static int populate_transport_states(void *obj, void *arg, int flags) 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) { return NULL; @@ -1393,7 +1394,8 @@ int ast_sip_initialize_sorcery_transport(void) struct ao2_container *transports = NULL; /* 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) { ast_log(LOG_ERROR, "Unable to allocate transport states container\n"); return -1; diff --git a/res/res_pjsip/pjsip_transport_management.c b/res/res_pjsip/pjsip_transport_management.c index e7483e6d61..89ad1fc0fa 100644 --- a/res/res_pjsip/pjsip_transport_management.c +++ b/res/res_pjsip/pjsip_transport_management.c @@ -354,8 +354,8 @@ int ast_sip_initialize_transport_management(void) { struct ao2_container *transports; - transports = ao2_container_alloc(TRANSPORTS_BUCKETS, monitored_transport_hash_fn, - monitored_transport_cmp_fn); + transports = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, TRANSPORTS_BUCKETS, + monitored_transport_hash_fn, NULL, monitored_transport_cmp_fn); if (!transports) { ast_log(LOG_ERROR, "Could not create container for transports to perform keepalive on.\n"); return AST_MODULE_LOAD_DECLINE; diff --git a/res/res_pjsip_mwi.c b/res/res_pjsip_mwi.c index f8c2392ec3..56225155eb 100644 --- a/res/res_pjsip_mwi.c +++ b/res/res_pjsip_mwi.c @@ -361,7 +361,8 @@ static struct mwi_subscription *mwi_subscription_alloc(struct ast_sip_endpoint * 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) { ao2_cleanup(sub); return NULL; diff --git a/res/res_pjsip_outbound_publish.c b/res/res_pjsip_outbound_publish.c index 2d49cd896c..820be54873 100644 --- a/res/res_pjsip_outbound_publish.c +++ b/res/res_pjsip_outbound_publish.c @@ -1074,7 +1074,8 @@ static struct ast_sip_outbound_publish_state *sip_outbound_publish_state_alloc( 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) { ao2_ref(state, -1); return NULL; diff --git a/res/res_pjsip_outbound_registration.c b/res/res_pjsip_outbound_registration.c index c42f59e50d..b73b5a76fe 100644 --- a/res/res_pjsip_outbound_registration.c +++ b/res/res_pjsip_outbound_registration.c @@ -2197,8 +2197,8 @@ static int load_module(void) } /* Create outbound registration states container. */ - new_states = ao2_container_alloc(DEFAULT_STATE_BUCKETS, - registration_state_hash, registration_state_cmp); + new_states = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + DEFAULT_STATE_BUCKETS, registration_state_hash, NULL, registration_state_cmp); if (!new_states) { ast_log(LOG_ERROR, "Unable to allocate registration states container\n"); unload_module(); diff --git a/res/res_pjsip_pubsub.c b/res/res_pjsip_pubsub.c index eb4545b113..ab3e4b20a3 100644 --- a/res/res_pjsip_pubsub.c +++ b/res/res_pjsip_pubsub.c @@ -1251,7 +1251,8 @@ static struct ast_sip_subscription *allocate_subscription(const struct ast_sip_s } strcpy(sub->resource, resource); /* Safe */ - sub->datastores = ao2_container_alloc(DATASTORE_BUCKETS, datastore_hash, datastore_cmp); + sub->datastores = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + DATASTORE_BUCKETS, datastore_hash, NULL, datastore_cmp); if (!sub->datastores) { destroy_subscription(sub); return NULL; @@ -2741,8 +2742,9 @@ int ast_sip_register_publish_handler(struct ast_sip_publish_handler *handler) return -1; } - if (!(handler->publications = ao2_container_alloc(PUBLICATIONS_BUCKETS, - publication_hash_fn, publication_cmp_fn))) { + handler->publications = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + 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", handler->event_name); return -1; @@ -3181,7 +3183,9 @@ static struct ast_sip_publication *sip_create_publication(struct ast_sip_endpoin ast_module_ref(ast_module_info->self); - if (!(publication->datastores = ao2_container_alloc(DATASTORE_BUCKETS, datastore_hash, datastore_cmp))) { + publication->datastores = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + DATASTORE_BUCKETS, datastore_hash, NULL, datastore_cmp); + if (!publication->datastores) { ao2_ref(publication, -1); return NULL; } diff --git a/res/res_pjsip_session.c b/res/res_pjsip_session.c index 669315f5cd..ee120995dc 100644 --- a/res/res_pjsip_session.c +++ b/res/res_pjsip_session.c @@ -1412,7 +1412,8 @@ struct ast_sip_session *ast_sip_session_alloc(struct ast_sip_endpoint *endpoint, if (!session->req_caps) { 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) { return NULL; } @@ -1434,7 +1435,8 @@ struct ast_sip_session *ast_sip_session_alloc(struct ast_sip_endpoint *endpoint, session->endpoint = ao2_bump(endpoint); - session->media = ao2_container_alloc(MEDIA_BUCKETS, session_media_hash, session_media_cmp); + session->media = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, MEDIA_BUCKETS, + session_media_hash, NULL, session_media_cmp); if (!session->media) { return NULL; } @@ -3267,8 +3269,8 @@ static int load_module(void) } nat_hook->outgoing_external_message = session_outgoing_nat_hook; ast_sorcery_create(ast_sip_get_sorcery(), nat_hook); - sdp_handlers = ao2_container_alloc(SDP_HANDLER_BUCKETS, - sdp_handler_list_hash, sdp_handler_list_cmp); + sdp_handlers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + SDP_HANDLER_BUCKETS, sdp_handler_list_hash, NULL, sdp_handler_list_cmp); if (!sdp_handlers) { return AST_MODULE_LOAD_DECLINE; } diff --git a/res/res_rtp_asterisk.c b/res/res_rtp_asterisk.c index 7b006cec9d..8841f6d6de 100644 --- a/res/res_rtp_asterisk.c +++ b/res/res_rtp_asterisk.c @@ -642,9 +642,12 @@ static void ast_rtp_ice_add_remote_candidate(struct ast_rtp_instance *instance, return; } - if (!rtp->ice_proposed_remote_candidates && - !(rtp->ice_proposed_remote_candidates = ao2_container_alloc(1, NULL, ice_candidate_cmp))) { - return; + if (!rtp->ice_proposed_remote_candidates) { + rtp->ice_proposed_remote_candidates = ao2_container_alloc_list( + 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 */ @@ -1059,8 +1062,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); - if (!rtp->ice_local_candidates && !(rtp->ice_local_candidates = ao2_container_alloc(1, NULL, ice_candidate_cmp))) { - return; + if (!rtp->ice_local_candidates) { + 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))) { diff --git a/res/res_sorcery_memory.c b/res/res_sorcery_memory.c index a05f05d9e8..953bcb282f 100644 --- a/res/res_sorcery_memory.c +++ b/res/res_sorcery_memory.c @@ -252,7 +252,8 @@ static int sorcery_memory_delete(const struct ast_sorcery *sorcery, void *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) diff --git a/res/res_sorcery_memory_cache.c b/res/res_sorcery_memory_cache.c index 9a1ade09f3..42da7273d3 100644 --- a/res/res_sorcery_memory_cache.c +++ b/res/res_sorcery_memory_cache.c @@ -3528,7 +3528,8 @@ static int load_module(void) { 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); if (!caches) { ast_log(LOG_ERROR, "Failed to create container for configured caches\n"); diff --git a/res/res_stasis.c b/res/res_stasis.c index 8362848103..127d0e8b78 100644 --- a/res/res_stasis.c +++ b/res/res_stasis.c @@ -2155,9 +2155,12 @@ static int load_module(void) if (STASIS_MESSAGE_TYPE_INIT(end_message_type) != 0) { return AST_MODULE_LOAD_DECLINE; } - apps_registry = ao2_container_alloc(APPS_NUM_BUCKETS, app_hash, app_compare); - app_controls = ao2_container_alloc(CONTROLS_NUM_BUCKETS, control_hash, control_compare); - app_bridges = ao2_container_alloc(BRIDGES_NUM_BUCKETS, bridges_hash, bridges_compare); + apps_registry = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + APPS_NUM_BUCKETS, app_hash, NULL, app_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( AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37, bridges_channel_hash_fn, NULL, NULL); diff --git a/res/res_stasis_device_state.c b/res/res_stasis_device_state.c index fbdfb3d525..d1a9bf764b 100644 --- a/res/res_stasis_device_state.c +++ b/res/res_stasis_device_state.c @@ -463,9 +463,10 @@ static int load_module(void) return AST_MODULE_LOAD_DECLINE; } - if (!(device_state_subscriptions = ao2_container_alloc( - DEVICE_STATE_BUCKETS, device_state_subscriptions_hash, - device_state_subscriptions_cmp))) { + device_state_subscriptions = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + DEVICE_STATE_BUCKETS, device_state_subscriptions_hash, NULL, + device_state_subscriptions_cmp); + if (!device_state_subscriptions) { ast_devstate_prov_del(DEVICE_STATE_PROVIDER_STASIS); return AST_MODULE_LOAD_DECLINE; } diff --git a/res/res_stasis_playback.c b/res/res_stasis_playback.c index 6a0e6c3cad..999e6d0ae0 100644 --- a/res/res_stasis_playback.c +++ b/res/res_stasis_playback.c @@ -667,8 +667,8 @@ static int load_module(void) return AST_MODULE_LOAD_DECLINE; } - playbacks = ao2_container_alloc(PLAYBACK_BUCKETS, playback_hash, - playback_cmp); + playbacks = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, PLAYBACK_BUCKETS, + playback_hash, NULL, playback_cmp); if (!playbacks) { STASIS_MESSAGE_TYPE_CLEANUP(stasis_app_playback_snapshot_type); return AST_MODULE_LOAD_DECLINE; diff --git a/res/res_stasis_recording.c b/res/res_stasis_recording.c index 93c32c97c4..66203dfd6b 100644 --- a/res/res_stasis_recording.c +++ b/res/res_stasis_recording.c @@ -636,8 +636,8 @@ static int load_module(void) return AST_MODULE_LOAD_DECLINE; } - recordings = ao2_container_alloc(RECORDING_BUCKETS, recording_hash, - recording_cmp); + recordings = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, RECORDING_BUCKETS, + recording_hash, NULL, recording_cmp); if (!recordings) { STASIS_MESSAGE_TYPE_CLEANUP(stasis_app_recording_snapshot_type); return AST_MODULE_LOAD_DECLINE; diff --git a/res/res_timing_pthread.c b/res/res_timing_pthread.c index f57c737f6a..eee0749442 100644 --- a/res/res_timing_pthread.c +++ b/res/res_timing_pthread.c @@ -442,8 +442,9 @@ static int init_timing_thread(void) static int load_module(void) { - if (!(pthread_timers = ao2_container_alloc(PTHREAD_TIMER_BUCKETS, - pthread_timer_hash, pthread_timer_cmp))) { + pthread_timers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + PTHREAD_TIMER_BUCKETS, pthread_timer_hash, NULL, pthread_timer_cmp); + if (!pthread_timers) { return AST_MODULE_LOAD_DECLINE; } diff --git a/res/res_xmpp.c b/res/res_xmpp.c index a85892fc85..2c2a0a9654 100644 --- a/res/res_xmpp.c +++ b/res/res_xmpp.c @@ -643,7 +643,9 @@ static struct ast_xmpp_client *xmpp_client_alloc(const char *name) 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); ao2_ref(client, -1); return NULL; @@ -709,7 +711,9 @@ static void *ast_xmpp_client_config_alloc(const char *cat) 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); return NULL; } @@ -727,14 +731,6 @@ static void xmpp_config_destructor(void *obj) 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 */ static int xmpp_config_cmp(void *obj, void *arg, int flags) { @@ -756,7 +752,9 @@ static void *xmpp_config_alloc(void) 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; } @@ -2256,7 +2254,9 @@ static struct ast_xmpp_buddy *xmpp_client_create_buddy(struct ao2_container *con 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); return NULL; } diff --git a/tests/test_astobj2.c b/tests/test_astobj2.c index 68f48ed3cc..98625946a8 100644 --- a/tests/test_astobj2.c +++ b/tests/test_astobj2.c @@ -714,9 +714,9 @@ AST_TEST_DEFINE(astobj2_test_2) 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) { - 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; goto cleanup; } diff --git a/tests/test_astobj2_thrash.c b/tests/test_astobj2_thrash.c index 324c4f4b9e..36e0ef706f 100644 --- a/tests/test_astobj2_thrash.c +++ b/tests/test_astobj2_thrash.c @@ -268,8 +268,8 @@ AST_TEST_DEFINE(hash_test) data.preload = MAX_HASH_ENTRIES / 2; data.max_grow = MAX_HASH_ENTRIES - data.preload; data.deadline = ast_tvadd(ast_tvnow(), ast_tv(MAX_TEST_SECONDS, 0)); - data.to_be_thrashed = ao2_container_alloc(HASH_BUCKETS, hash_string, - compare_strings); + data.to_be_thrashed = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, + HASH_BUCKETS, hash_string, NULL, compare_strings); if (data.to_be_thrashed == NULL) { ast_test_status_update(test, "Allocation failed\n"); diff --git a/tests/test_cel.c b/tests/test_cel.c index 9a3dc81148..1461f76e36 100644 --- a/tests/test_cel.c +++ b/tests/test_cel.c @@ -1839,8 +1839,8 @@ static int test_cel_init_cb(struct ast_test_info *info, struct ast_test *test) ast_cel_set_config(cel_test_config); /* init CEL event storage (degenerate hash table becomes a linked list) */ - cel_received_events = ao2_container_alloc(1, NULL, NULL); - cel_expected_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_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL); /* start the CEL event callback */ if (ast_cel_backend_register(TEST_BACKEND_NAME, test_sub)) { diff --git a/tests/test_config.c b/tests/test_config.c index 88e62bd51a..0d030f159f 100644 --- a/tests/test_config.c +++ b/tests/test_config.c @@ -1366,12 +1366,6 @@ struct test_config { 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) { struct test_item *one = obj, *two = arg; @@ -1424,7 +1418,8 @@ static void *test_config_alloc(void) if (!(cfg->global_defaults = test_item_alloc("global_defaults"))) { 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; } return cfg; diff --git a/tests/test_scoped_lock.c b/tests/test_scoped_lock.c index 1881bce7e1..0be86ebae8 100644 --- a/tests/test_scoped_lock.c +++ b/tests/test_scoped_lock.c @@ -199,8 +199,8 @@ AST_TEST_DEFINE(cleanup_order) enum ast_test_result_state res = AST_TEST_PASS; struct ao2_iterator iter; struct test_struct *object_iter; - RAII_VAR(struct ao2_container*, container, ao2_container_alloc(13, NULL, NULL), ao2_cleanup); - RAII_VAR(struct test_struct *, object, ao2_alloc(sizeof(*object), NULL), ao2_cleanup); + RAII_VAR(struct ao2_container*, container, NULL, ao2_cleanup); + RAII_VAR(struct test_struct *, object, NULL, ao2_cleanup); switch(cmd) { case TEST_INIT: @@ -216,6 +216,8 @@ AST_TEST_DEFINE(cleanup_order) } 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) { /* Allocation failure. We can't even pretend to do this test properly */ return AST_TEST_FAIL; -- 2.47.2