Update the resource name of log

Change-Id: I03bd19af2535abcd5ab63df65f75037642493b09

diff --git a/src/daemon/mm_resource_manager_daemon_priv.c b/src/daemon/mm_resource_manager_daemon_priv.c
index 968fca0..53011fb 100644 (file)
--- a/src/daemon/mm_resource_manager_daemon_priv.c
+++ b/src/daemon/mm_resource_manager_daemon_priv.c
@@ -193,7 +193,8 @@ mm_resource_manager_error_e _mmrm_dmn_destroy(mm_resource_manager_id id)
 
        g_ptr_array_remove_index_fast(managers, idx);
 
-       MM_RM_INFO("remaining managers #%d type %d available volume %d", managers->len, type, conf->max_volume[type]);
+       MM_RM_INFO("remaining managers #%d type %s available volume %d",
+               managers->len, _mm_resource_manager_get_res_str(type), conf->max_volume[type]);
 
 #ifdef RM_GCOV_TEST
        __gcov_flush();
@@ -337,7 +338,7 @@ static mm_resource_manager_error_e __check_release_requests(mm_resource_manager_
                        MM_RM_ERROR("Resource %s is not acquired", res_name);
                        return MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER;
                }
-               MM_RM_DEBUG("Release requests are OK type %d available volume %d", type, conf->max_volume[type]);
+               MM_RM_DEBUG("Release requests are OK type %s available volume %d", res_name, conf->max_volume[type]);
        }
 
        return MM_RESOURCE_MANAGER_ERROR_NONE;
@@ -378,7 +379,7 @@ static mm_resource_manager_dmn_res_request_s *__create_dmn_res_requests(
        for (; releases->type != MM_RESOURCE_MANAGER_NO_RES; releases++) {
                if (resources[releases->type] > 1) {
                        resources[releases->type] += releases->volume;
-                       MM_RM_INFO("type %d available volume %d", releases->type, resources[releases->type]);
+                       MM_RM_INFO("type %s available volume %d", _mm_resource_manager_get_res_str(releases->type), resources[releases->type]);
                }
        }
 
@@ -420,7 +421,7 @@ static mm_resource_manager_error_e __check_requests_conflict(mm_resource_manager
                res_name = _mm_resource_manager_get_res_str(type);
 
                MM_RM_RETVM_IF(type < MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_DECODER || type >= MM_RESOURCE_MANAGER_RES_TYPE_MAX,
-                       MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "wrong type %d", type);
+                       MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "wrong type %s", res_name);
                MM_RM_RETVM_IF(manager->resources[type] == NULL, MM_RESOURCE_MANAGER_ERROR_NOT_SUPPORTED,
                        "There is no resource %s for the platform", res_name);
 
@@ -549,9 +550,8 @@ static GArray *__handle_acquire_requests(mm_resource_manager_dmn_p manager,
                                }
                        }
                } else {
-                       MM_RM_INFO("[managers len #%d] [%s #%d (max inst #%d)] [%d (max vol %d) units of %s] are requested",
-                               managers->len, _mm_resource_manager_get_res_str(type), res_count[type] + 1,
-                               conf->max_instance[type], volume, conf->max_volume[type], res_name);
+                       MM_RM_INFO("[managers len #%d] [%s #%d (max inst #%d)] [%d (max vol %d)] are requested",
+                               managers->len, res_name, res_count[type] + 1, conf->max_instance[type], volume, conf->max_volume[type]);
 
                        if (conf->max_instance[type] > 0 && conf->max_instance[type] == res_count[type]) {
                                for (i= 0; i < managers->len; i++) {
@@ -581,7 +581,7 @@ static GArray *__handle_acquire_requests(mm_resource_manager_dmn_p manager,
                                                                i_mgr->type = type;
                                                                i_mgr->volume = volume;
                                                                conf->max_volume[type] -= volume;
-                                                               MM_RM_INFO("[type %d] - %d = %d", type, volume, conf->max_volume[type]);
+                                                               MM_RM_INFO("[type %s] - %d = %d", res_name, volume, conf->max_volume[type]);
                                                        }
 
                                                        if (conf->volume_would_be_checked[type] && conf->max_volume[type] < 0
@@ -640,6 +640,7 @@ static void __handle_release_callbacks(GArray *requests)
        mm_resource_manager_res_type_e type = MM_RESOURCE_MANAGER_RES_TYPE_MAX;
        mm_resource_manager_res_volume volume = MM_RESOURCE_MANAGER_RES_VOLUME_FULL;
        mm_resource_manager_dmn_p mgr = NULL;
+       const char *res_name = NULL;
        mm_resource_manager_conf_s *conf = mm_resource_manager_get_conf();
 
        MM_RM_RETM_IF(requests == NULL, "requests is NULL");
@@ -649,6 +650,7 @@ static void __handle_release_callbacks(GArray *requests)
                request = &g_array_index(requests, mm_resource_manager_dmn_release_cb_request_s, i);
                mgr = request->manager;
                type = request->type;
+               res_name = _mm_resource_manager_get_res_str(type);
                volume = request->volume;
 
                if (mgr->resources[type]->state != MM_RESOURCE_MANAGER_RES_STATE_ACQUIRED)
@@ -659,12 +661,11 @@ static void __handle_release_callbacks(GArray *requests)
 
                if (mgr->type == type && mgr->volume == volume && mgr->resources[type]->state == MM_RESOURCE_MANAGER_RES_STATE_FOR_RELEASE) {
                        MM_RM_WARNING("Resource (mgr %p) release callback is already invoked RM #%"PRIu64" for %s of volume %d",
-                               mgr, id, _mm_resource_manager_get_res_str(type), volume);
+                               mgr, id, res_name, volume);
                        continue;
                }
 
-               MM_RM_INFO("Sending release callback to [mgr %p] RM #%"PRIu64" for %s of volume %d",
-                               mgr, id, _mm_resource_manager_get_res_str(type), volume);
+               MM_RM_INFO("Sending release callback to [mgr %p] RM #%"PRIu64" for %s of volume %d", mgr, id, res_name, volume);
 
                _mmrm_dmn_dbus_release_callback(id, type, volume);
 
@@ -672,19 +673,19 @@ static void __handle_release_callbacks(GArray *requests)
                        MM_RM_INFO("[SYNC] Release callback success RM #%"PRIu64, id);
                        if (conf->volume_would_be_checked[type] && volume != MM_RESOURCE_MANAGER_RES_VOLUME_FULL) {
                                conf->max_volume[type] += volume;
-                               MM_RM_DEBUG("type %d available volume + %d = %d", type, volume, conf->max_volume[type]);
+                               MM_RM_DEBUG("type %s available volume + %d = %d", res_name, volume, conf->max_volume[type]);
                        }
 
                        if (conf->max_instance[type] > 0 && res_count[type] > 0) {
                                res_count[type]--;
-                               MM_RM_DEBUG("The number of type %d #%d", type, res_count[type]);
+                               MM_RM_DEBUG("The number of type %s #%d", res_name, res_count[type]);
                        }
 
                        mgr->resources[type]->state = MM_RESOURCE_MANAGER_RES_STATE_FOR_RELEASE;
                        MM_RM_DEBUG("RM #%"PRIu64" (type %s mgr %p) set acquired value as state (%s)",
-                               id, _mm_resource_manager_get_res_str(type), mgr, res_state_str[mgr->resources[type]->state]);
+                               id, res_name, mgr, res_state_str[mgr->resources[type]->state]);
                } else {
-                       MM_RM_ERROR("Wait for release callback sync failed RM #%"PRIu64" (type %s)", id, _mm_resource_manager_get_res_str(type));
+                       MM_RM_ERROR("Wait for release callback sync failed RM #%"PRIu64" (type %s)", id, res_name);
                }
        }
 }
@@ -696,6 +697,7 @@ static void __handle_release_requests(mm_resource_manager_dmn_p manager,
        int i;
        mm_resource_manager_res_type_e type = MM_RESOURCE_MANAGER_RES_TYPE_MAX;
        mm_resource_manager_res_volume volume = MM_RESOURCE_MANAGER_RES_VOLUME_FULL;
+       const char *res_name = NULL;
        mm_resource_manager_conf_s *conf = mm_resource_manager_get_conf();
 
        MM_RM_RETM_IF(conf == NULL, "conf is NULL");
@@ -704,6 +706,7 @@ static void __handle_release_requests(mm_resource_manager_dmn_p manager,
        for (; requests->type != MM_RESOURCE_MANAGER_NO_RES; requests++) {
 
                type = requests->type;
+               res_name = _mm_resource_manager_get_res_str(type);
                volume = requests->volume;
 
                if (volume == MM_RESOURCE_MANAGER_RES_VOLUME_FULL) {
@@ -723,12 +726,12 @@ static void __handle_release_requests(mm_resource_manager_dmn_p manager,
 
                if (conf->volume_would_be_checked[type]) {
                        conf->max_volume[type] += volume;
-                       MM_RM_INFO("[type %d] + %d = %d", type, volume, conf->max_volume[type]);
+                       MM_RM_INFO("[type %s] + %d = %d", res_name, volume, conf->max_volume[type]);
                }
 
-               if (conf->max_instance[type] > 0) {
+               if (conf->max_instance[type] > 0 && res_count[type] > 0) {
                        res_count[type]--;
-                       MM_RM_INFO("The number of type %d #%d", type, res_count[type]);
+                       MM_RM_INFO("The number of type %s #%d", res_name, res_count[type]);
                }
 
                mm_resource_manager_backend_release(type);

diff --git a/src/lib/mm_resource_manager_priv.c b/src/lib/mm_resource_manager_priv.c
index 8c430d1..0e76ccf 100644 (file)
--- a/src/lib/mm_resource_manager_priv.c
+++ b/src/lib/mm_resource_manager_priv.c
@@ -319,6 +319,7 @@ int _mm_resource_manager_mark_for_release(mm_resource_manager_h rm, mm_resource_
        mm_resource_manager_res_p resource;
        mm_resource_manager_id handle_id;
        int idx = 0;
+       const char *res_name = NULL;
 
        __mm_resource_handles_lock();
 
@@ -328,6 +329,7 @@ int _mm_resource_manager_mark_for_release(mm_resource_manager_h rm, mm_resource_
        MM_RM_HASH64(handle_id);
 
        resource = (mm_resource_manager_res_p)resource_h;
+       res_name = _mm_resource_manager_get_res_str(resource->type);
 
        MM_RM_DEBUG("[invoked : %d state : %s] Resource %p is marked for release in resource #%"PRIu64,
                handle->release_cb.is_invoked, res_state_str[resource->state], resource_h, handle_id);
@@ -337,14 +339,13 @@ int _mm_resource_manager_mark_for_release(mm_resource_manager_h rm, mm_resource_
 
        /* FIXME : We should consider resource lock's vulnerability because of using global variable of 'handles_lock' */
        if (handle->release_cb.is_invoked) {
-               MM_RM_DEBUG("Skip resource %p (%s) of RM #%"PRIu64" because release cb will be executed soon",
-                       resource, _mm_resource_manager_get_res_str(resource->type), handle_id);
+               MM_RM_DEBUG("Skip resource %p (%s) of RM #%"PRIu64" because release cb will be executed soon", resource, res_name, handle_id);
                __mm_resource_handles_unlock();
                resource->state = MM_RESOURCE_MANAGER_RES_STATE_FOR_RELEASE;
                return MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION;
        }
 
-       MM_RM_INFO("(%s) is marked for release in RM #%"PRIu64, _mm_resource_manager_get_res_str(resource->type), handle_id);
+       MM_RM_INFO("(%s) is marked for release in RM #%"PRIu64, res_name, handle_id);
 
        __mm_resources_lock(handle);
        __mm_resource_handles_unlock();
@@ -501,12 +502,15 @@ static void __mm_resource_manager_release_callback(mm_resource_manager_s *handle
        gboolean release_all = FALSE;
        int idx;
        int prev_len;
+       const char *res_name = NULL;
 
        handle_id = handle->id;
        MM_RM_HASH64(handle_id);
 
+       res_name = _mm_resource_manager_get_res_str(type);
+
        MM_RM_DEBUG("Release callback is invoked for %s of volume %d in handle RM #%"PRIu64" input RM #%"PRIu64,
-               _mm_resource_manager_get_res_str(type), volume, handle_id, id);
+               res_name, volume, handle_id, id);
 
        if (handle_id == id) {
                __mm_resources_lock(handle);
@@ -521,7 +525,7 @@ static void __mm_resource_manager_release_callback(mm_resource_manager_s *handle
                                /* FIXME : Set true in advance release callback invoking to prevent deadlock with resource marking */
                                handle->release_cb.is_invoked = TRUE;
 
-                               MM_RM_INFO("[res %p type %s volume %d] release_cb", resource, _mm_resource_manager_get_res_str(type), volume);
+                               MM_RM_INFO("[res %p type %s volume %d] release_cb", resource, res_name, volume);
                                release_all = ((mm_resource_manager_release_cb)handle->release_cb.cb)(handle, resource, handle->release_cb.user_data);
                                MM_RM_INFO("[%d] release_cb is completed", release_all);