Apply with GMutexLocker for code conciseness

Change-Id: I76594247fc8bb59d8726c82cfd68487050ddc478

diff --git a/core/src/muse_core.c b/core/src/muse_core.c
index 7c6edad..af4ae9a 100644 (file)
--- a/core/src/muse_core.c
+++ b/core/src/muse_core.c
@@ -281,6 +281,7 @@ bool muse_server_is_ready(void)
 int muse_core_connection_close(int sock_fd)
 {
        char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
+       g_autoptr(GMutexLocker) locker = NULL;
 
        if (!muse_core_fd_is_valid(sock_fd)) {
                LOGE("[%d] invalid socket", sock_fd);
@@ -299,13 +300,11 @@ int muse_core_connection_close(int sock_fd)
 
        muse_core_dump_fd_state(sock_fd);
 
-       g_mutex_lock(&fd_state_lock);
+       locker = g_mutex_locker_new(&fd_state_lock);
 
        if (!g_hash_table_remove(fd_state_table, GINT_TO_POINTER(sock_fd)))
                LOGW("fail : remove fd %d from table[%p]", sock_fd, fd_state_table);
 
-       g_mutex_unlock(&fd_state_lock);
-
        return MM_ERROR_NONE;
 }
 
@@ -392,6 +391,7 @@ int muse_core_msg_send_fd(int sock_fd, int *fds, const char *buf)
        char err_msg[MUSE_MSG_LEN_MAX] = {'\0',};
        int *fdptr;
        int fd_cnt = 0;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_val_if_fail(buf, MM_ERROR_INVALID_ARGUMENT);
        muse_return_val_if_fail(muse_core_fd_is_valid(sock_fd), MM_ERROR_INVALID_ARGUMENT);
@@ -404,7 +404,7 @@ int muse_core_msg_send_fd(int sock_fd, int *fds, const char *buf)
        msg_info.marker = MUSE_MSG_HEAD;
        msg_info.size = strlen(buf);
 
-       g_mutex_lock(&msg_ipc_lock);
+       locker = g_mutex_locker_new(&msg_ipc_lock);
 
        ret = send(sock_fd, &msg_info, sizeof(muse_msg_info_t), 0);
        if (ret != sizeof(muse_msg_info_t)) {
@@ -412,7 +412,7 @@ int muse_core_msg_send_fd(int sock_fd, int *fds, const char *buf)
                LOGE("[fd : %d] msg info [type : %s size : %zu] send failed : %d [error %s %d]",
                                sock_fd, msg_type[msg_info.type], msg_info.size, ret, err_msg, errno);
 
-               goto _MSG_SEND_DONE;
+               return ret;
        }
 
        if (msg_info.type == MUSE_MSG_TYPE_NORMAL) {
@@ -422,7 +422,7 @@ int muse_core_msg_send_fd(int sock_fd, int *fds, const char *buf)
                        LOGE("[%s] send failed : %d [error %s %d]", buf, ret, err_msg, errno);
                }
 
-               goto _MSG_SEND_DONE;
+               return ret;
        }
 
        /* MUSE_MSG_TYPE_FDS */
@@ -458,9 +458,6 @@ int muse_core_msg_send_fd(int sock_fd, int *fds, const char *buf)
                LOGE("[%d] fail to send msg - [error %s %d]", sock_fd, err_msg, errno);
        }
 
-_MSG_SEND_DONE:
-       g_mutex_unlock(&msg_ipc_lock);
-
        return ret;
 }
 
@@ -573,18 +570,18 @@ bool muse_core_msg_deserialize(const char *key, char *buf, int *parse_len,
 {
        json_object *obj = NULL, *jobj = NULL;
        bool ret = false;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_val_if_fail(key, false);
        muse_return_val_if_fail(buf, false);
        muse_return_val_if_fail(m_type >= MUSE_TYPE_INT && m_type < MUSE_TYPE_MAX, false);
        muse_return_val_if_fail(data, false);
 
-       g_mutex_lock(&msg_lock);
+       locker = g_mutex_locker_new(&msg_lock);
 
        jobj = _muse_msg_json_tokener_parse_len(buf, parse_len, err);
        if (!jobj) {
                LOGE("jobj is NULL");
-               g_mutex_unlock(&msg_lock);
                return false;
        }
 
@@ -592,7 +589,6 @@ bool muse_core_msg_deserialize(const char *key, char *buf, int *parse_len,
        if (!obj) {
                LOGE("\"%s\" key is not founded", key);
                json_object_put(jobj);
-               g_mutex_unlock(&msg_lock);
                return false;
        }
 
@@ -600,8 +596,6 @@ bool muse_core_msg_deserialize(const char *key, char *buf, int *parse_len,
 
        json_object_put(jobj);
 
-       g_mutex_unlock(&msg_lock);
-
        return ret;
 }
 
@@ -612,54 +606,41 @@ void muse_core_msg_free(char *msg)
 
 void *muse_core_msg_object_new(char *str, int *parse_len, muse_core_msg_parse_err_e *err)
 {
-       void *jobj = NULL;
-
        muse_return_val_if_fail(str, NULL);
 
-       g_mutex_lock(&msg_lock);
-
-       jobj = (void *)_muse_msg_json_tokener_parse_len(str, parse_len, err);
+       g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&msg_lock);
 
-       g_mutex_unlock(&msg_lock);
-
-       return jobj;
+       return (void *)_muse_msg_json_tokener_parse_len(str, parse_len, err);
 }
 
 bool muse_core_msg_object_get_value(const char *key, void *jobj, muse_core_msg_type_e m_type, void *data)
 {
        json_object *obj;
-       bool ret = false;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_val_if_fail(key, false);
        muse_return_val_if_fail(jobj, false);
        muse_return_val_if_fail(data, false);
        muse_return_val_if_fail(m_type >= MUSE_TYPE_INT && m_type < MUSE_TYPE_MAX, false);
 
-       g_mutex_lock(&msg_lock);
+       locker = g_mutex_locker_new(&msg_lock);
 
        obj = _muse_msg_json_find_obj((json_object *)jobj, key);
        if (!obj) {
                LOGE("\"%s\" key is not found", key);
-               g_mutex_unlock(&msg_lock);
                return false;
        }
 
-       ret = (bool)_muse_msg_json_get_obj_value(obj, m_type, data);
-
-       g_mutex_unlock(&msg_lock);
-
-       return ret;
+       return (bool)_muse_msg_json_get_obj_value(obj, m_type, data);
 }
 
 void muse_core_msg_object_free(void *jobj)
 {
        muse_return_if_fail(jobj);
 
-       g_mutex_lock(&msg_lock);
+       g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&msg_lock);
 
        json_object_put((json_object *)jobj);
-
-       g_mutex_unlock(&msg_lock);
 }
 
 bool muse_core_msg_recv_len(int fd, char *buf, int msg_len)
@@ -717,26 +698,24 @@ void muse_core_dump_fd_state(int fd)
        int sec = 0;
        char time_buf[MUSE_MSG_TIME_LEN];
 
-       g_mutex_lock(&fd_state_lock);
+       g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&fd_state_lock);
+
        sec = GPOINTER_TO_INT(g_hash_table_lookup(fd_state_table, GINT_TO_POINTER(fd)));
        muse_core_change_time_format(sec, time_buf);
        LOGI("[%d] %s", fd, time_buf);
-       g_mutex_unlock(&fd_state_lock);
 }
 
 void muse_core_update_fd_state(int fd)
 {
        struct timespec tv;
 
-       g_mutex_lock(&fd_state_lock);
+       g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&fd_state_lock);
 
        if (!fd_state_table)
                fd_state_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, NULL);
 
        muse_core_get_cur_time(&tv, NULL);
        g_hash_table_insert(fd_state_table, GINT_TO_POINTER(fd), GINT_TO_POINTER((int)tv.tv_sec));
-
-       g_mutex_unlock(&fd_state_lock);
 }
 
 gboolean muse_core_set_close_on_exec(int fd)
@@ -754,33 +733,29 @@ gboolean muse_core_set_close_on_exec(int fd)
 
 void muse_core_create_fd_table(void)
 {
-       g_mutex_lock(&fd_state_lock);
+       g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&fd_state_lock);
 
        if (fd_state_table) {
                LOGW("fd state table [%p] is already created", fd_state_table);
-               goto out;
+               return;
        }
 
        fd_state_table = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, NULL);
        if (!fd_state_table)
                LOGE("fail to create new fd state table");
-out:
-       g_mutex_unlock(&fd_state_lock);
 }
 
 void muse_core_remove_all_fd_table(void)
 {
-       g_mutex_lock(&fd_state_lock);
+       g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&fd_state_lock);
        g_hash_table_remove_all(fd_state_table);
-       g_mutex_unlock(&fd_state_lock);
 }
 
 void muse_core_destroy_fd_table(void)
 {
-       g_mutex_lock(&fd_state_lock);
+       g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&fd_state_lock);
        g_hash_table_destroy(fd_state_table);
        fd_state_table = NULL;
-       g_mutex_unlock(&fd_state_lock);
 }
 
 void muse_core_get_cur_time(struct timespec *time, char *time_buf)

diff --git a/packaging/mused.spec b/packaging/mused.spec
index 9e798c0..2e6d17d 100644 (file)
--- a/packaging/mused.spec
+++ b/packaging/mused.spec
@@ -1,6 +1,6 @@
 Name:       mused
 Summary:    A multimedia daemon
-Version:    0.3.162
+Version:    0.3.163
 Release:    0
 Group:      System/Libraries
 License:    Apache-2.0

diff --git a/server/include/muse_server_module.h b/server/include/muse_server_module.h
index 2ac4d13..9d3eb5f 100644 (file)
--- a/server/include/muse_server_module.h
+++ b/server/include/muse_server_module.h
@@ -44,8 +44,6 @@ typedef struct ms_module {
 void ms_module_init(ms_module_t *module);
 void ms_module_deinit(ms_module_t *module);
 GModule *ms_module_open(int idx);
-void ms_module_dispatch_lock(muse_module_h m);
-void ms_module_dispatch_unlock(muse_module_h m);
 int ms_module_dispatch(muse_module_h m);
 gboolean ms_module_close(muse_module_h m);
 gboolean ms_module_get_loaded_dllsym(int idx);

diff --git a/server/src/muse_server_connection.c b/server/src/muse_server_connection.c
index 0394958..4e12f61 100644 (file)
--- a/server/src/muse_server_connection.c
+++ b/server/src/muse_server_connection.c
@@ -72,6 +72,7 @@ int ms_connection_register(muse_module_h m)
        int caution_instance;
        GQueue *queue;
        ms_connection_t *connection = NULL;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        LOGD("Enter");
 
@@ -83,7 +84,7 @@ int ms_connection_register(muse_module_h m)
        muse_return_val_if_fail(connection->instance_q, MM_ERROR_INVALID_ARGUMENT);
        muse_return_val_if_fail(m, MM_ERROR_INVALID_ARGUMENT);
 
-       ms_connection_lock(connection);
+       locker = g_mutex_locker_new(&connection->lock);
 
        queue = connection->instance_q;
 
@@ -102,8 +103,6 @@ int ms_connection_register(muse_module_h m)
                ms_cmd_dispatch(m, MUSE_MODULE_COMMAND_CREATE_CAUTION);
        }
 
-       ms_connection_unlock(connection);
-
        LOGD("Leave");
 
        return MM_ERROR_NONE;
@@ -114,6 +113,7 @@ int ms_connection_unregister(muse_module_h m)
        int fd;
        GQueue *queue;
        ms_connection_t *connection = NULL;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        LOGD("Enter");
 
@@ -126,7 +126,7 @@ int ms_connection_unregister(muse_module_h m)
        muse_return_val_if_fail(connection, MM_ERROR_INVALID_ARGUMENT);
        muse_return_val_if_fail(connection->instance_q, MM_ERROR_INVALID_ARGUMENT);
 
-       ms_connection_lock(connection);
+       locker = g_mutex_locker_new(&connection->lock);
 
        queue = connection->instance_q;
 
@@ -137,8 +137,6 @@ int ms_connection_unregister(muse_module_h m)
 
        _ms_connection_module_instance_info(m, connection, queue, API_DESTROY);
 
-       ms_connection_unlock(connection);
-
        LOGD("Leave");
 
        return MM_ERROR_NONE;

diff --git a/server/src/muse_server_ipc.c b/server/src/muse_server_ipc.c
index 5e6b6b5..4967b76 100644 (file)
--- a/server/src/muse_server_ipc.c
+++ b/server/src/muse_server_ipc.c
@@ -68,7 +68,9 @@ static void _ms_ipc_data_ch_deinit(muse_module_h m)
 static void _ms_ipc_module_data_ch_cleanup(muse_module_h m)
 {
        muse_return_if_fail(m);
-       muse_return_if_fail(m->ch[MUSE_CHANNEL_DATA].thread);
+
+       if (!m->ch[MUSE_CHANNEL_DATA].thread)
+               return;
 
        g_thread_join(m->ch[MUSE_CHANNEL_DATA].thread);
        m->ch[MUSE_CHANNEL_DATA].thread = NULL;
@@ -145,22 +147,23 @@ static gboolean _ms_ipc_get_module_idx(muse_module_h m, void *jobj)
 static gboolean _ms_ipc_dispatch_create(muse_module_h m, void *jobj)
 {
        int pid, dispatch_ret = MM_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_val_if_fail(m, FALSE);
        muse_return_val_if_fail(jobj, FALSE);
 
-       ms_module_dispatch_lock(m);
+       locker = g_mutex_locker_new(&m->dispatch_lock);
 
        if (!_ms_ipc_get_module_idx(m, jobj)) {
                ms_cmd_dispatch(m, MUSE_MODULE_COMMAND_DEBUG_INFO_DUMP);
-               goto out;
+               return FALSE;
        }
 
        m->ch[MUSE_CHANNEL_MSG].dll_handle = ms_module_open(m->idx);
 
        if (!_ms_ipc_module_instance_creation_is_allowed(m->idx)) {
                ms_cmd_dispatch(m, MUSE_MODULE_COMMAND_RESOURCE_NOT_AVAILABLE);
-               goto out;
+               return FALSE;
        }
 
        if (muse_core_msg_object_get_value(MSG_KEY_PID, jobj, MUSE_TYPE_INT, &pid) && m->pid != pid)
@@ -180,39 +183,31 @@ static gboolean _ms_ipc_dispatch_create(muse_module_h m, void *jobj)
 
        if (dispatch_ret != MM_ERROR_NONE) {
                LOGE("create dispatch failed 0x%x, clean up module", dispatch_ret);
-               goto out;
+               return FALSE;
        }
 
        m->is_created = TRUE;
 
-       ms_module_dispatch_unlock(m);
-
        LOGD("Leave");
 
        return TRUE;
-
-out:
-       ms_module_dispatch_unlock(m);
-
-       return FALSE;
 }
 
 static gboolean _ms_ipc_dispatch_destroy(muse_module_h m)
 {
        int dispatch_ret = MM_ERROR_NONE;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_val_if_fail(m, FALSE);
 
-       ms_module_dispatch_lock(m);
+       locker = g_mutex_locker_new(&m->dispatch_lock);
+
        dispatch_ret = ms_module_dispatch(m);
        if (dispatch_ret != MM_ERROR_NONE) {
                LOGE("destroy dispatch failed 0x%x", dispatch_ret);
-               ms_module_dispatch_unlock(m);
                return TRUE;
        }
 
-       ms_module_dispatch_unlock(m);
-
        return FALSE;
 }
 
@@ -221,18 +216,18 @@ static gboolean _ms_ipc_dispatch_no_instance(muse_module_h m, void *jobj)
        muse_return_val_if_fail(m, FALSE);
        muse_return_val_if_fail(jobj, FALSE);
 
-       ms_module_dispatch_lock(m);
+       g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&m->dispatch_lock);
 
        if (!_ms_ipc_get_module_idx(m, jobj)) {
                ms_cmd_dispatch(m, MUSE_MODULE_COMMAND_DEBUG_INFO_DUMP);
-               goto out;
+               return FALSE;
        }
 
        m->ch[MUSE_CHANNEL_MSG].dll_handle = ms_module_open(m->idx);
 
        if (!_ms_ipc_module_instance_creation_is_allowed(m->idx)) {
                ms_cmd_dispatch(m, MUSE_MODULE_COMMAND_RESOURCE_NOT_AVAILABLE);
-               goto out;
+               return FALSE;
        }
 
        ms_connection_register(m);
@@ -243,9 +238,6 @@ static gboolean _ms_ipc_dispatch_no_instance(muse_module_h m, void *jobj)
 
        SECURE_LOGW("[module %p] [loaded value %d]", m, ms_module_get_loaded_dllsym(m->idx));
 
-out:
-       ms_module_dispatch_unlock(m);
-
        return FALSE;
 }
 

diff --git a/server/src/muse_server_log.c b/server/src/muse_server_log.c
index c1cf539..eab1e60 100644 (file)
--- a/server/src/muse_server_log.c
+++ b/server/src/muse_server_log.c
@@ -60,11 +60,12 @@ static gboolean _ms_log_pid_is_valid(pid_t pid)
 static void _ms_log_latest_msgs(ms_log_t *log)
 {
        int idx = 0;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_if_fail(ms_is_log_enabled());
        muse_return_if_fail(log);
 
-       g_mutex_lock(&log->lock);
+       locker = g_mutex_locker_new(&log->lock);
 
        if (muse_core_fd_is_valid(log->fd)) {
                for (idx = log->cur_idx; idx < MUSE_LOG_MSG_NUM; idx++)
@@ -73,8 +74,6 @@ static void _ms_log_latest_msgs(ms_log_t *log)
                for (idx = 0; idx < log->cur_idx; idx++)
                        ms_log_write(log->latest_msgs[idx]);
        }
-
-       g_mutex_unlock(&log->lock);
 }
 
 static void _ms_log_pid_time(ms_log_t *log, int pid)
@@ -282,17 +281,17 @@ static void _ms_log_set_fd(ms_log_t *log)
 static void _ms_log_cache_latest_msg(ms_log_t *log, int pid, char *msg)
 {
        char time_buf[MUSE_MSG_TIME_LEN];
+       g_autoptr(GMutexLocker) locker = NULL;
+
        muse_return_if_fail(msg);
        muse_return_if_fail(log);
 
-       g_mutex_lock(&log->lock);
+       locker = g_mutex_locker_new(&log->lock);
 
        muse_core_get_cur_time(NULL, time_buf);
        snprintf(log->latest_msgs[log->cur_idx], MUSE_MSG_LEN_MAX, "[P%5d] %s %s", pid, time_buf, msg);
 
        log->cur_idx = (log->cur_idx + 1) % MUSE_LOG_MSG_NUM;
-
-       g_mutex_unlock(&log->lock);
 }
 
 void ms_log_init(ms_log_t *log)

diff --git a/server/src/muse_server_module.c b/server/src/muse_server_module.c
index d2aa37a..b7cc7ae 100644 (file)
--- a/server/src/muse_server_module.c
+++ b/server/src/muse_server_module.c
@@ -157,10 +157,11 @@ GModule *ms_module_open(int idx)
 {
        GModule *dllsym = NULL;
        ms_module_t *module = ms_get_module_instance(idx);
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_val_if_fail(module, NULL);
 
-       g_mutex_lock(&module->lock);
+       locker = g_mutex_locker_new(&module->lock);
 
        if (!ms_module_get_loaded_dllsym(idx)) {
                dllsym = g_module_open(ms_config_get_path(idx), G_MODULE_BIND_LAZY);
@@ -174,23 +175,9 @@ GModule *ms_module_open(int idx)
                SECURE_LOGW("already module is opened: %p", dllsym);
        }
 
-       g_mutex_unlock(&module->lock);
-
        return dllsym;
 }
 
-void ms_module_dispatch_lock(muse_module_h m)
-{
-       muse_return_if_fail(m);
-       g_mutex_lock(&m->dispatch_lock);
-}
-
-void ms_module_dispatch_unlock(muse_module_h m)
-{
-       muse_return_if_fail(m);
-       g_mutex_unlock(&m->dispatch_lock);
-}
-
 int ms_module_dispatch(muse_module_h m)
 {
        int ret = MUSE_ERR;
@@ -257,24 +244,23 @@ int ms_module_dispatch(muse_module_h m)
 gboolean ms_module_close(muse_module_h m)
 {
        ms_module_t *module = NULL;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_val_if_fail(m, FALSE);
 
        module = ms_get_module_instance(m->idx);
        muse_return_val_if_fail(module, FALSE);
 
-       g_mutex_lock(&module->lock);
+       locker = g_mutex_locker_new(&module->lock);
 
        LOGD("Closing module %s", g_module_name(m->ch[MUSE_CHANNEL_MSG].dll_handle));
        if (!g_module_close(m->ch[MUSE_CHANNEL_MSG].dll_handle)) {
                LOGE("Couldn't close dll_handle %s", g_module_error());
-               g_mutex_unlock(&module->lock);
                return FALSE;
        }
 
        _ms_module_set_loaded_dllsym(m->idx, NULL, false);
 
-       g_mutex_unlock(&module->lock);
 
        return TRUE;
 }
@@ -298,13 +284,14 @@ gboolean ms_module_get_loaded_dllsym(int idx)
 void ms_module_set_dllsym_value(int idx, const char *name, gpointer value)
 {
        ms_module_t *module = ms_get_module_instance(idx);
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_if_fail(module);
        muse_return_if_fail(name);
 
-       g_mutex_lock(&dllsym_table_lock);
+       locker = g_mutex_locker_new(&dllsym_table_lock);
+
        g_hash_table_insert(module->dllsym_table, g_strdup(name), value);
-       g_mutex_unlock(&dllsym_table_lock);
 }
 
 int ms_module_get_dllsym_value(int idx, const char *name, gpointer *value)
@@ -313,27 +300,24 @@ int ms_module_get_dllsym_value(int idx, const char *name, gpointer *value)
 
        muse_return_val_if_fail(module, MM_ERROR_INVALID_ARGUMENT);
        muse_return_val_if_fail(name, MM_ERROR_INVALID_ARGUMENT);
+       muse_return_val_if_fail(value, MM_ERROR_INVALID_ARGUMENT);
 
-       if (value) {
-               *value = g_hash_table_lookup(module->dllsym_table, name);
-               return MM_ERROR_NONE;
-       } else {
-               return MM_ERROR_INVALID_ARGUMENT;
-       }
+       *value = g_hash_table_lookup(module->dllsym_table, name);
+
+       return MM_ERROR_NONE;
 }
 
 void ms_module_set_timeout(int idx, int api, int timeout)
 {
        ms_module_t *module = ms_get_module_instance(idx);
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_if_fail(module);
        muse_return_if_fail(timeout >= ms_config_get_min_timeout() && timeout <= ms_config_get_max_timeout());
 
-       g_mutex_lock(&module->lock);
+       locker = g_mutex_locker_new(&module->lock);
 
        module->disp_timeout[api] = timeout;
-
-       g_mutex_unlock(&module->lock);
 }
 
 int ms_module_get_timeout(int idx, int api)

diff --git a/server/src/muse_server_private.c b/server/src/muse_server_private.c
index ae22021..7f439d6 100644 (file)
--- a/server/src/muse_server_private.c
+++ b/server/src/muse_server_private.c
@@ -1321,9 +1321,9 @@ void ms_set_state(ms_state_e state)
 {
        muse_return_if_fail(muse_server);
 
-       g_mutex_lock(&muse_server->state_lock);
+       g_autoptr(GMutexLocker) locker = g_mutex_locker_new(&muse_server->state_lock);
+
        muse_server->state = state;
-       g_mutex_unlock(&muse_server->state_lock);
 }
 
 gboolean ms_is_server_ready(void)

diff --git a/server/src/muse_server_security.c b/server/src/muse_server_security.c
index 6f0ac95..ffb4041 100644 (file)
--- a/server/src/muse_server_security.c
+++ b/server/src/muse_server_security.c
@@ -114,12 +114,13 @@ bool ms_security_is_privilege_granted(ms_security_t *security, int fd, const cha
        char *user = NULL;
        char *client = NULL;
        char *session = NULL;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_val_if_fail(security, false);
 
        LOGI("Enter [fd %d privilege %s]", fd, privilege);
 
-       g_mutex_lock(&security->lock);
+       locker = g_mutex_locker_new(&security->lock);
 
        ret = cynara_creds_socket_get_user(fd, USER_METHOD_DEFAULT, &user);
        if (ret != CYNARA_API_SUCCESS) {
@@ -165,8 +166,6 @@ CLEANUP:
        MUSE_FREE(session);
        MUSE_FREE(client);
 
-       g_mutex_unlock(&security->lock);
-
        LOGI("Leave [fd %d privilege %s] RET [%d]", fd, privilege, ret);
 
        return (ret == CYNARA_API_ACCESS_ALLOWED);

diff --git a/server/src/muse_server_system.c b/server/src/muse_server_system.c
index e368c19..602c93d 100644 (file)
--- a/server/src/muse_server_system.c
+++ b/server/src/muse_server_system.c
@@ -99,6 +99,7 @@ static void _ms_poweroff_state_changed_cb(GDBusConnection *con, const gchar *sen
        ms_cmd_dispatcher_info_t dispatch;
        ms_system_t *system = NULL;
        ms_connection_t *connection = NULL;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        LOGE("received power off signal");
 
@@ -127,7 +128,7 @@ static void _ms_poweroff_state_changed_cb(GDBusConnection *con, const gchar *sen
 
        _ms_system_unsubscribe_poweroff_state_change();
 
-       g_mutex_lock(&system->lock);
+       locker = g_mutex_locker_new(&system->lock);
 
        ms_connection_lock(connection);
 
@@ -137,8 +138,6 @@ static void _ms_poweroff_state_changed_cb(GDBusConnection *con, const gchar *sen
 
        ms_connection_unlock(connection);
 
-       g_mutex_unlock(&system->lock);
-
        exit(EXIT_FAILURE);
 }
 #endif
@@ -430,6 +429,7 @@ int ms_system_get_platform_info(const char *key, bool *value)
        int ret = MM_ERROR_NONE;
        gpointer orig_value;
        ms_system_t *system = NULL;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_val_if_fail(ms_get_instance(), MM_ERROR_UNKNOWN);
 
@@ -439,7 +439,7 @@ int ms_system_get_platform_info(const char *key, bool *value)
        muse_return_val_if_fail(key, MM_ERROR_INVALID_ARGUMENT);
        muse_return_val_if_fail(value, MM_ERROR_INVALID_ARGUMENT);
 
-       g_mutex_lock(&system->lock);
+       locker = g_mutex_locker_new(&system->lock);
 
        if (g_hash_table_lookup_extended(system->platform_info_table, key, NULL, &orig_value)) {
                *value = GPOINTER_TO_INT(orig_value);
@@ -466,8 +466,6 @@ int ms_system_get_platform_info(const char *key, bool *value)
                }
        }
 
-       g_mutex_unlock(&system->lock);
-
        return ret;
 }
 

diff --git a/server/src/muse_server_watchdog.c b/server/src/muse_server_watchdog.c
index d1cc356..772dec5 100644 (file)
--- a/server/src/muse_server_watchdog.c
+++ b/server/src/muse_server_watchdog.c
@@ -27,12 +27,13 @@ static gpointer _ms_watchdog_thread(gpointer data);
 static gboolean _ms_watchdog_timer_cb(gpointer data)
 {
        ms_watchdog_t *watchdog = (ms_watchdog_t *)data;
+       g_autoptr(GMutexLocker) locker = NULL;
 
        muse_return_val_if_fail(watchdog, FALSE);
 
-       g_mutex_lock(&watchdog->lock);
+       locker = g_mutex_locker_new(&watchdog->lock);
+
        g_cond_signal(&watchdog->cond);
-       g_mutex_unlock(&watchdog->lock);
 
        return TRUE;
 }
@@ -77,13 +78,14 @@ static gpointer _ms_watchdog_thread(gpointer data)
 int ms_watchdog_init(ms_watchdog_t *watchdog)
 {
        muse_return_val_if_fail(watchdog, MM_ERROR_INVALID_ARGUMENT);
+       g_autoptr(GMutexLocker) locker = NULL;
 
        g_mutex_init(&watchdog->lock);
        g_cond_init(&watchdog->cond);
 
-       g_mutex_lock(&watchdog->lock);
+       locker = g_mutex_locker_new(&watchdog->lock);
+
        watchdog->run = TRUE;
-       g_mutex_unlock(&watchdog->lock);
 
        return MM_ERROR_NONE;
 }