Revise the function name more intuitively

 - Check the return value of release callback

Change-Id: Id4221ee174b9a82477856fef598777e01dddb8c8

diff --git a/src/daemon/backend/murphy/mm_resource_manager_rset.c b/src/daemon/backend/murphy/mm_resource_manager_rset.c
index 4b675b75ce756ff5666bab89543ff9646da69761..6493888e267e24de12accebba194a5620ae1c9bc 100644 (file)
--- a/src/daemon/backend/murphy/mm_resource_manager_rset.c
+++ b/src/daemon/backend/murphy/mm_resource_manager_rset.c
@@ -141,7 +141,7 @@ int _mm_resource_manager_rset_acquire(mm_resource_manager_rset_s *rset)
        }
 
        gint64 end_time = g_get_monotonic_time() + RM_RESOURCE_TIMEOUT * G_TIME_SPAN_SECOND;
-       MM_RM_DEBUG("Waiting for aquire rset %p...", rset);
+       MM_RM_DEBUG("Waiting for acquire rset %p...", rset);
        if (!g_cond_wait_until(&rset->cond, &rset->lock, end_time)) {
                MM_RM_ERROR("Could not acquire rset %p", rset);
                ret = MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION;

diff --git a/src/daemon/mm_resource_manager_daemon_dbus.c b/src/daemon/mm_resource_manager_daemon_dbus.c
index cc57b04cab57ff72af903fc67af1f5ac3c455156..4330058cf10a13d34afaf827de9cd5448b3cd9a1 100644 (file)
--- a/src/daemon/mm_resource_manager_daemon_dbus.c
+++ b/src/daemon/mm_resource_manager_daemon_dbus.c
@@ -258,7 +258,8 @@ static void __gv2c_array(GVariantIter *gv, mm_resource_manager_dmn_res_request_s
                        break;
                }
 
-               MM_RM_DEBUG("(type, vol) = (%d, %d)", type, rs[i].volume);
+               if (type != MM_RESOURCE_MANAGER_NO_RES)
+                       MM_RM_DEBUG("(type, vol) = (%d, %d)", type, rs[i].volume);
        }
 
        *c = rs;

diff --git a/src/daemon/mm_resource_manager_daemon_priv.c b/src/daemon/mm_resource_manager_daemon_priv.c
index 63017a758ddbe0f57ac3690b13e308cd6e38cdc6..98a17e388d22bd75dd1830b1d2495847c7e87d84 100644 (file)
--- a/src/daemon/mm_resource_manager_daemon_priv.c
+++ b/src/daemon/mm_resource_manager_daemon_priv.c
@@ -77,11 +77,11 @@ static int __search_manager_index(mm_resource_manager_id id);
 static inline mm_resource_manager_dmn_p __search_manager(mm_resource_manager_id id);
 static mm_resource_manager_error_e __check_release_requests(
                mm_resource_manager_dmn_p manager,
-               mm_resource_manager_dmn_res_request_s *requests);
-static mm_resource_manager_dmn_res_request_s *__create_increase_requests(
+               mm_resource_manager_dmn_res_request_s *releases);
+static mm_resource_manager_dmn_res_request_s *__create_dmn_res_requests(
                mm_resource_manager_dmn_res_request_s *releases,
                mm_resource_manager_dmn_res_request_s *acquires);
-static mm_resource_manager_error_e __check_increase_requests(
+static mm_resource_manager_error_e __check_requests_conflict(
                mm_resource_manager_dmn_p manager,
                mm_resource_manager_dmn_res_request_s *requests);
 static void __sync_increase_acquire_requests(
@@ -227,18 +227,17 @@ mm_resource_manager_error_e _mmrm_dmn_commit(mm_resource_manager_id id,
        MM_RM_RETVM_IF(
                        (releases == NULL || releases[0].type == MM_RESOURCE_MANAGER_NO_RES) &&
                        (acquires == NULL || acquires[0].type == MM_RESOURCE_MANAGER_NO_RES),
-                       MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
-                       "Commit request is empty");
+                       MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Commit request is empty");
 
        ret = __check_release_requests(manager, releases);
        MM_RM_RETVM_IF(ret != MM_RESOURCE_MANAGER_ERROR_NONE, ret,
                "check_release_requests is failed [0x%x]", ret);
 
-       increases = __create_increase_requests(releases, acquires);
+       increases = __create_dmn_res_requests(releases, acquires);
        MM_RM_RETVM_IF(increases == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
                "create_increase_requests is failed");
 
-       ret = __check_increase_requests(manager, increases);
+       ret = __check_requests_conflict(manager, increases);
        if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
                __sync_increase_acquire_requests(increases, acquires);
                g_free(increases);
@@ -317,18 +316,18 @@ static inline mm_resource_manager_dmn_p __search_manager(mm_resource_manager_id
 }
 
 static mm_resource_manager_error_e __check_release_requests(mm_resource_manager_dmn_p manager,
-                       mm_resource_manager_dmn_res_request_s *requests)
+                       mm_resource_manager_dmn_res_request_s *releases)
 {
        int i;
        mm_resource_manager_conf_s *conf = mm_resource_manager_get_conf();
        mm_resource_manager_res_type_e type = MM_RESOURCE_MANAGER_RES_TYPE_MAX;
 
        MM_RM_RETVM_IF(conf == NULL, MM_RESOURCE_MANAGER_ERROR_NONE, "conf is null");
-       MM_RM_RETVM_IF(requests == NULL, MM_RESOURCE_MANAGER_ERROR_NONE, "requests is null");
+       MM_RM_RETVM_IF(releases == NULL, MM_RESOURCE_MANAGER_ERROR_NONE, "requests is null");
 
-       for (; requests->type != MM_RESOURCE_MANAGER_NO_RES; requests++) {
+       for (; releases->type != MM_RESOURCE_MANAGER_NO_RES; releases++) {
 
-               type = requests->type;
+               type = releases->type;
                const char *type_s = _mm_resource_manager_get_res_str(type);
 
                MM_RM_RETVM_IF(manager->resources[type] == NULL,
@@ -336,16 +335,15 @@ static mm_resource_manager_error_e __check_release_requests(mm_resource_manager_
 
                if (manager->resources[type]->is_acquired) {
                        if (manager->resources[type]->parts == NULL) {
-                               if (requests->volume != MM_RESOURCE_MANAGER_RES_VOLUME_FULL) {
+                               if (releases->volume != MM_RESOURCE_MANAGER_RES_VOLUME_FULL) {
                                        MM_RM_ERROR("Resource %s is acquired fully, but a resource part is tried to be released", type_s);
                                        return MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER;
                                }
                        } else {
                                for (i = 0; i < manager->resources[type]->parts->len &&
-                                       ((mm_resource_manager_res_volume*)manager->resources[type]->parts->data)[i]
-                                               != requests->volume; i++);
+                                       ((mm_resource_manager_res_volume*)manager->resources[type]->parts->data)[i] != releases->volume; i++);
                                if (i == manager->resources[type]->parts->len) {
-                                       MM_RM_ERROR("Part of %s of volume %d is not acquired", type_s, requests->volume);
+                                       MM_RM_ERROR("Part of %s of volume %d is not acquired", type_s, releases->volume);
                                        return MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER;
                                }
                        }
@@ -359,7 +357,7 @@ static mm_resource_manager_error_e __check_release_requests(mm_resource_manager_
        return MM_RESOURCE_MANAGER_ERROR_NONE;
 }
 
-static mm_resource_manager_dmn_res_request_s *__create_increase_requests(
+static mm_resource_manager_dmn_res_request_s *__create_dmn_res_requests(
                mm_resource_manager_dmn_res_request_s *releases, mm_resource_manager_dmn_res_request_s *acquires)
 {
        int i;
@@ -416,7 +414,7 @@ static mm_resource_manager_dmn_res_request_s *__create_increase_requests(
        return result;
 }
 
-static mm_resource_manager_error_e __check_increase_requests(mm_resource_manager_dmn_p manager,
+static mm_resource_manager_error_e __check_requests_conflict(mm_resource_manager_dmn_p manager,
                        mm_resource_manager_dmn_res_request_s *requests)
 {
        mm_resource_manager_res_volume remaining_volume;
@@ -559,8 +557,8 @@ static GArray *__handle_acquire_requests(mm_resource_manager_dmn_p manager,
 
                                        mm_resource_manager_backend_release(type);
 
-                                       MM_RM_INFO("Resource %s is released in RM %"PRIu64" available volume %d",
-                                               res_name, _mm_rm_hash64(i_mgr->id), conf->max_volume[type]);
+                                       MM_RM_INFO("Resource %s is released (%d) in RM %"PRIu64" available volume %d", res_name,
+                                               i_mgr->resources[type]->is_acquired, _mm_rm_hash64(i_mgr->id), conf->max_volume[type]);
                                }
                        }
                } else {

diff --git a/src/lib/mm_resource_manager_priv.c b/src/lib/mm_resource_manager_priv.c
index 6ce9630e269fadb81ec383e6246f0f881af230d6..8b16e018ac72defce54f8e951814a7c8ed4656ae 100644 (file)
--- a/src/lib/mm_resource_manager_priv.c
+++ b/src/lib/mm_resource_manager_priv.c
@@ -365,8 +365,7 @@ int _mm_resource_manager_mark_all_for_release(mm_resource_manager_h rm)
        __mm_resource_handles_unlock();
 
        for (i = 0; i < handle->resources->len; i++) {
-               if (!__mark_resource_for_release(handle->resources, i,
-                               (mm_resource_manager_res_p) handle->resources->pdata[i]))
+               if (!__mark_resource_for_release(handle->resources, i, (mm_resource_manager_res_p) handle->resources->pdata[i]))
                        i--;
        }
 
@@ -493,7 +492,7 @@ int _mm_resource_manager_get_type_max_instance(mm_resource_manager_h rm,
        return MM_RESOURCE_MANAGER_ERROR_NONE;
 }
 
-void __mm_resource_manager_release_callback(mm_resource_manager_s *handle,
+static void __mm_resource_manager_release_callback(mm_resource_manager_s *handle,
                mm_resource_manager_id id,
                mm_resource_manager_res_type_e type,
                mm_resource_manager_res_volume volume)
@@ -517,8 +516,7 @@ void __mm_resource_manager_release_callback(mm_resource_manager_s *handle,
                        if (resource->type == type && resource->volume == volume) {
 
                                release_all = ((mm_resource_manager_release_cb)
-                                               handle->release_cb.cb)(
-                                               handle, resource, handle->release_cb.user_data);
+                                               handle->release_cb.cb)(handle, resource, handle->release_cb.user_data);
 
                                __send_release_cb_sync(handle->id);
 
@@ -530,26 +528,24 @@ void __mm_resource_manager_release_callback(mm_resource_manager_s *handle,
 
                if (release_all) {
                        if (_mm_resource_manager_mark_all_for_release(handle) == MM_RESOURCE_MANAGER_ERROR_NONE &&
-                               _mm_resource_manager_commit(handle) == MM_RESOURCE_MANAGER_ERROR_NONE) {
+                               _mm_resource_manager_commit(handle) == MM_RESOURCE_MANAGER_ERROR_NONE)
                                MM_RM_DEBUG("All resources are released after release cb");
-                       } else {
+                       else
                                MM_RM_ERROR("Resources cannot be released after release cb");
-                       }
                }
        } else {
                __mm_resource_handles_unlock();
        }
 }
 
-void __mm_resource_manager_status_callback(mm_resource_manager_s *handle,
+static void __mm_resource_manager_status_callback(mm_resource_manager_s *handle,
                mm_resource_manager_status_e status)
 {
        __mm_resources_lock(handle);
        __mm_resource_handles_unlock();
-       if (handle->status_cb.cb) {
-               ((mm_resource_manager_status_cb)handle->status_cb.cb)(handle, status,
-                               handle->status_cb.user_data);
-       }
+       if (handle->status_cb.cb)
+               ((mm_resource_manager_status_cb)handle->status_cb.cb)(handle, status, handle->status_cb.user_data);
+
        __mm_resources_unlock(handle);
 }
 
@@ -634,11 +630,17 @@ static int __get_resource_index(mm_resource_manager_s *rm, mm_resource_manager_r
 {
        int i;
 
+       MM_RM_RETVM_IF(rm == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
+                       "NULL handle pointer");
+
        for (i = 0; i < rm->resources->len; i++) {
                if (rm->resources->pdata[i] == (gpointer) res)
                        return i;
        }
 
+       MM_RM_WARNING("[%d] Resource %p is marked for release in resource manager #%"PRIu64,
+               rm->resources->len, res, _mm_rm_hash64(rm->id));
+
        return MM_RESOURCE_MANAGER_RES_NOT_FOUND;
 }
 
@@ -657,10 +659,10 @@ static gboolean __mark_resource_for_release(GPtrArray *resources, int index,
                MM_RM_DEBUG("Resource %p is already marked", resource);
                break;
        }
+
        return TRUE;
 }
 
-
 static gboolean __check_rm_handle(mm_resource_manager_s *handle)
 {
        int i;
@@ -722,10 +724,8 @@ static int __dbus_init(mm_resource_manager_s *handle)
        g_main_context_pop_thread_default(handle->dispatcher_context);
        MM_RM_RET_IF_GERR(error, "Dbus proxy cannot be created");
 
-       if (g_signal_connect(handle->dbus_proxy, "release_callback",
-                       (GCallback)__dbus_release_callback, NULL) < 1 ||
-                       g_signal_connect(handle->dbus_proxy, "status_callback",
-                       (GCallback)__dbus_status_callback, NULL) < 1) {
+       if (g_signal_connect(handle->dbus_proxy, "release_callback", (GCallback)__dbus_release_callback, NULL) < 1 ||
+                       g_signal_connect(handle->dbus_proxy, "status_callback", (GCallback)__dbus_status_callback, NULL) < 1) {
 
                g_object_unref(handle->dbus_proxy);
                handle->dbus_proxy = NULL;
@@ -953,8 +953,7 @@ static void __dbus_release_callback(MMResourceManager *object, guint64 arg_id,
                MM_RM_HASH64(handle_id);
 
                if (handle->dbus_proxy == object && handle_id == arg_id) {
-                       __mm_resource_manager_release_callback(handle, arg_id,
-                                       arg_resource_type, arg_volume);
+                       __mm_resource_manager_release_callback(handle, arg_id, arg_resource_type, arg_volume);
                        return;
                }
        }

diff --git a/src/lib/mm_resource_manager_priv.h b/src/lib/mm_resource_manager_priv.h
index 10e3ac7e54bd3004e43fd445cbac239257c367f5..47364ad7ba044c33764943a51792c8b617321e17 100644 (file)
--- a/src/lib/mm_resource_manager_priv.h
+++ b/src/lib/mm_resource_manager_priv.h
@@ -27,31 +27,25 @@
 #include <fcntl.h>
 
 int _mm_resource_manager_create(mm_resource_manager_app_class_e app_class,
-               mm_resource_manager_release_cb cb, void *cb_data,
-               mm_resource_manager_h *rm);
+               mm_resource_manager_release_cb cb, void *cb_data, mm_resource_manager_h *rm);
 int _mm_resource_manager_destroy(mm_resource_manager_h rm);
 int _mm_resource_manager_mark_for_acquire(
                mm_resource_manager_h rm, mm_resource_manager_res_type_e type,
-               mm_resource_manager_res_volume volume,
-               mm_resource_manager_res_h *resource_h);
+               mm_resource_manager_res_volume volume, mm_resource_manager_res_h *resource_h);
 int _mm_resource_manager_resize_marked(mm_resource_manager_h rm,
-               mm_resource_manager_res_h resource_h,
-               mm_resource_manager_res_volume new_volume);
+               mm_resource_manager_res_h resource_h, mm_resource_manager_res_volume new_volume);
 int _mm_resource_manager_mark_for_release(mm_resource_manager_h rm,
                mm_resource_manager_res_h resource_h);
 int _mm_resource_manager_mark_all_for_release(mm_resource_manager_h rm);
 int _mm_resource_manager_get_resource_info(mm_resource_manager_h rm,
-               mm_resource_manager_res_h resource_h,
-               mm_resource_manager_res_info_s *info);
+               mm_resource_manager_res_h resource_h, mm_resource_manager_res_info_s *info);
 int _mm_resource_manager_commit(mm_resource_manager_h rm);
 int _mm_resource_manager_set_status_cb(mm_resource_manager_h rm,
                mm_resource_manager_status_cb cb, void *user_data);
 int _mm_resource_manager_get_res_type_max_volume(mm_resource_manager_h rm,
-               mm_resource_manager_res_type_e type,
-               mm_resource_manager_res_volume *max_volume);
+               mm_resource_manager_res_type_e type, mm_resource_manager_res_volume *max_volume);
 int _mm_resource_manager_get_res_type_volume(mm_resource_manager_h rm,
-               mm_resource_manager_res_type_e type,
-               mm_resource_manager_res_type_cond_e condition,
+               mm_resource_manager_res_type_e type, mm_resource_manager_res_type_cond_e condition,
                mm_resource_manager_res_volume *volume);
 int _mm_resource_manager_get_type_max_instance(mm_resource_manager_h rm,
                mm_resource_manager_res_type_e type, int *max_instance);