sorcery: Create function ast_sorcery_lockable_alloc.
authorCorey Farrell <git@cfware.com>
Fri, 26 Aug 2016 22:22:51 +0000 (18:22 -0400)
committerCorey Farrell <git@cfware.com>
Fri, 2 Sep 2016 13:26:25 +0000 (09:26 -0400)
Create an alternative to ast_sorcery_generic_alloc which uses astobj2
shared locking. Use this new method for the 'struct ast_sip_aor' allocator.

Change-Id: I3f62f2ada64b622571950278fbb6ad57395b5d6f

include/asterisk/sorcery.h
main/sorcery.c
res/res_pjsip/location.c
res/res_pjsip_registrar.c

index 23219ec..8966338 100644 (file)
@@ -988,10 +988,30 @@ int ast_sorcery_changeset_create(const struct ast_variable *original, const stru
  *
  * \retval non-NULL success
  * \retval NULL failure
+ *
+ * \note The returned object does not support AO2 locking.
  */
 void *ast_sorcery_generic_alloc(size_t size, ao2_destructor_fn destructor);
 
 /*!
+ * \since 14.1.0
+ * \brief Allocate a generic sorcery capable object with locking.
+ *
+ * \details Sorcery objects may be replaced with new allocations during reloads.
+ * If locking is required on sorcery objects it must be shared between the old
+ * object and the new one.  lockobj can be any AO2 object with locking enabled,
+ * but in most cases named locks should be used to provide stable locking.
+ *
+ * \param size Size of the object
+ * \param destructor Optional destructor function
+ * \param lockobj An AO2 object that will provide locking.
+ *
+ * \retval non-NULL success
+ * \retval NULL failure
+ */
+void *ast_sorcery_lockable_alloc(size_t size, ao2_destructor_fn destructor, void *lockobj);
+
+/*!
  * \brief Allocate an object
  *
  * \param sorcery Pointer to a sorcery structure
index 55ee830..9f8c35c 100644 (file)
@@ -1736,9 +1736,26 @@ static void sorcery_object_destructor(void *object)
        ast_free(details->object->id);
 }
 
+void *ast_sorcery_lockable_alloc(size_t size, ao2_destructor_fn destructor, void *lockobj)
+{
+       void *object = ao2_alloc_with_lockobj(size + sizeof(struct ast_sorcery_object),
+               sorcery_object_destructor, lockobj, "");
+       struct ast_sorcery_object_details *details = object;
+
+       if (!object) {
+               return NULL;
+       }
+
+       details->object = object + size;
+       details->object->destructor = destructor;
+
+       return object;
+}
+
 void *ast_sorcery_generic_alloc(size_t size, ao2_destructor_fn destructor)
 {
-       void *object = ao2_alloc_options(size + sizeof(struct ast_sorcery_object), sorcery_object_destructor, AO2_ALLOC_OPT_LOCK_NOLOCK);
+       void *object = ao2_alloc_options(size + sizeof(struct ast_sorcery_object),
+               sorcery_object_destructor, AO2_ALLOC_OPT_LOCK_NOLOCK);
        struct ast_sorcery_object_details *details = object;
 
        if (!object) {
index 0ab69ec..5abfcab 100644 (file)
@@ -49,11 +49,22 @@ static void aor_destroy(void *obj)
 /*! \brief Allocator for AOR */
 static void *aor_alloc(const char *name)
 {
-       struct ast_sip_aor *aor = ast_sorcery_generic_alloc(sizeof(struct ast_sip_aor), aor_destroy);
+       void *lock;
+       struct ast_sip_aor *aor;
+
+       lock = ast_named_lock_get(AST_NAMED_LOCK_TYPE_MUTEX, "aor", name);
+       if (!lock) {
+               return NULL;
+       }
+
+       aor = ast_sorcery_lockable_alloc(sizeof(struct ast_sip_aor), aor_destroy, lock);
+       ao2_ref(lock, -1);
+
        if (!aor) {
                return NULL;
        }
        ast_string_field_init(aor, 128);
+
        return aor;
 }
 
@@ -206,17 +217,11 @@ struct ao2_container *ast_sip_location_retrieve_aor_contacts_nolock(const struct
 struct ao2_container *ast_sip_location_retrieve_aor_contacts(const struct ast_sip_aor *aor)
 {
        struct ao2_container *contacts;
-       struct ast_named_lock *lock;
 
-       lock = ast_named_lock_get(AST_NAMED_LOCK_TYPE_MUTEX, "aor", ast_sorcery_object_get_id(aor));
-       if (!lock) {
-               return NULL;
-       }
-
-       ao2_lock(lock);
+       /* ao2_lock / ao2_unlock do not actually write aor since it has an ao2 lockobj. */
+       ao2_lock((void*)aor);
        contacts = ast_sip_location_retrieve_aor_contacts_nolock(aor);
-       ao2_unlock(lock);
-       ast_named_lock_put(lock);
+       ao2_unlock((void*)aor);
 
        return contacts;
 }
@@ -369,19 +374,12 @@ int ast_sip_location_add_contact(struct ast_sip_aor *aor, const char *uri,
                struct ast_sip_endpoint *endpoint)
 {
        int res;
-       struct ast_named_lock *lock;
-
-       lock = ast_named_lock_get(AST_NAMED_LOCK_TYPE_MUTEX, "aor", ast_sorcery_object_get_id(aor));
-       if (!lock) {
-               return -1;
-       }
 
-       ao2_lock(lock);
+       ao2_lock(aor);
        res = ast_sip_location_add_contact_nolock(aor, uri, expiration_time, path_info, user_agent,
                via_addr, via_port, call_id,
                endpoint);
-       ao2_unlock(lock);
-       ast_named_lock_put(lock);
+       ao2_unlock(aor);
 
        return res;
 }
index f99a3b8..47d5991 100644 (file)
@@ -523,25 +523,17 @@ static int register_aor(pjsip_rx_data *rdata,
 {
        int res;
        struct ao2_container *contacts = NULL;
-       struct ast_named_lock *lock;
 
-       lock = ast_named_lock_get(AST_NAMED_LOCK_TYPE_MUTEX, "aor", aor_name);
-       if (!lock) {
-               return PJ_TRUE;
-       }
-
-       ao2_lock(lock);
+       ao2_lock(aor);
        contacts = ast_sip_location_retrieve_aor_contacts_nolock(aor);
        if (!contacts) {
-               ao2_unlock(lock);
-               ast_named_lock_put(lock);
+               ao2_unlock(aor);
                return PJ_TRUE;
        }
 
        res = register_aor_core(rdata, endpoint, aor, aor_name, contacts);
        ao2_cleanup(contacts);
-       ao2_unlock(lock);
-       ast_named_lock_put(lock);
+       ao2_unlock(aor);
 
        return res;
 }