const char *_mm_resource_manager_get_res_str(mm_resource_manager_res_type_e type)
{
- MM_RM_RETVM_IF(type < 0 || type >= MM_RESOURCE_MANAGER_RES_TYPE_MAX, "",
- "Type is out of range");
+ MM_RM_RETVM_IF(type < 0 || type >= MM_RESOURCE_MANAGER_RES_TYPE_MAX, "", "Type is out of range");
return mm_resource_manager_res_str[type];
}
const char *_mm_resource_manager_get_app_class_str(mm_resource_manager_app_class_e cls)
{
- MM_RM_RETVM_IF(cls < 0 || cls >= MM_RESOURCE_MANAGER_APP_CLASS_MAX, "",
- "App class is out of range");
+ MM_RM_RETVM_IF(cls < 0 || cls >= MM_RESOURCE_MANAGER_APP_CLASS_MAX, "", "App class is out of range");
return mm_resource_manager_app_class_str[cls];
}
const char *_mm_resource_manager_get_condition_str(mm_resource_manager_res_type_cond_e cond)
{
- MM_RM_RETVM_IF(cond < 0 || cond >= MM_RESOURCE_MANAGER_RES_TYPE_COND_MAX, "",
- "Resource type condition is out of range");
+ MM_RM_RETVM_IF(cond < 0 || cond >= MM_RESOURCE_MANAGER_RES_TYPE_COND_MAX, "", "Resource type condition is out of range");
return mm_resource_manager_condition_str[cond];
}
int mm_resource_manager_backend_acquire(mm_resource_manager_res_type_e type)
{
- MM_RM_RETVM_IF(type < MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_DECODER ||
- type >= MM_RESOURCE_MANAGER_RES_TYPE_MAX,
+ 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);
resources[type].ref_counter++;
int mm_resource_manager_backend_release(mm_resource_manager_res_type_e type)
{
- MM_RM_RETVM_IF(type < MM_RESOURCE_MANAGER_RES_TYPE_VIDEO_DECODER ||
- type >= MM_RESOURCE_MANAGER_RES_TYPE_MAX,
+ 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);
if (resources[type].ref_counter > 0)
static void __mm_resource_manager_mloop_error_cb(mm_resource_manager_mloop_s *mrp,
mm_resource_manager_mloop_error_e err, void *user_data);
static int __mm_resource_manager_add_resource(mm_resource_manager_res_type_e type);
-static void __mm_resource_manager_release_cb(mm_resource_manager_res_type_e type,
- void *user_data);
+static void __mm_resource_manager_release_cb(mm_resource_manager_res_type_e type, void *user_data);
if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
return ret;
- ret = _mm_resource_manager_mloop_set_error_cb(mrp,
- __mm_resource_manager_mloop_error_cb, NULL);
+ ret = _mm_resource_manager_mloop_set_error_cb(mrp, __mm_resource_manager_mloop_error_cb, NULL);
if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
return ret;
{
int ret;
- MM_RM_RETVM_IF(mrp == NULL,
- MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "mloop is NULL");
+ MM_RM_RETVM_IF(mrp == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "mloop is NULL");
ret = _mm_resource_manager_mloop_destroy(mrp);
mrp = NULL;
gboolean is_run = FALSE;
int ret = MM_RESOURCE_MANAGER_ERROR_NONE;
- MM_RM_RETVM_IF(rset[type] != NULL,
- MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
+ MM_RM_RETVM_IF(rset[type] != NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
"%s is already acquired", _mm_resource_manager_get_res_str(type));
ret = _mm_resource_manager_mloop_is_run(mrp, &is_run);
return ret;
}
- MM_RM_INFO("%s is acquired successfully",
- _mm_resource_manager_get_res_str(type));
+ MM_RM_INFO("%s is acquired successfully", _mm_resource_manager_get_res_str(type));
return MM_RESOURCE_MANAGER_ERROR_NONE;
}
gboolean is_run = FALSE;
int ret = MM_RESOURCE_MANAGER_ERROR_NONE;
- MM_RM_RETVM_IF(rset[type] == NULL,
- MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
+ MM_RM_RETVM_IF(rset[type] == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
"%s is not acquired", _mm_resource_manager_get_res_str(type));
ret = _mm_resource_manager_mloop_is_run(mrp, &is_run);
return ret;
}
- MM_RM_INFO("%s is released successfully",
- _mm_resource_manager_get_res_str(type));
+ MM_RM_INFO("%s is released successfully", _mm_resource_manager_get_res_str(type));
return MM_RESOURCE_MANAGER_ERROR_NONE;
}
kill(getpid(), SIGHUP);
}
-static int __mm_resource_manager_add_resource(
- mm_resource_manager_res_type_e type)
+static int __mm_resource_manager_add_resource(mm_resource_manager_res_type_e type)
{
int ret = MM_RESOURCE_MANAGER_ERROR_NONE;
- ret = _mm_resource_manager_rset_create(MM_RESOURCE_MANAGER_APP_CLASS_MEDIA,
- mrp, &rset[type]);
+ ret = _mm_resource_manager_rset_create(MM_RESOURCE_MANAGER_APP_CLASS_MEDIA, mrp, &rset[type]);
if (MM_RESOURCE_MANAGER_ERROR_NONE != ret) {
MM_RM_ERROR("Failed to create new resource set for resource type %d", type);
return ret;
}
- ret = _mm_resource_manager_rset_set_release_cb(rset[type],
- __mm_resource_manager_release_cb, NULL);
+ ret = _mm_resource_manager_rset_set_release_cb(rset[type], __mm_resource_manager_release_cb, NULL);
if (MM_RESOURCE_MANAGER_ERROR_NONE != ret) {
MM_RM_ERROR("Failed to set release callback to resource set %p 0x%x", rset[type], ret);
return ret;
return MM_RESOURCE_MANAGER_ERROR_NONE;
}
-static void __mm_resource_manager_release_cb(mm_resource_manager_res_type_e type,
- void *user_data)
+static void __mm_resource_manager_release_cb(mm_resource_manager_res_type_e type, void *user_data)
{
kill(getpid(), SIGHUP);
}
#include "daemon/mm_resource_manager_daemon_dbus.h"
#include "daemon/backend/murphy/mm_resource_manager_mloop.h"
-static void __mm_resource_manager_mloop_state_callback(mrp_res_context_t *context,
- mrp_res_error_t err, void *user_data);
+static void __mm_resource_manager_mloop_state_callback(mrp_res_context_t *context, mrp_res_error_t err, void *user_data);
static gboolean __mm_resource_manager_mloop_list_resources(mrp_res_context_t *context);
static int __mm_resource_manager_mloop_wait_connection(mm_resource_manager_mloop_s *mrp);
mm_resource_manager_mloop_s *handle = NULL;
int ret = MM_RESOURCE_MANAGER_ERROR_NONE;
- handle = (mm_resource_manager_mloop_s *) calloc(1,
- sizeof(mm_resource_manager_mloop_s));
- MM_RM_RETVM_IF(NULL == handle, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
- "Error allocating memory for Handle");
+ handle = (mm_resource_manager_mloop_s *) calloc(1, sizeof(mm_resource_manager_mloop_s));
+ MM_RM_RETVM_IF(NULL == handle, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION, "Error allocating memory for Handle");
g_mutex_init(&handle->lock);
g_cond_init(&handle->cond);
}
/* Wait while resource manager connects to Murphy.
- We assume that this condition is triggered only in case
- we successfully connected to Murphy. Otherwise an error
- is returned. And resulting handle is NULL */
+ We assume that this condition is triggered only in case
+ we successfully connected to Murphy. Otherwise an error
+ is returned. And resulting handle is NULL */
if (MM_RESOURCE_MANAGER_ERROR_NONE !=
__mm_resource_manager_mloop_wait_connection(handle)) {
_mm_resource_manager_mloop_destroy(handle);
-static void _mm_resource_manager_rset_state_callback(mrp_res_context_t *cx,
- const mrp_res_resource_set_t *rs, void *user_data);
-static void _mm_resource_manager_rset_release_cb(mrp_res_context_t *cx,
- const mrp_res_resource_set_t *rs, void *user_data);
+static void _mm_resource_manager_rset_state_callback(mrp_res_context_t *cx, const mrp_res_resource_set_t *rs, void *user_data);
+static void _mm_resource_manager_rset_release_cb(mrp_res_context_t *cx, const mrp_res_resource_set_t *rs, void *user_data);
#define RM_RESOURCE_TIMEOUT 5
mm_resource_manager_rset_s *handle = NULL;
handle = (mm_resource_manager_rset_s *) calloc(1, sizeof(mm_resource_manager_rset_s));
- MM_RM_RETVM_IF(NULL == handle, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
- "Error allocating memory for Handle");
+ MM_RM_RETVM_IF(NULL == handle, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION, "Error allocating memory for Handle");
- MM_RM_DEBUG("Creating rset with app_class %s",
- _mm_resource_manager_get_app_class_str(app_class));
- handle->mrp_rset = mrp_res_create_resource_set(mrp->mrp_ctx,
- _mm_resource_manager_get_app_class_str(app_class),
+ MM_RM_DEBUG("Creating rset with app_class %s", _mm_resource_manager_get_app_class_str(app_class));
+ handle->mrp_rset = mrp_res_create_resource_set(mrp->mrp_ctx, _mm_resource_manager_get_app_class_str(app_class),
_mm_resource_manager_rset_state_callback, handle);
if (!handle->mrp_rset) {
return MM_RESOURCE_MANAGER_ERROR_NONE;
}
-int _mm_resource_manager_rset_add_resource(mm_resource_manager_rset_s *rset,
- mm_resource_manager_res_type_e type)
+int _mm_resource_manager_rset_add_resource(mm_resource_manager_rset_s *rset, mm_resource_manager_res_type_e type)
{
mrp_res_resource_t *resource = NULL;
g_mutex_lock(&rset->lock);
- resource = mrp_res_create_resource(rset->mrp_rset,
- _mm_resource_manager_get_res_str(type), TRUE, FALSE);
+ resource = mrp_res_create_resource(rset->mrp_rset, _mm_resource_manager_get_res_str(type), TRUE, FALSE);
if (!resource) {
- MM_RM_ERROR("Failed to create resource type %d [%s]", type,
- _mm_resource_manager_get_res_str(type));
+ MM_RM_ERROR("Failed to create resource type %d [%s]", type, _mm_resource_manager_get_res_str(type));
g_mutex_unlock(&rset->lock);
return MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION;
}
return MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION;
}
- MM_RM_INFO("Successfully added resource type %d [%s]", type,
- _mm_resource_manager_get_res_str(type));
+ MM_RM_INFO("Successfully added resource type %d [%s]", type, _mm_resource_manager_get_res_str(type));
rset->type = type;
return ret;
}
-static void _mm_resource_manager_rset_release_cb(mrp_res_context_t *cx,
- const mrp_res_resource_set_t *rs, void *user_data)
+static void _mm_resource_manager_rset_release_cb(mrp_res_context_t *cx, const mrp_res_resource_set_t *rs, void *user_data)
{
mm_resource_manager_rset_s *rset = NULL;
if (pid != 0) {
/* Read in a string from the pipe */
- MM_RM_RETVM_IF(read(fds[0], msg, sizeof(msg)) < 0,
- FALSE, "Failed to create pipe to get child status");
+ MM_RM_RETVM_IF(read(fds[0], msg, sizeof(msg)) < 0, FALSE, "Failed to create pipe to get child status");
close(fds[0]);
close(fds[1]);
"Daemon fork&wait to set waiting until child process of fork actually completes failed");
umask(0);
- MM_RM_RETVM_IF(setsid() < 0, MM_RESOURCE_MANAGER_DAEMON_FAIL,
- "Daemon cannot set session id");
- MM_RM_RETVM_IF(chdir(path ? path : "/") < 0,
- MM_RESOURCE_MANAGER_DAEMON_FAIL, "Daemon cannot chdir");
-
- MM_RM_RETVM_IF(
- !freopen("/dev/null", "r", stdin) ||
- !freopen("/dev/null", "w", stdout) ||
- !freopen("/dev/null", "w", stderr),
- MM_RESOURCE_MANAGER_DAEMON_FAIL,
- "Daemon cannot redirect std streams");
+ MM_RM_RETVM_IF(setsid() < 0, MM_RESOURCE_MANAGER_DAEMON_FAIL, "Daemon cannot set session id");
+ MM_RM_RETVM_IF(chdir(path ? path : "/") < 0, MM_RESOURCE_MANAGER_DAEMON_FAIL, "Daemon cannot chdir");
+
+ MM_RM_RETVM_IF(!freopen("/dev/null", "r", stdin) || !freopen("/dev/null", "w", stdout) ||
+ !freopen("/dev/null", "w", stderr), MM_RESOURCE_MANAGER_DAEMON_FAIL, "Daemon cannot redirect std streams");
MM_RM_DEBUG("Daemonize succeeded");
switch (daemonize(NULL)) {
case MM_RESOURCE_MANAGER_DAEMON_NOW:
- MM_RM_RETVM_IF(!set_signal_handlers(), EXIT_FAILURE,
- "Daemon cannot set signal handlers");
+ MM_RM_RETVM_IF(!set_signal_handlers(), EXIT_FAILURE, "Daemon cannot set signal handlers");
#ifdef RM_GCOV_TEST
setenv("GCOV_PREFIX", "/tmp", 1);
daemon_loop();
- MM_RM_RETVM_IF(!remove_daemon_setup_file(), EXIT_FAILURE,
- "Daemon cannot remove setup file");
+ MM_RM_RETVM_IF(!remove_daemon_setup_file(), EXIT_FAILURE, "Daemon cannot remove setup file");
case MM_RESOURCE_MANAGER_DAEMON_PARENT:
return EXIT_SUCCESS;
int i, j;
ini = iniparser_load(MM_RESOURCE_MANAGER_INI_FILE);
- MM_RM_RETVM_IF(ini == NULL, FALSE,
- "Daemon cannot load conf file '%s'", MM_RESOURCE_MANAGER_INI_FILE);
+ MM_RM_RETVM_IF(ini == NULL, FALSE, "Daemon cannot load conf file '%s'", MM_RESOURCE_MANAGER_INI_FILE);
param_name = g_string_sized_new(64);
for (i = 0; i < MM_RESOURCE_MANAGER_RES_TYPE_MAX; i++) {
- mm_resource_manager_conf.max_volume[i] = iniparser_getint(ini,
- g_string_append(g_string_assign(param_name,
- MM_RESOURCE_MANAGER_INI_MAX_VOLUME),
- _mm_resource_manager_get_res_str(i))->str,
- MM_RESOURCE_MANAGER_NO_RES);
+ mm_resource_manager_conf.max_volume[i] = iniparser_getint(ini, g_string_append(g_string_assign(param_name,
+ MM_RESOURCE_MANAGER_INI_MAX_VOLUME), _mm_resource_manager_get_res_str(i))->str, MM_RESOURCE_MANAGER_NO_RES);
if (mm_resource_manager_conf.max_volume[i] >= 1) {
if (mm_resource_manager_conf.max_volume[i] > 1)
mm_resource_manager_conf.volume_would_be_checked[i] = TRUE;
for (j = 0; j < MM_RESOURCE_MANAGER_RES_TYPE_COND_MAX; j++) {
- g_string_printf(param_name, "%s:%s",
- _mm_resource_manager_get_res_str(i),
- _mm_resource_manager_get_condition_str(j));
- mm_resource_manager_conf.condition_volume[i][j] =
- iniparser_getint(ini, param_name->str,
- MM_RESOURCE_MANAGER_NO_RES);
+ g_string_printf(param_name, "%s:%s", _mm_resource_manager_get_res_str(i), _mm_resource_manager_get_condition_str(j));
+ mm_resource_manager_conf.condition_volume[i][j] = iniparser_getint(ini, param_name->str, MM_RESOURCE_MANAGER_NO_RES);
}
}
}
for (i = 0; i < MM_RESOURCE_MANAGER_APP_CLASS_MAX; i++) {
- mm_resource_manager_conf.priority[i] = iniparser_getint(ini,
- g_string_append(g_string_assign(param_name,
- MM_RESOURCE_MANAGER_INI_PRIORITY),
- _mm_resource_manager_get_app_class_str(i))->str,
- MM_RESOURCE_MANAGER_NO_APP_CLASS);
+ mm_resource_manager_conf.priority[i] = iniparser_getint(ini, g_string_append(g_string_assign(param_name,
+ MM_RESOURCE_MANAGER_INI_PRIORITY), _mm_resource_manager_get_app_class_str(i))->str, MM_RESOURCE_MANAGER_NO_APP_CLASS);
}
for (i = 0; i < MM_RESOURCE_MANAGER_RES_TYPE_MAX; i++) {
- mm_resource_manager_conf.max_instance[i] = iniparser_getint(ini,
- g_string_append(g_string_assign(param_name,
- MM_RESOURCE_MANAGER_INI_MAX_INSTANCE),
- _mm_resource_manager_get_res_str(i))->str,
- MM_RESOURCE_MANAGER_NO_RES);
+ mm_resource_manager_conf.max_instance[i] = iniparser_getint(ini, g_string_append(g_string_assign(param_name,
+ MM_RESOURCE_MANAGER_INI_MAX_INSTANCE), _mm_resource_manager_get_res_str(i))->str, MM_RESOURCE_MANAGER_NO_RES);
}
g_string_free(param_name, TRUE);
static void __gv2c_array(GVariantIter *gv, mm_resource_manager_dmn_res_request_s **c);
-static gboolean on_get_conf(MMResourceManager *interface,
- GDBusMethodInvocation *invocation, gpointer user_data);
+static gboolean on_get_conf(MMResourceManager *interface, GDBusMethodInvocation *invocation, gpointer user_data);
static gboolean on_create_handle(MMResourceManager *interface,
- GDBusMethodInvocation *invocation, const gint app_class,
- gpointer user_data);
+ GDBusMethodInvocation *invocation, const gint app_class, gpointer user_data);
static gboolean on_destroy_handle(MMResourceManager *interface,
GDBusMethodInvocation *invocation, const guint64 id, gpointer user_data);
static gboolean on_commit_handle(MMResourceManager *interface,
- GDBusMethodInvocation *invocation, const guint64 id,
- GVariant *release, GVariant *acquire, gpointer user_data);
-static void on_bus_acquired(GDBusConnection *connection, const gchar *name,
- gpointer user_data);
+ GDBusMethodInvocation *invocation, const guint64 id, GVariant *release, GVariant *acquire, gpointer user_data);
+static void on_bus_acquired(GDBusConnection *connection, const gchar *name, gpointer user_data);
static gboolean _type_is_valid(int type)
{
int _mmrm_dmn_dbus_init(void)
{
interface = mmresource_manager_skeleton_new();
- MM_RM_RETVM_IF(interface == NULL,
- MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
- "Interface cannot be created");
- g_bus_own_name(G_BUS_TYPE_SYSTEM, RMD_GDBUS_NAME,
- G_BUS_NAME_OWNER_FLAGS_NONE, on_bus_acquired, NULL, NULL, NULL,
- NULL);
+ MM_RM_RETVM_IF(interface == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION, "Interface cannot be created");
+ g_bus_own_name(G_BUS_TYPE_SYSTEM, RMD_GDBUS_NAME, G_BUS_NAME_OWNER_FLAGS_NONE, on_bus_acquired, NULL, NULL, NULL, NULL);
return MM_RESOURCE_MANAGER_ERROR_NONE;
}
int _mmrm_dmn_dbus_deinit(void)
{
- MM_RM_RETVM_IF(interface == NULL,
- MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION, "Interface is NULL");
+ MM_RM_RETVM_IF(interface == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION, "Interface is NULL");
g_object_unref(interface);
interface = NULL;
return MM_RESOURCE_MANAGER_ERROR_NONE;
conf = mm_resource_manager_get_conf();
- MM_RM_RETVM_IF(conf == NULL,
- MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
- "mm_resource_manager_conf is NULL");
+ MM_RM_RETVM_IF(conf == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION, "mm_resource_manager_conf is NULL");
*max_volume = conf->max_volume;
*cond_volume = &conf->condition_volume;
return MM_RESOURCE_MANAGER_ERROR_NONE;
}
-int _mmrm_dmn_dbus_create(mm_resource_manager_app_class_e app_class,
- mm_resource_manager_id *id)
+int _mmrm_dmn_dbus_create(mm_resource_manager_app_class_e app_class, mm_resource_manager_id *id)
{
return _mmrm_dmn_create(app_class, id);
}
return _mmrm_dmn_destroy(id);
}
-int _mmrm_dmn_dbus_commit(mm_resource_manager_id id, GVariantIter *release,
- GVariantIter *acquire, gboolean **is_acquired)
+int _mmrm_dmn_dbus_commit(mm_resource_manager_id id, GVariantIter *release, GVariantIter *acquire, gboolean **is_acquired)
{
int i;
int ret;
return ret;
}
-int _mmrm_dmn_dbus_release_callback(mm_resource_manager_id id,
- mm_resource_manager_res_type_e type,
+int _mmrm_dmn_dbus_release_callback(mm_resource_manager_id id, mm_resource_manager_res_type_e type,
mm_resource_manager_res_volume volume)
{
mmresource_manager_emit_release_callback(interface, id, type, volume);
*c = rs;
}
-static gboolean on_get_conf(MMResourceManager *interface,
- GDBusMethodInvocation *invocation, gpointer user_data)
+static gboolean on_get_conf(MMResourceManager *interface, GDBusMethodInvocation *invocation, gpointer user_data)
{
int i, j;
gint error = 0;
}
static gboolean on_create_handle(MMResourceManager *interface,
- GDBusMethodInvocation *invocation, const gint app_class,
- gpointer user_data)
+ GDBusMethodInvocation *invocation, const gint app_class, gpointer user_data)
{
guint64 id = 0;
gint error = 0;
return TRUE;
}
-static gboolean on_commit_handle(MMResourceManager *interface,
- GDBusMethodInvocation *invocation, const guint64 id,
- GVariant *release, GVariant *acquire, gpointer user_data)
+static gboolean on_commit_handle(MMResourceManager *interface, GDBusMethodInvocation *invocation,
+ const guint64 id, GVariant *release, GVariant *acquire, gpointer user_data)
{
gint error = 0;
gboolean ret = TRUE, *flags = NULL;
return ret;
}
-static void on_bus_acquired(GDBusConnection *connection, const gchar *name,
- gpointer user_data)
+static void on_bus_acquired(GDBusConnection *connection, const gchar *name, gpointer user_data)
{
GError *error = NULL;
MM_RM_DEBUG("name of bus = %s, userID = %d", name, getuid());
g_signal_connect(interface, "handle-destroy", G_CALLBACK(on_destroy_handle), NULL);
g_signal_connect(interface, "handle-commit", G_CALLBACK(on_commit_handle), NULL);
- if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(interface),
- connection, RMD_GDBUS_PATH, &error)) {
+ if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(interface), connection, RMD_GDBUS_PATH, &error)) {
MM_RM_ERROR("failed to export interface. msg : %s", error->message);
g_error_free(error);
return;
static void __destroy_manager(void *m);
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,
+static mm_resource_manager_error_e __check_release_requests(mm_resource_manager_dmn_p manager,
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_requests_conflict(
- mm_resource_manager_dmn_p manager,
+ mm_resource_manager_dmn_res_request_s *releases, mm_resource_manager_dmn_res_request_s *acquires);
+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(
- mm_resource_manager_dmn_res_request_s *increases,
+static void __sync_increase_acquire_requests(mm_resource_manager_dmn_res_request_s *increases,
mm_resource_manager_dmn_res_request_s *acquires);
-static void __handle_release_requests(mm_resource_manager_dmn_p manager,
- mm_resource_manager_dmn_res_request_s *requests);
-static GArray* __handle_acquire_requests(mm_resource_manager_dmn_p manager,
- mm_resource_manager_dmn_res_request_s *requests);
+static void __handle_release_requests(mm_resource_manager_dmn_p manager, mm_resource_manager_dmn_res_request_s *requests);
+static GArray* __handle_acquire_requests(mm_resource_manager_dmn_p manager, mm_resource_manager_dmn_res_request_s *requests);
static void __handle_release_callbacks(GArray *requests);
static inline void __add_cb_request(GArray *cb_requests, mm_resource_manager_dmn_p mgr,
mm_resource_manager_res_type_e type, mm_resource_manager_res_volume volume);
MM_RM_RETVMS_IF(access(RELEASE_CB_SYNC_PATH, F_OK) != 0, FALSE,
"systemd-tmpfiles-setup.service can't create %s", RELEASE_CB_SYNC_PATH);
- MM_RM_RETVM_IF(mm_resource_manager_backend_init() !=
- MM_RESOURCE_MANAGER_ERROR_NONE, FALSE,
- "Back-end cannot be initialized");
+ MM_RM_RETVM_IF(mm_resource_manager_backend_init() != MM_RESOURCE_MANAGER_ERROR_NONE, FALSE, "Back-end cannot be initialized");
if (_mmrm_dmn_dbus_init() != MM_RESOURCE_MANAGER_ERROR_NONE) {
mm_resource_manager_backend_deinit();
return FALSE;
}
- managers = g_ptr_array_new_full(MM_RESOURCE_MANAGER_RESERVED_RM_ARRAY_SIZE,
- __destroy_manager);
+ managers = g_ptr_array_new_full(MM_RESOURCE_MANAGER_RESERVED_RM_ARRAY_SIZE, __destroy_manager);
MM_RM_RETVM_IF(managers == NULL, FALSE, "Daemon cannot be initialized");
return TRUE;
mm_resource_manager_conf_s *conf = mm_resource_manager_get_conf();
int i;
- MM_RM_RETVM_IF(app_class < 0 ||
- app_class >= MM_RESOURCE_MANAGER_APP_CLASS_MAX,
+ MM_RM_RETVM_IF(app_class < 0 || app_class >= MM_RESOURCE_MANAGER_APP_CLASS_MAX,
MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Wrong app class");
- MM_RM_RETVM_IF(conf->priority[app_class] ==
- MM_RESOURCE_MANAGER_NO_APP_CLASS,
- MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "App class is not supported for the platform");
+ MM_RM_RETVM_IF(conf->priority[app_class] == MM_RESOURCE_MANAGER_NO_APP_CLASS,
+ MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "App class is not supported for the platform");
mgr = g_new0(mm_resource_manager_dmn_s, 1);
MM_RM_RAND64(mgr->id);
}
mm_resource_manager_error_e _mmrm_dmn_commit(mm_resource_manager_id id,
- mm_resource_manager_dmn_res_request_s *releases,
- mm_resource_manager_dmn_res_request_s *acquires)
+ mm_resource_manager_dmn_res_request_s *releases, mm_resource_manager_dmn_res_request_s *acquires)
{
mm_resource_manager_dmn_p manager = __search_manager(id);
mm_resource_manager_error_e ret = MM_RESOURCE_MANAGER_ERROR_NONE;
MM_RM_RETVM_IF(manager == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
"Resource manager #%"PRIu64" doesn't exist", _mm_rm_hash64(id));
- MM_RM_RETVM_IF(
- (releases == NULL || releases[0].type == MM_RESOURCE_MANAGER_NO_RES) &&
+ 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");
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);
+ MM_RM_RETVM_IF(ret != MM_RESOURCE_MANAGER_ERROR_NONE, ret, "check_release_requests is failed [0x%x]", ret);
increases = __create_dmn_res_requests(releases, acquires);
- MM_RM_RETVM_IF(increases == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
- "create_increase_requests is failed");
+ MM_RM_RETVM_IF(increases == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION, "create_increase_requests is failed");
ret = __check_requests_conflict(manager, increases);
if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
__handle_release_requests(manager, releases);
cb_requests = __handle_acquire_requests(manager, acquires);
- MM_RM_RETVM_IF(cb_requests == NULL, MM_RESOURCE_MANAGER_ERROR_NOT_ENOUGH,
- "not enough free resource volume");
+ MM_RM_RETVM_IF(cb_requests == NULL, MM_RESOURCE_MANAGER_ERROR_NOT_ENOUGH, "not enough free resource volume");
__handle_release_callbacks(cb_requests);
if (!mm_resource_manager_backend_commit_all()) {
/*
- * The commit_all
- * function can fail only if resource management back-end is not solely
- * used by mm-resource-manager or if the back-end cannot acquire/release
- * a resource because of some internal error.
+ * The commit_all function can fail only if resource management back-end is not solely used by mm-resource-manager or
+ * if the back-end cannot acquire/release a resource because of some internal error.
*
- * Initiate status disconnected and reload the back-end and the RM
- * daemon.
+ * Initiate status disconnected and reload the back-end and the RM daemon.
*/
kill(getpid(), SIGHUP);
ret = MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION;
if ((resources[acquires->type] > 0 || resources[acquires->type] == MM_RESOURCE_MANAGER_RES_VOLUME_FULL) &&
acquires->volume == MM_RESOURCE_MANAGER_RES_VOLUME_FULL) {
- MM_RM_ERROR("The client tries to acquire %s by part and fully at once",
- _mm_resource_manager_get_res_str(acquires->type));
+ MM_RM_ERROR("The client tries to acquire %s by part and fully at once", _mm_resource_manager_get_res_str(acquires->type));
return NULL;
}
type = requests->type;
const char *type_s = _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_RM_RETVM_IF(manager->resources[type] == NULL,
- MM_RESOURCE_MANAGER_ERROR_NOT_SUPPORTED,
- "There is no resource %s for the platform", type_s);
+ 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_RM_RETVM_IF(manager->resources[type] == NULL, MM_RESOURCE_MANAGER_ERROR_NOT_SUPPORTED,
+ "There is no resource %s for the platform", type_s);
remaining_volume = conf->max_volume[type];
return MM_RESOURCE_MANAGER_ERROR_LOW_PRIORITY;
} else {
for (j = 0; j < i_mgr->resources[type]->parts->len; j++)
- remaining_volume -= g_array_index(i_mgr->resources[type]->parts,
- mm_resource_manager_res_volume, j);
+ remaining_volume -= g_array_index(i_mgr->resources[type]->parts, mm_resource_manager_res_volume, j);
if (remaining_volume < requests->volume) {
requests->priority_error = TRUE;
#include <unistd.h>
int mm_resource_manager_create(mm_resource_manager_app_class_e app_class,
- mm_resource_manager_release_cb release_cb, void *cb_user_data,
- mm_resource_manager_h *rm)
+ mm_resource_manager_release_cb release_cb, void *cb_user_data, mm_resource_manager_h *rm)
{
- MM_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Handle is NULL");
- MM_RM_RETVM_IF(app_class < 0 ||
- app_class >= MM_RESOURCE_MANAGER_APP_CLASS_MAX,
+ MM_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ MM_RM_RETVM_IF(app_class < 0 || app_class >= MM_RESOURCE_MANAGER_APP_CLASS_MAX,
MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Wrong app class");
- MM_RM_RETVM_IF(NULL == release_cb, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Callback is NULL");
+ MM_RM_RETVM_IF(NULL == release_cb, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Callback is NULL");
MM_RM_RETVM_IF(access(MM_RESOURCE_MANAGER_READY, F_OK) != 0,
MM_RESOURCE_MANAGER_ERROR_LAUNCH_FAILURE, "Resource Manager Launch Failure");
int mm_resource_manager_destroy(mm_resource_manager_h rm)
{
- MM_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Handle is NULL");
+ MM_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Handle is NULL");
return _mm_resource_manager_destroy(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)
+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_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Handle is NULL");
+ MM_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Handle is NULL");
MM_RM_RETVM_IF(type < 0 || type >= MM_RESOURCE_MANAGER_RES_TYPE_MAX,
- MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Wrong resource type");
+ MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Wrong resource type");
MM_RM_RETVM_IF(volume <= 0 && volume != MM_RESOURCE_MANAGER_RES_VOLUME_FULL,
- MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Wrong resource part volume");
- MM_RM_RETVM_IF(resource_h == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Resource handle is NULL");
+ MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Wrong resource part volume");
+ MM_RM_RETVM_IF(resource_h == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Resource handle is NULL");
return _mm_resource_manager_mark_for_acquire(rm, type, volume, 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)
{
- MM_RM_RETVM_IF(rm == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Resource manager handle is NULL");
- MM_RM_RETVM_IF(resource_h == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Resource handle is NULL");
- MM_RM_RETVM_IF(new_volume <= 0 &&
- new_volume != MM_RESOURCE_MANAGER_RES_VOLUME_FULL,
- MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Wrong resource part volume");
+ MM_RM_RETVM_IF(rm == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Resource manager handle is NULL");
+ MM_RM_RETVM_IF(resource_h == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Resource handle is NULL");
+ MM_RM_RETVM_IF(new_volume <= 0 && new_volume != MM_RESOURCE_MANAGER_RES_VOLUME_FULL,
+ MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Wrong resource part volume");
return _mm_resource_manager_resize_marked(rm, resource_h, 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_for_release(mm_resource_manager_h rm, mm_resource_manager_res_h resource_h)
{
- MM_RM_RETVM_IF(rm == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Resource manager handle is NULL");
- MM_RM_RETVM_IF(resource_h == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Resource handle is NULL");
+ MM_RM_RETVM_IF(rm == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Resource manager handle is NULL");
+ MM_RM_RETVM_IF(resource_h == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Resource handle is NULL");
return _mm_resource_manager_mark_for_release(rm, resource_h);
}
int mm_resource_manager_mark_all_for_release(mm_resource_manager_h rm)
{
- MM_RM_RETVM_IF(rm == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Handle is NULL");
+ MM_RM_RETVM_IF(rm == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Handle is NULL");
return _mm_resource_manager_mark_all_for_release(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)
{
- MM_RM_RETVM_IF(rm == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Resource manager handle is NULL");
- MM_RM_RETVM_IF(resource_h == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Resource handle is NULL");
- MM_RM_RETVM_IF(info == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Info structure is NULL");
+ MM_RM_RETVM_IF(rm == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Resource manager handle is NULL");
+ MM_RM_RETVM_IF(resource_h == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Resource handle is NULL");
+ MM_RM_RETVM_IF(info == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Info structure is NULL");
return _mm_resource_manager_get_resource_info(rm, resource_h, info);
}
int mm_resource_manager_commit(mm_resource_manager_h rm)
{
- MM_RM_RETVM_IF(rm == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Handle is NULL");
+ MM_RM_RETVM_IF(rm == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Handle is NULL");
return _mm_resource_manager_commit(rm);
}
int mm_resource_manager_set_status_cb(mm_resource_manager_h rm,
mm_resource_manager_status_cb cb, void *user_data)
{
- MM_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Handle is NULL");
+ MM_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Handle is NULL");
return _mm_resource_manager_set_status_cb(rm, cb, 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)
{
- MM_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Handle is NULL");
+ MM_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Handle is NULL");
MM_RM_RETVM_IF(type < 0 || type >= MM_RESOURCE_MANAGER_RES_TYPE_MAX,
- MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Wrong resource type");
- MM_RM_RETVM_IF(max_volume == NULL,
- MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Max volume var is NULL");
+ MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Wrong resource type");
+ MM_RM_RETVM_IF(max_volume == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Max volume var is NULL");
return _mm_resource_manager_get_res_type_max_volume(rm, type, 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_volume *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_volume *volume)
{
- MM_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Handle is NULL");
+ MM_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Handle is NULL");
MM_RM_RETVM_IF(type < 0 || type >= MM_RESOURCE_MANAGER_RES_TYPE_MAX,
- MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Wrong resource type");
+ MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Wrong resource type");
MM_RM_RETVM_IF(condition < 0 || condition >= MM_RESOURCE_MANAGER_RES_TYPE_COND_MAX,
- MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Wrong resource condition");
- MM_RM_RETVM_IF(volume == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Volume var is NULL");
+ MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Wrong resource condition");
+ MM_RM_RETVM_IF(volume == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Volume var is NULL");
return _mm_resource_manager_get_res_type_volume(rm, type, condition, volume);
}
-int mm_resource_manager_get_type_max_instance(mm_resource_manager_h rm,
- mm_resource_manager_res_type_e type, int *max_instance)
+int mm_resource_manager_get_type_max_instance(mm_resource_manager_h rm, mm_resource_manager_res_type_e type, int *max_instance)
{
MM_RM_RETVM_IF(NULL == rm, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Handle is NULL");
MM_RM_RETVM_IF(type < 0 || type >= MM_RESOURCE_MANAGER_RES_TYPE_MAX,
static void __init_lib() __attribute__((constructor));
static void __deinit_lib() __attribute__((destructor));
-static int __check_resource(mm_resource_manager_s *rm,
- mm_resource_manager_res_type_e type,
- mm_resource_manager_res_volume volume);
-static int __create_resource(mm_resource_manager_s *rm,
- mm_resource_manager_res_type_e type,
+static int __check_resource(mm_resource_manager_s *rm, mm_resource_manager_res_type_e type, mm_resource_manager_res_volume volume);
+static int __create_resource(mm_resource_manager_s *rm, mm_resource_manager_res_type_e type,
mm_resource_manager_res_volume volume, mm_resource_manager_res_p *res);
static void __destroy_resource(void *res);
static int __get_resource_index(mm_resource_manager_s *rm,
mm_resource_manager_res_p res);
-static gboolean __mark_resource_for_release(GPtrArray *resources, int index,
- mm_resource_manager_res_p resource); /* FALSE if resource is destroyed */
+ /* FALSE if resource is destroyed */
+static gboolean __mark_resource_for_release(GPtrArray *resources, int index, mm_resource_manager_res_p resource);
static void __send_release_cb_sync(mm_resource_manager_id id);
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);
-static void __mm_resource_manager_status_callback(mm_resource_manager_s *handle,
- mm_resource_manager_status_e status);
+ mm_resource_manager_id id, mm_resource_manager_res_type_e type, mm_resource_manager_res_volume volume);
+static void __mm_resource_manager_status_callback(mm_resource_manager_s *handle, mm_resource_manager_status_e status);
static void __mm_resource_handles_lock(void);
static void __mm_resource_handles_unlock(void);
static void __mm_resources_lock(mm_resource_manager_s *h);
static int __dbus_deinit(mm_resource_manager_s *handle);
static int __dbus_init_conf(mm_resource_manager_s *handle);
static gboolean __check_rm_handle(mm_resource_manager_s *handle);
-static int __dbus_create(mm_resource_manager_s *handle,
- mm_resource_manager_app_class_e app_class);
+static int __dbus_create(mm_resource_manager_s *handle, mm_resource_manager_app_class_e app_class);
static int __dbus_destroy(mm_resource_manager_s *handle);
static int __dbus_commit(mm_resource_manager_s *handle);
-static void __dbus_release_callback(MMResourceManager *object, guint64 arg_id,
- gint arg_resource_type, gint arg_volume);
+static void __dbus_release_callback(MMResourceManager *object, guint64 arg_id, gint arg_resource_type, gint arg_volume);
static void __dbus_status_callback(MMResourceManager *object, gint arg_status);
static gpointer __dispatcher_thread(gpointer user_data);
static void __destroy_dispatcher(mm_resource_manager_s *handle);
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)
{
mm_resource_manager_s *handle = *rm = NULL;
int ret;
GError *error = NULL;
handle = (mm_resource_manager_s *) calloc(1, sizeof(mm_resource_manager_s));
- MM_RM_RETVM_IF(NULL == handle, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
- "Error allocating memory for Handle");
+ MM_RM_RETVM_IF(NULL == handle, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION, "Error allocating memory for Handle");
handle->dispatcher_context = g_main_context_new();
if (!handle->dispatcher_context) {
handle->release_cb.cb = cb;
handle->release_cb.user_data = cb_data;
- handle->resources = g_ptr_array_new_full(
- MM_RESOURCE_MANAGER_RESERVED_RES_ARRAY_SIZE, __destroy_resource);
+ handle->resources = g_ptr_array_new_full(MM_RESOURCE_MANAGER_RESERVED_RES_ARRAY_SIZE, __destroy_resource);
g_mutex_init(&handle->resources_lock);
return ret;
}
-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)
+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)
{
int ret = MM_RESOURCE_MANAGER_ERROR_NONE;
mm_resource_manager_s *handle = MM_RESOURCE_MANAGER(rm);
__mm_resource_handles_unlock();
ret = __create_resource(handle, type, volume, &resource);
- MM_RM_UNLOCK_RETVM_IF(ret != MM_RESOURCE_MANAGER_ERROR_NONE,
- handle->resources_lock, ret, "Resource cannot be created");
+ MM_RM_UNLOCK_RETVM_IF(ret != MM_RESOURCE_MANAGER_ERROR_NONE, handle->resources_lock, ret, "Resource cannot be created");
g_ptr_array_add(handle->resources, resource);
*resource_h = resource;
- MM_RM_INFO("Resource %p of type %d with volume %d is marked for acquire in "
- "resource manager #%"PRIu64, *resource_h, type, volume,
- _mm_rm_hash64(handle->id));
+ MM_RM_INFO("Resource %p of type %d with volume %d is marked for acquire in resource manager #%"PRIu64,
+ *resource_h, type, volume, _mm_rm_hash64(handle->id));
__mm_resources_unlock(handle);
return ret;
}
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)
{
mm_resource_manager_s *handle = MM_RESOURCE_MANAGER(rm);
mm_resource_manager_res_p resource = (mm_resource_manager_res_p) resource_h;
__mm_resource_handles_unlock();
i = __get_resource_index(handle, resource);
- MM_RM_UNLOCK_RETVM_IF(i == MM_RESOURCE_MANAGER_RES_NOT_FOUND,
- handle->resources_lock,
- MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Invalid resource handle");
+ MM_RM_UNLOCK_RETVM_IF(i == MM_RESOURCE_MANAGER_RES_NOT_FOUND, handle->resources_lock,
+ MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Invalid resource handle");
if (new_volume == resource->volume) {
__mm_resources_unlock(handle);
MM_RM_DEBUG("New volume equals the old. Resize is not needed.");
return ret;
}
- add_volume = resource->volume != MM_RESOURCE_MANAGER_RES_VOLUME_FULL &&
- new_volume != MM_RESOURCE_MANAGER_RES_VOLUME_FULL &&
+ add_volume = resource->volume != MM_RESOURCE_MANAGER_RES_VOLUME_FULL && new_volume != MM_RESOURCE_MANAGER_RES_VOLUME_FULL &&
resource->volume < new_volume ? (new_volume - resource->volume) : 0;
switch (resource->state) {
case MM_RESOURCE_MANAGER_RES_STATE_FOR_ACQUIRE:
if (add_volume > 0) {
ret = __check_resource(handle, resource->type, add_volume);
- MM_RM_UNLOCK_RETVM_IF(ret != MM_RESOURCE_MANAGER_ERROR_NONE,
- handle->resources_lock, ret, "Resource check failed");
+ MM_RM_UNLOCK_RETVM_IF(ret != MM_RESOURCE_MANAGER_ERROR_NONE, handle->resources_lock, ret, "Resource check failed");
}
resource->volume = new_volume;
break;
case MM_RESOURCE_MANAGER_RES_STATE_FOR_RELEASE:
case MM_RESOURCE_MANAGER_RES_STATE_ACQUIRED:
ret = __create_resource(handle, resource->type, add_volume, &tmp_resource);
- MM_RM_UNLOCK_RETVM_IF(ret != MM_RESOURCE_MANAGER_ERROR_NONE,
- handle->resources_lock, ret, "Resource cannot be created");
+ MM_RM_UNLOCK_RETVM_IF(ret != MM_RESOURCE_MANAGER_ERROR_NONE, handle->resources_lock, ret, "Resource cannot be created");
tmp_resource->volume = resource->volume;
tmp_resource->state = MM_RESOURCE_MANAGER_RES_STATE_FOR_RELEASE;
break;
}
- MM_RM_INFO("Resource %p is resized for acquire in resource manager #%"PRIu64,
- resource_h, _mm_rm_hash64(handle->id));
+ MM_RM_INFO("Resource %p is resized for acquire in resource manager #%"PRIu64, resource_h, _mm_rm_hash64(handle->id));
__mm_resources_unlock(handle);
return ret;
}
-int _mm_resource_manager_mark_for_release(mm_resource_manager_h rm,
- mm_resource_manager_res_h resource_h)
+int _mm_resource_manager_mark_for_release(mm_resource_manager_h rm, mm_resource_manager_res_h resource_h)
{
mm_resource_manager_s *handle;
mm_resource_manager_res_p resource;
idx = __get_resource_index(handle, resource);
MM_RM_UNLOCK_RETVM_IF(idx == MM_RESOURCE_MANAGER_RES_NOT_FOUND,
- handle->resources_lock, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Invalid resource handle");
+ handle->resources_lock, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Invalid resource handle");
MM_RM_UNLOCK_RETVM_IF(!__mark_resource_for_release(handle->resources, idx, resource),
- handle->resources_lock, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
- "Not in a release state");
+ handle->resources_lock, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION, "Not in a release state");
__mm_resources_unlock(handle);
}
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)
{
mm_resource_manager_s *handle = MM_RESOURCE_MANAGER(rm);
mm_resource_manager_res_p resource = (mm_resource_manager_res_p) resource_h;
__mm_resource_handles_unlock();
i = __get_resource_index(handle, resource);
- MM_RM_UNLOCK_RETVM_IF(i == MM_RESOURCE_MANAGER_RES_NOT_FOUND,
- handle->resources_lock,
- MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "Invalid resource handle #%"PRIu64"", _mm_rm_hash64(handle->id));
+ MM_RM_UNLOCK_RETVM_IF(i == MM_RESOURCE_MANAGER_RES_NOT_FOUND, handle->resources_lock,
+ MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "Invalid resource handle #%"PRIu64"", _mm_rm_hash64(handle->id));
info->type = resource->type;
info->volume = resource->volume;
info->is_acquire_failed = resource->is_acquire_failed;
- MM_RM_INFO("Info structure of resource %p in resource manager #%"PRIu64" is filled",
- resource_h, _mm_rm_hash64(handle->id));
+ MM_RM_INFO("Info structure of resource %p in resource manager #%"PRIu64" is filled", resource_h, _mm_rm_hash64(handle->id));
__mm_resources_unlock(handle);
return MM_RESOURCE_MANAGER_ERROR_NONE;
ret = __dbus_commit(handle);
if (ret == MM_RESOURCE_MANAGER_ERROR_NONE)
- MM_RM_INFO("Changes in resource manager #%"PRIu64" have been committed successfully",
- _mm_rm_hash64(handle->id));
+ MM_RM_INFO("Changes in resource manager #%"PRIu64" have been committed successfully", _mm_rm_hash64(handle->id));
else
MM_RM_ERROR("Dbus commit request failed");
__mm_resources_unlock(handle);
return ret;
}
-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_set_status_cb(mm_resource_manager_h rm, mm_resource_manager_status_cb cb, void *user_data)
{
mm_resource_manager_s *handle = MM_RESOURCE_MANAGER(rm);
handle->status_cb.user_data = user_data;
__mm_resources_unlock(handle);
- MM_RM_INFO("Status callback %p in resource manager #%"PRIu64" is set", cb,
- _mm_rm_hash64(handle->id));
+ MM_RM_INFO("Status callback %p in resource manager #%"PRIu64" is set", cb, _mm_rm_hash64(handle->id));
return MM_RESOURCE_MANAGER_ERROR_NONE;
}
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)
{
mm_resource_manager_s *handle = MM_RESOURCE_MANAGER(rm);
}
}
-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_volume *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_volume *volume)
{
mm_resource_manager_s *handle = MM_RESOURCE_MANAGER(rm);
return MM_RESOURCE_MANAGER_ERROR_NONE;
}
-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)
+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)
{
mm_resource_manager_res_s *resource;
mm_resource_manager_id handle_id;
gboolean release_all = FALSE;
int idx;
- MM_RM_INFO("Release callback is emitted for %s of volume %d in RM #%"PRIu64,
- _mm_resource_manager_get_res_str(type), volume, id);
+ MM_RM_INFO("Release callback is emitted for %s of volume %d in RM #%"PRIu64, _mm_resource_manager_get_res_str(type), volume, id);
handle_id = handle->id;
MM_RM_HASH64(handle_id);
}
}
-static void __mm_resource_manager_status_callback(mm_resource_manager_s *handle,
- mm_resource_manager_status_e status)
+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();
g_mutex_unlock(&h->resources_lock);
}
-static int __check_resource(mm_resource_manager_s *rm,
- mm_resource_manager_res_type_e type,
- mm_resource_manager_res_volume volume)
+static int __check_resource(mm_resource_manager_s *rm, mm_resource_manager_res_type_e type, mm_resource_manager_res_volume volume)
{
mm_resource_manager_res_volume local_volume = rm->__max_resource_volumes[type];
mm_resource_manager_res_p i_res;
for (i = 0; i < rm->resources->len; i++) {
i_res = (mm_resource_manager_res_p) rm->resources->pdata[i];
if (i_res->type == type && i_res->state != MM_RESOURCE_MANAGER_RES_STATE_FOR_RELEASE &&
- (i_res->volume == MM_RESOURCE_MANAGER_RES_VOLUME_FULL ||
- (local_volume -= i_res->volume) < volume)) {
- MM_RM_ERROR("Requested volume %d exceeds remaining local volume %d",
- volume,
- i_res->volume == MM_RESOURCE_MANAGER_RES_VOLUME_FULL ?
- 0 : local_volume);
+ (i_res->volume == MM_RESOURCE_MANAGER_RES_VOLUME_FULL ||(local_volume -= i_res->volume) < volume)) {
+ MM_RM_ERROR("Requested volume %d exceeds remaining local volume %d", volume, i_res->volume ==
+ MM_RESOURCE_MANAGER_RES_VOLUME_FULL ? 0 : local_volume);
return MM_RESOURCE_MANAGER_ERROR_NOT_ENOUGH;
}
}
}
static int __create_resource(mm_resource_manager_s *rm,
- mm_resource_manager_res_type_e type,
- mm_resource_manager_res_volume volume, mm_resource_manager_res_p *res)
+ mm_resource_manager_res_type_e type, mm_resource_manager_res_volume volume, mm_resource_manager_res_p *res)
{
int ret;
mm_resource_manager_s *handle = MM_RESOURCE_MANAGER(rm);
- MM_RM_RETVM_IF(handle == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "NULL handle pointer");
+ MM_RM_RETVM_IF(handle == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "NULL handle pointer");
MM_RM_RETVM_IF(res == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER, "NULL pointer");
ret = __check_resource(rm, type, volume);
if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
{
int i;
- MM_RM_RETVM_IF(rm == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_PARAMETER,
- "NULL handle pointer");
+ 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 MM_RESOURCE_MANAGER_RES_NOT_FOUND;
}
-static gboolean __mark_resource_for_release(GPtrArray *resources, int index,
- mm_resource_manager_res_p resource)
+static gboolean __mark_resource_for_release(GPtrArray *resources, int index, mm_resource_manager_res_p resource)
{
switch (resource->state) {
case MM_RESOURCE_MANAGER_RES_STATE_FOR_ACQUIRE:
{
GError *error = NULL;
- MM_RM_RETVM_IF(handle->dbus_proxy != NULL,
- MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION,
- "Dbus proxy is not NULL");
+ MM_RM_RETVM_IF(handle->dbus_proxy != NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION, "Dbus proxy is not NULL");
g_main_context_push_thread_default(handle->dispatcher_context);
- handle->dbus_proxy = mmresource_manager_proxy_new_for_bus_sync(
- G_BUS_TYPE_SYSTEM, 0, RMD_GDBUS_NAME, RMD_GDBUS_PATH, NULL, &error);
+ handle->dbus_proxy = mmresource_manager_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM, 0, RMD_GDBUS_NAME, RMD_GDBUS_PATH, NULL, &error);
g_main_context_pop_thread_default(handle->dispatcher_context);
MM_RM_RET_IF_GERR(error, "Dbus proxy cannot be created");
static int __dbus_deinit(mm_resource_manager_s *handle)
{
- MM_RM_RETVM_IF(handle->dbus_proxy == NULL,
- MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION, "Dbus proxy is NULL");
+ MM_RM_RETVM_IF(handle->dbus_proxy == NULL, MM_RESOURCE_MANAGER_ERROR_INVALID_OPERATION, "Dbus proxy is NULL");
g_object_unref(handle->dbus_proxy);
handle->dbus_proxy = NULL;
return MM_RESOURCE_MANAGER_ERROR_NONE;
GVariantIter volume_iter;
GVariantIter cond_volume_iter;
- mmresource_manager_call_conf_sync(handle->dbus_proxy, &rm_error, &max_volume,
- &cond_volume, &max_instance, NULL, &error);
+ mmresource_manager_call_conf_sync(handle->dbus_proxy, &rm_error, &max_volume, &cond_volume, &max_instance, NULL, &error);
MM_RM_RET_IF_GERR(error, "DBus conf msg cannot be sent");
MM_RM_RETVM_IF(max_volume == NULL || cond_volume == NULL,
GError *error = NULL;
int rm_error = MM_RESOURCE_MANAGER_ERROR_NONE;
- mmresource_manager_call_create_sync(handle->dbus_proxy, app_class, &handle->id,
- &rm_error, NULL, &error);
+ mmresource_manager_call_create_sync(handle->dbus_proxy, app_class, &handle->id, &rm_error, NULL, &error);
MM_RM_RET_IF_GERR(error, "DBus create msg cannot be sent");
- MM_RM_DEBUG("Create returned id - #%"PRIu64", error - %d",
- _mm_rm_hash64(handle->id), rm_error);
+ MM_RM_DEBUG("Create returned id - #%"PRIu64", error - %d", _mm_rm_hash64(handle->id), rm_error);
return rm_error;
}
GError *error = NULL;
int rm_error = MM_RESOURCE_MANAGER_ERROR_NONE;
- mmresource_manager_call_destroy_sync(handle->dbus_proxy, handle->id, &rm_error,
- NULL, &error);
+ mmresource_manager_call_destroy_sync(handle->dbus_proxy, handle->id, &rm_error, NULL, &error);
MM_RM_RET_IF_GERR(error, "DBus destroy msg cannot be sent");
MM_RM_DEBUG("Destroy for id - #%"PRIu64" returned error - %d", _mm_rm_hash64(handle->id), rm_error);
switch (resource->state) {
case MM_RESOURCE_MANAGER_RES_STATE_FOR_ACQUIRE:
- g_variant_builder_add_value(acquire_builder, g_variant_new("(ii)",
- resource->type, resource->volume));
+ g_variant_builder_add_value(acquire_builder, g_variant_new("(ii)", resource->type, resource->volume));
acquire_num++;
break;
case MM_RESOURCE_MANAGER_RES_STATE_FOR_RELEASE:
- g_variant_builder_add_value(release_builder, g_variant_new("(ii)",
- resource->type, resource->volume));
+ g_variant_builder_add_value(release_builder, g_variant_new("(ii)", resource->type, resource->volume));
release_num++;
break;
default:
if (release_num + acquire_num == 0) {
g_variant_builder_unref(release_builder);
g_variant_builder_unref(acquire_builder);
- MM_RM_DEBUG("There is nothing to commit - dbus request is not sent [%d %d]",
- release_num, acquire_num);
+ MM_RM_DEBUG("There is nothing to commit - dbus request is not sent [%d %d]", release_num, acquire_num);
return rm_error;
}
- /*
- * Acquire and release arrays are ended with special element, because
- * g_variant_builder_end crashes without at least one element
- */
- g_variant_builder_add_value(acquire_builder, g_variant_new("(ii)",
- MM_RESOURCE_MANAGER_NO_RES, 0));
+ /* Acquire and release arrays are ended with special element, because g_variant_builder_end crashes without at least one element */
+ g_variant_builder_add_value(acquire_builder, g_variant_new("(ii)", MM_RESOURCE_MANAGER_NO_RES, 0));
acquire = g_variant_builder_end(acquire_builder);
g_variant_builder_unref(acquire_builder);
- g_variant_builder_add_value(release_builder, g_variant_new("(ii)",
- MM_RESOURCE_MANAGER_NO_RES, 0));
+ g_variant_builder_add_value(release_builder, g_variant_new("(ii)", MM_RESOURCE_MANAGER_NO_RES, 0));
release = g_variant_builder_end(release_builder);
g_variant_builder_unref(release_builder);
- mmresource_manager_call_commit_sync(handle->dbus_proxy, handle->id, release,
- acquire, &rm_error, &flags_variant, NULL, &error);
- if (error != NULL)
- MM_RM_RET_IF_GERR(error, "DBus commit msg cannot be sent");
+ mmresource_manager_call_commit_sync(handle->dbus_proxy, handle->id, release, acquire, &rm_error, &flags_variant, NULL, &error);
+ MM_RM_RET_IF_GERR(error, "DBus commit msg cannot be sent");
- MM_RM_DEBUG("Commit for id - #%"PRIu64" returned error - %d",
- _mm_rm_hash64(handle->id), rm_error);
+ MM_RM_DEBUG("Commit for id - #%"PRIu64" returned error - %d", _mm_rm_hash64(handle->id), rm_error);
if (rm_error == MM_RESOURCE_MANAGER_ERROR_NONE) {
for (i = 0; i < handle->resources->len; i++) {
return rm_error;
}
-static void __dbus_release_callback(MMResourceManager *object, guint64 arg_id,
- gint arg_resource_type, gint arg_volume)
+static void __dbus_release_callback(MMResourceManager *object, guint64 arg_id, gint arg_resource_type, gint arg_volume)
{
mm_resource_manager_s *handle;
mm_resource_manager_id handle_id;
g_print("ERROR: %s", msg);
}
-static int release_cb(mm_resource_manager_h rm,
- mm_resource_manager_res_h resource_h, void *user_data)
+static int release_cb(mm_resource_manager_h rm, mm_resource_manager_res_h resource_h, void *user_data)
{
GHashTable *resources;
- g_print("Release cb of resource manager %p is called for resource "
- "%p\n", rm, resource_h);
+ g_print("Release cb of resource manager %p is called for resource %p\n", rm, resource_h);
g_mutex_lock(&sync_mutex);
resources = g_hash_table_lookup(resource_managers, rm);
return FALSE;
}
-static void status_cb(mm_resource_manager_h rm, mm_resource_manager_status_e status,
- void *user_data)
+static void status_cb(mm_resource_manager_h rm, mm_resource_manager_status_e status, void *user_data)
{
- g_print("Status cb of resource manager %p is called with status %d (%s)\n",
- rm, status, status_str[status]);
+ g_print("Status cb of resource manager %p is called with status %d (%s)\n", rm, status, status_str[status]);
g_mutex_lock(&sync_mutex);
if (g_hash_table_lookup(resource_managers, rm)) {
switch (status) {
case MM_RESOURCE_MANAGER_STATUS_DISCONNECTED:
- g_print("Resource manager %p cannot be used anymore and must be"
- " destroyed.\n", rm);
+ g_print("Resource manager %p cannot be used anymore and must be destroyed.\n", rm);
break;
default:
break;
}
} else {
- g_print("WARNING: resource manager %p was removed during the status "
- "cb call.", rm);
+ g_print("WARNING: resource manager %p was removed during the status cb call.", rm);
}
g_mutex_unlock(&sync_mutex);
}
g_print(">");
}
-static void display_app_classes()
+static void display_app_classes(void)
{
int i;
for (i = 0; i < MM_RESOURCE_MANAGER_RES_TYPE_MAX; i++) {
g_print("%*s", max_res_width, resource_str[i]);
for (j = 0; j < MM_RESOURCE_MANAGER_RES_TYPE_COND_MAX; j++) {
- if (mm_resource_manager_get_res_type_volume(rm, i, j, &volume) ==
- MM_RESOURCE_MANAGER_ERROR_NONE)
+ if (mm_resource_manager_get_res_type_volume(rm, i, j, &volume) == MM_RESOURCE_MANAGER_ERROR_NONE)
g_print("%*d", max_cond_width, volume);
else
g_print("%*s", max_cond_width, "-");
mm_resource_manager_res_info_s res_info;
g_print("%*d.%*s", INDENT, counter(FALSE), INDENT, " ");
- if (mm_resource_manager_get_resource_info(rm, res, &res_info) ==
- MM_RESOURCE_MANAGER_ERROR_NONE) {
- g_print("%p %s (%s, %d, %s)\n", res,
- GET_ENUM_STR(*((mm_resource_manager_res_state_e*)state), res_state_str),
- GET_ENUM_STR(res_info.type, resource_str),
- res_info.volume, res_info.is_acquire_failed ? "TRUE" : "FALSE");
+ if (mm_resource_manager_get_resource_info(rm, res, &res_info) == MM_RESOURCE_MANAGER_ERROR_NONE) {
+ g_print("%p %s (%s, %d, %s)\n", res, GET_ENUM_STR(*((mm_resource_manager_res_state_e*)state), res_state_str),
+ GET_ENUM_STR(res_info.type, resource_str), res_info.volume, res_info.is_acquire_failed ? "TRUE" : "FALSE");
} else {
g_print("(!) Can't get resource info\n");
}
}
}
-static void display_manager_list()
+static void display_manager_list(void)
{
int number = 1;
const char *res_name = GET_ENUM_STR(resource, resource_str);
g_mutex_lock(&sync_mutex);
- g_hash_table_insert(g_hash_table_lookup(resource_managers, rm),
- res_h, g_new0(mm_resource_manager_res_state_e, 1));
+ g_hash_table_insert(g_hash_table_lookup(resource_managers, rm), res_h, g_new0(mm_resource_manager_res_state_e, 1));
g_mutex_unlock(&sync_mutex);
- g_print("Resource '%s' of volume %d is marked for acquire in RM %p successfully\n",
- res_name, volume, rm);
+ g_print("Resource '%s' of volume %d is marked for acquire in RM %p successfully\n", res_name, volume, rm);
} else {
print_api_error("Resource couldn't be marked for acquire", err);
}
else
*state_p = MM_RESOURCE_MANAGER_RES_STATE_FOR_RELEASE;
- g_print("Resource handle %p is marked for release in RM %p successfully\n",
- resource, rm);
+ g_print("Resource handle %p is marked for release in RM %p successfully\n", resource, rm);
} else {
print_api_error("Resource manager couldn't mark resource for release", err);
}
if (err == MM_RESOURCE_MANAGER_ERROR_NONE) {
g_mutex_lock(&sync_mutex);
- state = (mm_resource_manager_res_state_e *)g_hash_table_lookup(
- g_hash_table_lookup(resource_managers, rm), res_h);
+ state = (mm_resource_manager_res_state_e *)g_hash_table_lookup(g_hash_table_lookup(resource_managers, rm), res_h);
*state = MM_RESOURCE_MANAGER_RES_STATE_FOR_ACQUIRE;
g_mutex_unlock(&sync_mutex);
- g_print("Resource handle %p is resized to volume %d and marked "
- "for acquire in RM %p successfully\n", res_h, volume, rm);
+ g_print("Resource handle %p is resized to volume %d and marked for acquire in RM %p successfully\n", res_h, volume, rm);
} else {
print_api_error("Resource couldn't be marked for acquire", err);
}
}
-static void move_to_acquired(gpointer resource, gpointer state,
- gpointer user_data)
+static void move_to_acquired(gpointer resource, gpointer state, gpointer user_data)
{
- mm_resource_manager_res_state_e *res_state =
- (mm_resource_manager_res_state_e *)state;
+ mm_resource_manager_res_state_e *res_state = (mm_resource_manager_res_state_e *)state;
if (*res_state == MM_RESOURCE_MANAGER_RES_STATE_FOR_ACQUIRE)
*res_state = MM_RESOURCE_MANAGER_RES_STATE_ACQUIRED;
}
-static gboolean is_marked_for_release(gpointer resource, gpointer state,
- gpointer user_data)
+static gboolean is_marked_for_release(gpointer resource, gpointer state, gpointer user_data)
{
- return *((mm_resource_manager_res_state_e *)state) ==
- MM_RESOURCE_MANAGER_RES_STATE_FOR_RELEASE;
+ return *((mm_resource_manager_res_state_e *)state) == MM_RESOURCE_MANAGER_RES_STATE_FOR_RELEASE;
}
static void process_commit_cmd(gchar **cmd_tokens)
projects / platform / core / multimedia / mm-resource-manager.git / commitdiff