#include <dbus/dbus.h>
#include <glib.h>
+#include <gio/gio.h>
#include <stdint.h>
#include "trace.h"
#define D_BUS_INIT_RETRY_COUNT 5
-static struct d_bus_object dbus_objects[] = {
- { RESOURCED_DBUS_OBJECT_PATH, RESOURCED_DBUS_INTERFACE_NAME },
- { RESOURCED_PATH_SWAP, RESOURCED_INTERFACE_SWAP },
- { RESOURCED_PATH_FREEZER, RESOURCED_INTERFACE_FREEZER },
- { RESOURCED_PATH_OOM, RESOURCED_INTERFACE_OOM },
- { RESOURCED_PATH_PROCESS, RESOURCED_INTERFACE_PROCESS },
- { RESOURCED_PATH_LOGGING, RESOURCED_INTERFACE_LOGGING },
- { RESOURCED_PATH_DBUS, RESOURCED_INTERFACE_DBUS },
- { RESOURCED_PATH_APPOPT, RESOURCED_INTERFACE_APPOPT },
- /* Add new object & interface here*/
-};
-
-static DBusConnection *dbus_conn;
+static guint owner_id;
static GList *dbus_signal_list;
static GList *dbus_method_handle_list;
+static GDBusConnection *d_bus_get_connection(void)
+{
+ static GDBusConnection *g_dbus_conn;
+
+ if (g_dbus_conn)
+ return g_dbus_conn;
+
+ g_dbus_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
+ g_assert(g_dbus_conn);
+
+ return g_dbus_conn;
+}
+
static struct d_bus_signal *d_bus_find_signal(const char *path, const char *interface, const char *name)
{
size_t path_len, interface_len, name_len;
return NULL;
}
-static DBusHandlerResult d_bus_call_signal_handler(DBusConnection *conn, DBusMessage *msg, void *data)
-{
- const char *path, *interface, *name;
- struct d_bus_signal *signal;
-
- if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-
- path = dbus_message_get_path(msg);
- interface = dbus_message_get_interface(msg);
- name = dbus_message_get_member(msg);
-
- signal = d_bus_find_signal(path, interface, name);
- if (signal)
- signal->handler(signal->user_data, msg);
-
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
-}
-
-struct d_bus_watch_info {
- DBusWatch *watch;
- void *data;
-};
-
-static fd_handler_h watch_handler;
-
-static bool d_bus_watch_info_changed_cb(int fd, void *data)
-{
- struct d_bus_watch_info *winfo = data;
-
- if (!dbus_watch_handle(winfo->watch, DBUS_WATCH_READABLE | DBUS_WATCH_ERROR))
- return true;
-
- dbus_connection_ref(dbus_conn);
- while (dbus_connection_dispatch(dbus_conn) == DBUS_DISPATCH_DATA_REMAINS);
- dbus_connection_unref(dbus_conn);
-
- return true;
-}
-
-static void d_bus_watch_info_free(void *data)
-{
- if (data)
- free(data);
-}
-
-static dbus_bool_t d_bus_watch_add_cb(DBusWatch *watch, void *data)
-{
- int fd;
- int ret;
- struct d_bus_watch_info *winfo;
- dbus_bool_t enabled;
-
- _I("add_watch_cb %s", (dbus_watch_get_enabled(watch) == 0 ? "disabled" : "enabled"));
-
- enabled = dbus_watch_get_enabled(watch);
-
- if (watch_handler || !enabled)
- return TRUE;
-
- winfo = calloc(1, sizeof(struct d_bus_watch_info));
- if (!winfo) {
- _E("calloc() failed");
- return TRUE;
- }
-
- winfo->watch = watch;
- winfo->data = NULL;
-
- fd = dbus_watch_get_unix_fd(watch);
- ret = add_fd_read_handler(fd, d_bus_watch_info_changed_cb,
- winfo, d_bus_watch_info_free, &watch_handler);
- if (ret < 0)
- _E("Failed to add fd handler (%d)", ret);
-
- return TRUE;
-}
-
-static void d_bus_watch_remove_cb(DBusWatch *watch, void *data)
-{
- int ret;
-
- if (!watch_handler)
- return;
-
- ret = remove_fd_read_handler(&watch_handler);
- if (ret < 0)
- _E("Failed to remove fd handler (%d)", ret);
- watch_handler = NULL;
-}
-
-static void d_bus_watch_toggled_cb(DBusWatch *watch, void *data)
-{
- return;
-}
-
-static const char *d_bus_get_interface(const char *path)
+/* Find appropriate method and call its callback */
+static void d_bus_method_handler(GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path,
+ const gchar *interface_name, const gchar *method_name,
+ GVariant *parameters, GDBusMethodInvocation *invocation,
+ gpointer user_data)
{
int i;
- int path_len = strlen(path) + 1;
- int size = sizeof(dbus_objects) / sizeof(dbus_objects[0]);
+ struct d_bus_method_handle *handle;
+ int name_len;
- for (i = 0; i < size; i++) {
- if (!strncmp(dbus_objects[i].path, path, path_len))
- return dbus_objects[i].interface;
- }
-
- return NULL;
-}
-
-static DBusHandlerResult d_bus_call_method_handler(DBusConnection *conn,
- DBusMessage *msg, void *user_data)
-{
- int i;
- struct d_bus_method_handle *handle = (struct d_bus_method_handle *)user_data;
- DBusMessage *reply = NULL;
-
- if (!msg || !handle) {
- _E("Invalid parameter");
- return DBUS_HANDLER_RESULT_HANDLED;
+ if (!user_data) {
+ _E("There is no handle about received gdbus method");
+ return;
}
+ handle = (struct d_bus_method_handle *)user_data;
+ name_len = strlen(method_name) + 1;
for (i = 0; i < handle->num_methods; i++) {
- if (!dbus_message_is_method_call(msg, handle->interface, handle->methods[i].name))
+ if (strncmp(handle->methods[i].name, method_name, name_len))
continue;
- reply = handle->methods[i].handler(msg);
- if (!reply)
- _E("No reply from D-Bus method %s", handle->methods[i].name);
+ handle->methods[i].callback(invocation, parameters);
break;
}
+}
+
+static const GDBusInterfaceVTable vtable = { d_bus_method_handler, NULL, NULL };
- if (reply)
- d_bus_reply_message(reply);
+static void d_bus_signal_handler(GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path,
+ const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+{
+ struct d_bus_signal *signal = (struct d_bus_signal *)user_data;
+ if (!signal || !signal->callback)
+ return;
- return DBUS_HANDLER_RESULT_HANDLED;
+ signal->callback(parameters);
}
-static const DBusObjectPathVTable vtable = { NULL, d_bus_call_method_handler, NULL, NULL, NULL, NULL };
+struct dbus_int {
+ int *list;
+ int size;
+};
-static int append_variant(DBusMessageIter *iter,
- const char *sig, char *param[])
+static GVariant *append_variant(const char *sig, char *param[])
{
+ GVariantBuilder builder;
+ GVariantBuilder *sub_builder;
+ GVariant *var;
+ struct dbus_int *array_int;
char *ch;
- int i;
- int int_type;
- uint64_t int64_type;
- DBusMessageIter arr;
- struct dbus_byte *byte;
+ int i, j;
if (!sig || !param)
- return 0;
+ return NULL;
+
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
- for (ch = (char*)sig, i = 0; *ch != '\0'; ++i, ++ch) {
+ for (ch = (char *)sig, i = 0; *ch != '\0'; ++i, ++ch) {
switch (*ch) {
- case 'b':
- int_type = atoi(param[i]);
- dbus_message_iter_append_basic(iter,
- DBUS_TYPE_BOOLEAN, &int_type);
- break;
case 'i':
- int_type = atoi(param[i]);
- dbus_message_iter_append_basic(iter,
- DBUS_TYPE_INT32, &int_type);
+ g_variant_builder_add(&builder, "i", atoi(param[i]));
break;
case 'u':
- int_type = strtoul(param[i], NULL, 10);
- dbus_message_iter_append_basic(iter,
- DBUS_TYPE_UINT32, &int_type);
+ g_variant_builder_add(&builder, "u", strtoul(param[i], NULL, 10));
break;
case 't':
- int64_type = atoll(param[i]);
- dbus_message_iter_append_basic(iter,
- DBUS_TYPE_UINT64, &int64_type);
+ g_variant_builder_add(&builder, "t", atoll(param[i]));
break;
case 's':
- dbus_message_iter_append_basic(iter,
- DBUS_TYPE_STRING, ¶m[i]);
+ g_variant_builder_add(&builder, "s", param[i]);
break;
case 'a':
- ++i, ++ch;
+ ++ch;
switch (*ch) {
- case 'y':
- dbus_message_iter_open_container(iter,
- DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &arr);
- byte = (struct dbus_byte*)param[i];
- dbus_message_iter_append_fixed_array(&arr,
- DBUS_TYPE_BYTE, &(byte->data), byte->size);
- dbus_message_iter_close_container(iter, &arr);
+ case 'i':
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("ai"));
+ array_int = (struct dbus_int *)param[i];
+ for (j = 0; j < array_int->size; j++)
+ g_variant_builder_add(sub_builder, "i", array_int->list[j]);
+ var = g_variant_new("ai", sub_builder);
+ g_variant_builder_unref(sub_builder);
+ g_variant_builder_add_value(&builder, var);
break;
default:
break;
}
break;
- case 'd':
- dbus_message_iter_append_basic(iter,
- DBUS_TYPE_INT32, ¶m[i]);
- break;
-
default:
- return -EINVAL;
+ return NULL;
}
}
- return 0;
+ return g_variant_builder_end(&builder);
}
void serialize_params(char *params[], size_t n, ...)
va_end(va);
}
-DBusMessage *d_bus_call_method_sync(const char *dest, const char *path,
+int d_bus_call_method_sync(const char *dest, const char *path,
const char *interface, const char *method,
const char *sig, char *param[])
{
- DBusConnection *conn;
- DBusMessageIter iter;
- DBusMessage *reply;
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- _cleanup_dbus_message_unref_ DBusMessage *msg = NULL;
- int r;
-
- conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
- if (!conn) {
- _E("dbus_bus_get error");
- return NULL;
- }
-
- msg = dbus_message_new_method_call(dest, path, interface, method);
- if (!msg) {
- _E("dbus_message_new_method_call(%s:%s-%s)", path, interface, method);
- dbus_connection_unref(conn);
- return NULL;
- }
-
- dbus_message_iter_init_append(msg, &iter);
- r = append_variant(&iter, sig, param);
- if (r < 0) {
- _E("append_variant error(%d)", r);
- dbus_connection_unref(conn);
- return NULL;
- }
-
- reply = dbus_connection_send_with_reply_and_block(conn, msg,
- D_BUS_REPLY_TIMEOUT, &err);
-
- if (!reply) {
- if (dbus_error_is_set(&err))
- _E("dbus_connection_send error: (%s:%s) %s %s:%s-%s", err.name, err.message, dest, path, interface, method);
- else
- _E("dbus_connection_send error : %s %s:%s-%s", dest, path, interface, method);
- }
- dbus_connection_unref(conn);
- return reply;
-}
-
-static int dbus_method_sync_pairs(const char *dest, const char *path,
- const char *interface, const char *method,
- int num, va_list args)
-{
- DBusConnection *conn;
- DBusMessage *reply;
- DBusMessageIter iter;
- DBusMessageIter aiter, piter;
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- _cleanup_dbus_message_unref_ DBusMessage *msg = NULL;
- int ret, result, i;
- char *key, *value;
-
- conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
- if (!conn) {
- _E("dbus_bus_get error");
- return -EPERM;
- }
-
- msg = dbus_message_new_method_call(dest, path, interface, method);
- if (!msg) {
- _E("dbus_message_new_method_call(%s:%s-%s)",
- path, interface, method);
- return -EBADMSG;
- }
-
- dbus_message_iter_init_append(msg, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{ss}", &aiter);
-
- for (i = 0 ; i < num ; i = i + 2) {
- key = va_arg(args, char *);
- value = va_arg(args, char *);
- _I("key(%s), value(%s)", key, value);
- dbus_message_iter_open_container(&aiter, DBUS_TYPE_DICT_ENTRY, NULL, &piter);
- dbus_message_iter_append_basic(&piter, DBUS_TYPE_STRING, &key);
- dbus_message_iter_append_basic(&piter, DBUS_TYPE_STRING, &value);
- dbus_message_iter_close_container(&aiter, &piter);
+ int ret;
+ GVariant *reply = NULL;
+ GVariant *gv = NULL;
+
+ if (sig || param) {
+ gv = append_variant(sig, param);
+ if (!gv) {
+ _E("Failed to build g_variant");
+ return -EPERM;
+ }
}
- dbus_message_iter_close_container(&iter, &aiter);
-
- reply = dbus_connection_send_with_reply_and_block(conn, msg, D_BUS_REPLY_TIMEOUT, &err);
+ reply = g_dbus_connection_call_sync(d_bus_get_connection(), dest, path,
+ interface, method, gv, NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
if (!reply) {
- if (dbus_error_is_set(&err))
- _E("dbus_connection_send error: (%s:%s) %s %s:%s-%s", err.name, err.message, dest, path, interface, method);
- else
- _E("dbus_connection_send error : %s %s:%s-%s", dest, path, interface, method);
+ _E("Failed to call gdbus method");
return -ECOMM;
}
- ret = dbus_message_get_args(reply, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
- if (!ret) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
- return -ENOMSG;
- }
+ g_variant_get(reply, "(i)", &ret);
+ g_variant_unref(reply);
- return result;
+ return ret;
}
int d_bus_call_method_async(const char *dest, const char *path,
const char *interface, const char *method,
const char *sig, char *param[])
{
- DBusConnection *conn;
- DBusMessageIter iter;
- _cleanup_dbus_message_unref_ DBusMessage *msg = NULL;
- int ret;
-
- conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
- if (!conn) {
- _E("dbus_bus_get error");
+ GVariant *gv = append_variant(sig, param);
+ if (!gv) {
+ _E("Failed to build g_variant");
return -EPERM;
}
- msg = dbus_message_new_method_call(dest, path, interface, method);
- if (!msg) {
- _E("dbus_message_new_method_call(%s:%s-%s)", path, interface, method);
- return -EBADMSG;
- }
-
- dbus_message_iter_init_append(msg, &iter);
- ret = append_variant(&iter, sig, param);
- if (ret < 0) {
- _E("append_variant error(%d)", ret);
- dbus_message_unref(msg);
- return ret;
- }
-
- ret = dbus_connection_send(conn, msg, NULL);
- if (ret != TRUE) {
- _E("dbus_connection_send error");
- return -ECOMM;
- }
+ g_dbus_connection_call(d_bus_get_connection(), dest, path, interface, method,
+ gv, NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
return 0;
}
-pid_t d_bus_get_sender_pid(DBusMessage *msg)
-{
- const char *sender;
- DBusMessage *send_msg;
- DBusPendingCall *pending;
- DBusMessageIter iter;
- int ret;
- pid_t pid;
-
- if (!msg) {
- _E("invalid argument!");
- return RESOURCED_ERROR_FAIL;
- }
-
- sender = dbus_message_get_sender(msg);
- if (!sender) {
- _E("invalid sender!");
- return RESOURCED_ERROR_FAIL;
- }
-
- send_msg = dbus_message_new_method_call(DBUS_SERVICE_DBUS,
- DBUS_PATH_DBUS,
- DBUS_INTERFACE_DBUS,
- "GetConnectionUnixProcessID");
- if (!send_msg) {
- _E("invalid send msg!");
- return RESOURCED_ERROR_FAIL;
- }
-
- ret = dbus_message_append_args(send_msg, DBUS_TYPE_STRING,
- &sender, DBUS_TYPE_INVALID);
- if (!ret) {
- _E("fail to append args!");
- dbus_message_unref(send_msg);
- return RESOURCED_ERROR_FAIL;
- }
-
- if (!dbus_connection_send_with_reply(dbus_conn, send_msg, &pending, -1)) {
- _E("dbus_connection_send_with_reply failed");
- dbus_message_unref(send_msg);
- return RESOURCED_ERROR_FAIL;
- }
-
- if (!pending) {
- _E("pending is null!");
- dbus_message_unref(send_msg);
- return RESOURCED_ERROR_FAIL;
- }
-
- dbus_message_unref(send_msg);
-
- /* block until reply is received */
- dbus_pending_call_block(pending);
-
- msg = dbus_pending_call_steal_reply(pending);
- dbus_pending_call_unref(pending);
- if (!msg) {
- _E("reply msg is null!");
- return RESOURCED_ERROR_FAIL;
- }
-
- dbus_message_iter_init(msg, &iter);
- dbus_message_iter_get_basic(&iter, &pid);
- dbus_message_unref(msg);
-
- return pid;
-}
-
resourced_ret_c d_bus_register_signal(const char *path, const char *interface,
- const char *name, d_bus_signal_handler handler, void *user_data)
+ const char *name, d_bus_signal_callback callback, void *user_data)
{
struct d_bus_signal *signal;
- char buf[256];
if (d_bus_find_signal(path, interface, name)) {
_E("Same D-Bus signal is already registered");
signal->path = path;
signal->interface = interface;
signal->name = name;
- signal->handler = handler;
+ signal->callback = callback;
signal->user_data = user_data;
- snprintf(buf, 256, "type='signal',path='%s',interface='%s',member='%s'",
- path, interface, name);
- dbus_bus_add_match(dbus_conn, buf, NULL);
-
- dbus_signal_list = g_list_append(dbus_signal_list, signal);
-
- return RESOURCED_ERROR_NONE;
-}
-
-int d_bus_broadcast_signal_str(const char *path, const char *interface,
- const char *name, const char *sig, char *param[])
-{
- _cleanup_dbus_message_unref_ DBusMessage *msg = NULL;
- DBusConnection *conn;
- DBusMessageIter iter;
- int r;
-
- conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
- if (!conn) {
- _E("dbus_bus_get error");
- return -EPERM;
- }
-
- msg = dbus_message_new_signal(path, interface, name);
- if (!msg) {
- _E("fail to allocate new %s.%s signal", interface, name);
- return -EPERM;
- }
-
- dbus_message_iter_init_append(msg, &iter);
- r = append_variant(&iter, sig, param);
- if (r < 0) {
- _E("append_variant error(%d)", r);
- return -EPERM;
+ signal->subscription_id = g_dbus_connection_signal_subscribe(d_bus_get_connection(),
+ NULL, interface, name, path, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
+ d_bus_signal_handler, signal, NULL);
+ if (!(signal->subscription_id)) {
+ _E("Failed to subscribe signal %s", name);
+ return RESOURCED_ERROR_FAIL;
}
- r = dbus_connection_send(conn, msg, NULL);
-
- if (r != TRUE) {
- _E("dbus_connection_send error(%s:%s-%s)",
- path, interface, name);
- return -ECOMM;
- }
+ dbus_signal_list = g_list_append(dbus_signal_list, signal);
return RESOURCED_ERROR_NONE;
}
int d_bus_broadcast_signal(const char *path, const char *interface,
- const char *name, int type, void *value)
+ const char *name, const char *sig, char *param[])
{
- DBusConnection *conn;
- DBusMessage *msg = dbus_message_new_signal(path, interface, name);
- int r;
+ gboolean ret;
+ GVariant *gv;
- conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
- if (!conn) {
- _E("dbus_bus_get error");
+ gv = append_variant(sig, param);
+ if (!gv) {
+ _E("Failed to build g_variant");
return -EPERM;
}
- if (!msg) {
- _E("fail to allocate new %s.%s signal", interface, name);
- return RESOURCED_ERROR_FAIL;
- }
-
- dbus_message_append_args(msg, type, value, DBUS_TYPE_INVALID);
-
- r = dbus_connection_send(conn, msg, NULL);
- dbus_message_unref(msg);
-
- if (r != TRUE) {
- _E("dbus_connection_send error(%s:%s-%s)",
- path, interface, name);
+ ret = g_dbus_connection_emit_signal(d_bus_get_connection(),
+ NULL, path, interface, name, gv, NULL);
+ if (ret != TRUE) {
+ _E("Failed to emit gdbus signal(%s:%s-%s)", path, interface, name);
return -ECOMM;
}
return RESOURCED_ERROR_NONE;
}
-/* You have to use h1 after this function is run */
-static resourced_ret_c d_bus_merge_method_handles(struct d_bus_method_handle *h1,
- struct d_bus_method_handle *h2)
-{
- int i;
- int cur = 0;
- struct d_bus_method *new_methods = calloc(h1->num_methods + h2->num_methods,
- sizeof(struct d_bus_method));
-
- if (!new_methods) {
- _E("Not enough memory!");
- return RESOURCED_ERROR_OUT_OF_MEMORY;
- }
-
- for (i = 0; i < h1->num_methods; i++)
- new_methods[cur++] = h1->methods[i];
-
- for (i = 0; i < h2->num_methods; i++)
- new_methods[cur++] = h2->methods[i];
-
- if (h1->is_merged_methods)
- free(h1->methods);
-
- h1->methods = new_methods;
- h1->is_merged_methods = true;
- h1->num_methods += h2->num_methods;
-
- return RESOURCED_ERROR_NONE;
-}
-
-resourced_ret_c d_bus_register_methods(const char *path,
+resourced_ret_c d_bus_register_methods(const char *path, const char *xml,
struct d_bus_method *methods, const size_t num_methods)
{
- const char *interface;
struct d_bus_method_handle *handle = NULL;
- struct d_bus_method_handle *old_handle = NULL;
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- int ret;
+ GError *err = NULL;
- if (!path) {
- _E("There is no D-Bus method path");
- return RESOURCED_ERROR_INVALID_PARAMETER;
- }
-
- interface = d_bus_get_interface(path);
- if (!interface) {
- _E("%s is not registered path", path);
+ if (!path || !xml || !methods) {
+ _E("You must input path, introspection xml and method list");
return RESOURCED_ERROR_INVALID_PARAMETER;
}
}
handle->path = path;
- handle->interface = interface;
handle->methods = methods;
- handle->is_merged_methods = false;
handle->num_methods = num_methods;
- ret = dbus_connection_try_register_object_path(dbus_conn, handle->path, &vtable, handle, &err);
- if (!ret) {
- if (!strncmp(err.name, DBUS_ERROR_OBJECT_PATH_IN_USE, strlen(DBUS_ERROR_OBJECT_PATH_IN_USE) + 1)) {
- /*
- * If same path is already registered, just merge these (old + new)
- * methods. You don't have to unregister and re-register this path
- * because resourced check latest method list whenever it receive
- */
- ret = dbus_connection_get_object_path_data(dbus_conn, path, (void **)(&old_handle));
- if (!ret) {
- _E("Failed to get registered D-Bus handle");
- return RESOURCED_ERROR_FAIL;
- }
+ handle->node_info = g_dbus_node_info_new_for_xml(xml, &err);
+ if (!handle->node_info) {
+ _E("Failed to make node_info : %s", err->message);
+ return RESOURCED_ERROR_FAIL;
+ }
- ret = d_bus_merge_method_handles(old_handle, handle);
- if (ret != RESOURCED_ERROR_NONE) {
- _E("Failed to merge method D-Bus handles");
- return ret;
- }
- } else {
- _E("Failed to register D-Bus methods with path %s : %s", path, err.message);
- return RESOURCED_ERROR_FAIL;
- }
+ handle->subscription_id = g_dbus_connection_register_object(d_bus_get_connection(),
+ path, handle->node_info->interfaces[0], &vtable, (gpointer)handle, NULL, &err);
+ if (!handle->subscription_id) {
+ _E("Failed to register gdbus methods with path %s : %s", path, err->message);
+ return RESOURCED_ERROR_FAIL;
} else
- dbus_method_handle_list = g_list_append(dbus_method_handle_list, handle);
+ dbus_method_handle_list = g_list_append(dbus_method_handle_list, (gpointer)handle);
return RESOURCED_ERROR_NONE;
}
int ret;
for (i = 0; i < size; i++) {
- if (!signals[i].path || !signals[i].interface || !signals[i].name || !signals[i].handler)
+ if (!signals[i].path || !signals[i].interface || !signals[i].name || !signals[i].callback)
continue;
ret = d_bus_register_signal(
signals[i].path,
signals[i].interface,
signals[i].name,
- signals[i].handler,
+ signals[i].callback,
signals[i].user_data);
if (ret != RESOURCED_ERROR_NONE) {
_E("Fail to add signal %s, %s!\n", signals[i].path, signals[i].name);
return RESOURCED_ERROR_NONE;
}
-resourced_ret_c d_bus_reply_message(DBusMessage *msg)
+resourced_ret_c d_bus_reply_message(GDBusMessage *msg)
{
- if (dbus_connection_send(dbus_conn, msg, NULL))
- return RESOURCED_ERROR_NONE;
- else {
- _E("Fail to reply dbus message");
+ GError *err = NULL;
+
+ if (!g_dbus_connection_send_message(d_bus_get_connection(), msg,
+ G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, &err)) {
+ _E("Fail to reply gdbus message");
return RESOURCED_ERROR_FAIL;
}
-}
-
-int launch_system_app_by_dbus(const char *dest, const char *path,
- const char *iface, const char *method, int num, ...)
-{
- int ret;
- va_list args;
- va_start(args, num);
- ret = dbus_method_sync_pairs(dest, path, iface, method, num, args);
- va_end(args);
- return ret;
+ return RESOURCED_ERROR_NONE;
}
void d_bus_init(void)
{
- int retry = 0;
- int retval;
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
-
- dbus_threads_init_default();
-
-retry_bus_get:
- dbus_conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
- if (dbus_conn) {
- retry = 0;
- goto retry_bus_request;
- }
- if (retry == D_BUS_INIT_RETRY_COUNT) {
- _E("fail to get dbus");
- return;
+ owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM, RESOURCED_DBUS_BUS_NAME,
+ G_BUS_NAME_OWNER_FLAGS_NONE, NULL, NULL, NULL, NULL, NULL);
+ if (owner_id == 0) {
+ _E("Failed to get gdbus own name");
}
- retry++;
- goto retry_bus_get;
-
-retry_bus_request:
- retval = dbus_bus_request_name(dbus_conn, RESOURCED_DBUS_BUS_NAME,
- DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
- if (retval == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
- _I("start dbus service");
- goto do_others;
- }
- if (retry == D_BUS_INIT_RETRY_COUNT) {
- _E("fail to request dbus name");
- dbus_connection_set_exit_on_disconnect(dbus_conn, FALSE);
- return;
- }
- retry++;
- goto retry_bus_request;
-
-do_others:
- dbus_connection_add_filter(dbus_conn, d_bus_call_signal_handler, NULL, NULL);
-
- dbus_connection_set_watch_functions(dbus_conn,
- d_bus_watch_add_cb, d_bus_watch_remove_cb, d_bus_watch_toggled_cb,
- NULL, NULL);
}
void d_bus_exit(void)
GList *iter;
struct d_bus_signal *signal;
struct d_bus_method_handle *method_handle;
- char buf[256];
+ GDBusConnection *conn = d_bus_get_connection();
+
+ if (owner_id != 0)
+ g_bus_unown_name(owner_id);
/* Remove D-Bus signal list */
for (iter = dbus_signal_list; iter; iter = g_list_next(iter)) {
signal = (struct d_bus_signal *)iter->data;
- snprintf(buf, 256, "type='signal',path='%s',interface='%s',member='%s'",
- signal->path, signal->interface, signal->name);
- dbus_bus_remove_match(dbus_conn, buf, NULL);
+ g_dbus_connection_signal_unsubscribe(conn, signal->subscription_id);
free(signal);
dbus_signal_list = g_list_remove(dbus_signal_list, iter);
}
/* Remove D-Bus method list */
for (iter = dbus_method_handle_list; iter; iter = g_list_next(iter)) {
method_handle = (struct d_bus_method_handle *)iter->data;
- dbus_connection_unregister_object_path(dbus_conn, method_handle->path);
+ g_dbus_connection_unregister_object(conn, method_handle->subscription_id);
+ free(method_handle->node_info);
free(method_handle);
dbus_method_handle_list = g_list_remove(dbus_method_handle_list, iter);
}
#define __DBUS_HANDLER_H__
#include <dbus/dbus.h>
+#include <gio/gio.h>
#include <resourced.h>
-typedef void (*d_bus_signal_handler)(void *user_data, DBusMessage *msg);
-typedef DBusMessage *(*d_bus_method_handler)(DBusMessage *msg);
+typedef void (*d_bus_method_callback)(GDBusMethodInvocation *invocation, GVariant *params);
+typedef void (*d_bus_signal_callback)(GVariant *params);
struct d_bus_method {
const char *name;
- const char *signature;
- const char *reply_signature;
- d_bus_method_handler handler;
+ d_bus_method_callback callback;
};
struct d_bus_method_handle {
const char *path;
- const char *interface;
- struct d_bus_method *methods;
- /*
- * Libdbus allows to register methods having same path only one time.
- *
- * Therefore, if you want to many times, you have to load registered
- * method handle and merge handle->methods.
- *
- * In this case, you should free handle->methods when it comes to be
- * needless.
- */
- bool is_merged_methods;
+ const struct d_bus_method *methods;
size_t num_methods;
+ GDBusNodeInfo *node_info;
+ guint subscription_id;
};
struct d_bus_object {
const char *path;
const char *interface;
const char *name;
- d_bus_signal_handler handler;
+ d_bus_signal_callback callback;
void *user_data;
+ guint subscription_id;
};
+//#define D_BUS_REPLY_NULL(ivc) g_dbus_method_invocation_return_value(ivc, g_variant_new_tuple(NULL, 0));
+
+#define D_BUS_REPLY_NULL(ivc) \
+{ \
+ GDBusMessage *re = g_dbus_message_new_method_reply(g_dbus_method_invocation_get_message(ivc)); \
+ d_bus_reply_message(re); \
+ g_object_unref(re); \
+}
+
#define D_BUS_REPLY_TIMEOUT (120 * 1000)
#define RESOURCED_DBUS_BUS_NAME "org.tizen.resourced"
#define RESOURCED_PATH_DBUS RESOURCED_DBUS_OBJECT_PATH"/DBus"
#define RESOURCED_INTERFACE_DBUS RESOURCED_DBUS_INTERFACE_NAME".dbus"
-#define RESOURCED_PATH_APPOPT RESOURCED_DBUS_OBJECT_PATH"/Appopt"
-#define RESOURCED_INTERFACE_APPOPT RESOURCED_DBUS_INTERFACE_NAME".appopt"
-
#define SIGNAL_PROC_WATCHDOG_RESULT "WatchdogResult"
#define SIGNAL_PROC_ACTIVE "Active"
#define SIGNAL_PROC_EXCLUDE "ProcExclude"
int size;
};
-#define RETRY_MAX 5
-
/*
* @desc helper function for filling params array
* That params array is used in d_bus_method_sync/d_bus_method_async
void serialize_params(char *params[], size_t n, ...);
-DBusMessage *d_bus_call_method_sync(const char *dest, const char *path,
+int d_bus_call_method_sync(const char *dest, const char *path,
const char *interface, const char *method,
const char *sig, char *param[]);
const char *sig, char *param[]);
resourced_ret_c d_bus_register_signal(const char *path, const char *interface,
- const char *name, d_bus_signal_handler handler, void *user_data);
-
-pid_t d_bus_get_sender_pid(DBusMessage *msg);
-
-int d_bus_broadcast_signal_str(const char *path, const char *interface,
- const char *name, const char *sig, char *param[]);
+ const char *name, d_bus_signal_callback callback, void *user_data);
int d_bus_broadcast_signal(const char *path, const char *interface,
- const char *name, int type, void *value);
+ const char *name, const char *sig, char *param[]);
-resourced_ret_c d_bus_register_methods(const char *path,
+resourced_ret_c d_bus_register_methods(const char *path, const char *xml,
struct d_bus_method *methods, const size_t num_methods);
resourced_ret_c d_bus_register_signals(const struct d_bus_signal *signals,
const size_t size);
-resourced_ret_c d_bus_reply_message(DBusMessage *msg);
+resourced_ret_c d_bus_reply_message(GDBusMessage *msg);
int launch_system_app_by_dbus(const char *dest, const char *path,
- const char *iface, const char *method, int num, ...);
+ const char *iface, const char *method, const char *arg_type, ...);
void d_bus_init(void);
void d_bus_exit(void);
}
}
-static DBusMessage *dbus_list_active_modules_handler(DBusMessage *msg)
+static void dbus_list_active_modules_handler(GDBusMethodInvocation *invocation, GVariant *params)
{
- DBusMessage *reply;
- DBusMessageIter iter, array_iter;
struct module_ops *module;
GSList *list_iter;
+ GVariantBuilder builder;
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- if (!dbus_message_iter_open_container(&iter,
- DBUS_TYPE_ARRAY,
- DBUS_TYPE_STRING_AS_STRING,
- &array_iter)) {
- _E("Failed to open DBus container");
- goto finish;
- }
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
gslist_for_each_item(list_iter, modules_list) {
module = (struct module_ops *)list_iter->data;
if (module->initalized != MODULE_INITIALIZED)
continue;
- if (!dbus_message_iter_append_basic(&array_iter,
- DBUS_TYPE_STRING,
- &module->name)) {
- _E("Failed to append string to DBus container");
- goto finish;
- }
+ g_variant_builder_add(&builder, "s", module->name);
}
- if (!dbus_message_iter_close_container(&iter, &array_iter))
- _E("Failed to close DBus container");
-
-finish:
- return reply;
+ g_dbus_method_invocation_return_value(invocation,
+ g_variant_builder_end(&builder));
}
+static const char resourced_module_methods_xml[] =
+"<node>"
+" <interface name ='"RESOURCED_DBUS_INTERFACE_NAME"'>"
+" <method name='ListActiveModuels'>"
+" <arg type='as' name='ActiveModules' direction='out'/>"
+" </method>"
+" </interface>"
+"</node>";
+
static struct d_bus_method resourced_module_methods[] = {
- { "ListActiveModuels", NULL, "as", dbus_list_active_modules_handler },
- { NULL, NULL, NULL, NULL },
+ { "ListActiveModuels", dbus_list_active_modules_handler },
/* Add methods here */
};
int modules_add_methods(void)
{
- return d_bus_register_methods(RESOURCED_DBUS_OBJECT_PATH,
- resourced_module_methods, ARRAY_SIZE(resourced_module_methods));
+ d_bus_register_methods(RESOURCED_DBUS_OBJECT_PATH, resourced_module_methods_xml,
+ resourced_module_methods, ARRAY_SIZE(resourced_module_methods));
+ return 0;
}
#include <dlfcn.h>
#include <sys/stat.h>
+#include <gio/gio.h>
#include "macro.h"
#include "util.h"
static int (*resourced_freezer_deinitialize)(void) = NULL;
/* Freezer module dbus method calls and signal handlers */
-static DBusMessage *(*resourced_freezer_dbus_method_handler)(DBusMessage *msg) = NULL;
-static void (*resourced_freezer_dbus_signal_handler)(void *data, DBusMessage *msg) = NULL;
+static void (*resourced_freezer_dbus_method_handler)(GDBusMethodInvocation *invocation, GVariant *params) = NULL;
+static void (*resourced_freezer_dbus_state_signal_handler)(GVariant *params) = NULL;
+static void (*resourced_freezer_dbus_service_signal_handler)(GVariant *params) = NULL;
+static void (*resourced_freezer_dbus_lcdon_complete_signal_handler)(GVariant *params) = NULL;
/* Resourced notifier handlers */
static int (*resourced_freezer_change_state_cb)(void *data) = NULL;
}
/****************************************** Internal symbols **************************************************/
-static DBusMessage *resourced_freezer_dbus_method_handler_generic(DBusMessage *msg)
+static void resourced_freezer_dbus_method_handler_generic(
+ GDBusMethodInvocation *invocation, GVariant *params)
{
- DBusMessageIter iter;
- DBusMessage *reply;
- int ret;
+ /* FREEZER_SUSPEND method can be used when suspend mode is enabled */
+ if (resourced_freezer_is_suspended) {
+ if (!g_strcmp0(g_dbus_method_invocation_get_method_name(invocation),
+ METHOD_SET_FREEZER_SUSPEND) && !resourced_freezer_is_suspended())
+ g_dbus_method_invocation_return_value(invocation,
+ g_variant_new("(i)", -1));
+ }
if (resourced_freezer_dbus_method_handler)
- return resourced_freezer_dbus_method_handler(msg);
-
- ret = 0;
-
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
- return reply;
+ resourced_freezer_dbus_method_handler(invocation, params);
}
-static struct d_bus_method dbus_methods[] = {
- { METHOD_GET_FREEZER_STATE, NULL, "i", resourced_freezer_dbus_method_handler_generic },
- { METHOD_GET_FREEZER_SERVICE, NULL, "i", resourced_freezer_dbus_method_handler_generic },
- /* Add methods here */
-};
+static const char dbus_methods_xml[] =
+"<node>"
+" <interface name='"RESOURCED_INTERFACE_FREEZER"'>"
+" <method name='"METHOD_GET_FREEZER_STATE"'>"
+" <arg type='i' name='FreezerEnabled' direction='out'/>"
+" </method>"
+" <method name='"METHOD_GET_FREEZER_SERVICE"'>"
+" <arg type='i' name='FreezerServiceEnabled' direction='out'/>"
+" </method>"
+" <method name='"METHOD_SET_FREEZER_SUSPEND"'>"
+" <arg type='s' name='Command' direction='in'/>"
+" <arg type='i' name='ZeroOnSuccess' direction='out'/>"
+" </method>"
+" </interface>"
+"</node>";
-static struct d_bus_method dbus_suspend_methods[] = {
- { METHOD_SET_FREEZER_SUSPEND, "s", "i", resourced_freezer_dbus_method_handler_generic },
+static struct d_bus_method dbus_methods[] = {
+ { METHOD_GET_FREEZER_STATE, resourced_freezer_dbus_method_handler_generic },
+ { METHOD_GET_FREEZER_SERVICE, resourced_freezer_dbus_method_handler_generic },
+ { METHOD_SET_FREEZER_SUSPEND, resourced_freezer_dbus_method_handler_generic },
/* Add methods here */
};
d_bus_register_signal(RESOURCED_PATH_FREEZER,
RESOURCED_INTERFACE_FREEZER,
SIGNAL_FREEZER_STATUS,
- (void *)resourced_freezer_dbus_signal_handler,
+ (void *)resourced_freezer_dbus_state_signal_handler,
NULL);
d_bus_register_signal(RESOURCED_PATH_FREEZER,
RESOURCED_INTERFACE_FREEZER,
SIGNAL_FREEZER_SERVICE,
- (void *)resourced_freezer_dbus_signal_handler,
+ (void *)resourced_freezer_dbus_service_signal_handler,
NULL);
- ret = d_bus_register_methods(RESOURCED_PATH_FREEZER,
- dbus_methods,
- ARRAY_SIZE(dbus_methods));
+ ret = d_bus_register_methods(RESOURCED_PATH_FREEZER, dbus_methods_xml,
+ dbus_methods, ARRAY_SIZE(dbus_methods));
ret_msg_if(ret != RESOURCED_ERROR_NONE,
"DBus method registration for %s is failed",
d_bus_register_signal(DEVICED_PATH_DISPLAY,
DEVICED_INTERFACE_DISPLAY,
SIGNAL_DEVICED_LCDONCOMPLETE,
- (void *)resourced_freezer_dbus_signal_handler,
+ (void *)resourced_freezer_dbus_lcdon_complete_signal_handler,
NULL);
-
- ret = d_bus_register_methods(RESOURCED_PATH_FREEZER,
- dbus_suspend_methods,
- ARRAY_SIZE(dbus_suspend_methods));
- ret_msg_if(ret != RESOURCED_ERROR_NONE,
- "DBus method registration for %s is failed",
- RESOURCED_PATH_FREEZER);
}
static bool freezer_is_present(void)
FREEZER_UNLOAD_SYMBOL(resourced_freezer_initialize);
FREEZER_UNLOAD_SYMBOL(resourced_freezer_deinitialize);
FREEZER_UNLOAD_SYMBOL(resourced_freezer_dbus_method_handler);
- FREEZER_UNLOAD_SYMBOL(resourced_freezer_dbus_signal_handler);
+ FREEZER_UNLOAD_SYMBOL(resourced_freezer_dbus_state_signal_handler);
+ FREEZER_UNLOAD_SYMBOL(resourced_freezer_dbus_service_signal_handler);
+ FREEZER_UNLOAD_SYMBOL(resourced_freezer_dbus_lcdon_complete_signal_handler);
FREEZER_UNLOAD_SYMBOL(resourced_freezer_change_state_cb);
FREEZER_UNLOAD_SYMBOL(resourced_freezer_service_launch);
FREEZER_UNLOAD_SYMBOL(resourced_freezer_wakeup);
FREEZER_LOAD_SYMBOL(resourced_freezer_initialize, "freezer_initialize");
FREEZER_LOAD_SYMBOL(resourced_freezer_deinitialize, "freezer_finalize");
FREEZER_LOAD_SYMBOL(resourced_freezer_dbus_method_handler, "freezer_dbus_method_handler");
- FREEZER_LOAD_SYMBOL(resourced_freezer_dbus_signal_handler, "freezer_dbus_signal_handler");
+ FREEZER_LOAD_SYMBOL(resourced_freezer_dbus_state_signal_handler, "freezer_dbus_state_signal_handler");
+ FREEZER_LOAD_SYMBOL(resourced_freezer_dbus_service_signal_handler, "freezer_dbus_service_signal_handler");
+ FREEZER_LOAD_SYMBOL(resourced_freezer_dbus_lcdon_complete_signal_handler, "freezer_dbus_lcdon_complete_signal_handler");
FREEZER_LOAD_SYMBOL(resourced_freezer_change_state_cb, "freezer_change_state_cb");
FREEZER_LOAD_SYMBOL(resourced_freezer_service_launch, "freezer_service_launch");
FREEZER_LOAD_SYMBOL(resourced_freezer_wakeup, "freezer_wakeup");
_I("MalfunctionNotifierLaunch Success");
}
-static void heart_abnormal_process_crashed(void *data, DBusMessage *msg)
+static void heart_abnormal_process_crashed(GVariant *params)
{
int ret, notify, count;
gpointer key, value;
char info[ABNORMAL_DATA_MAX];
struct heart_abnormal_table *table = NULL;
- ret = dbus_message_is_signal(msg, CRASH_INTERFACE_CRASH, PROCESS_CRASHED);
- if (!ret) {
- _E("dbus_message_is_signal error");
- return;
- }
- ret = dbus_message_get_args(msg, NULL,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_STRING, &process_name,
- DBUS_TYPE_STRING, &exepath, DBUS_TYPE_STRING, &appid,
- DBUS_TYPE_STRING, &pkgid, DBUS_TYPE_INVALID);
- if (!ret) {
+ g_variant_get(params, "(issss)", &pid, &process_name, &exepath, &appid, &pkgid);
+ if (pid <= 0 || !process_name || !exepath || !appid || !pkgid) {
_E("Failed: dbus_message_get_args()");
return;
}
free(table);
}
-static DBusMessage *edbus_heart_get_abnormal_data(DBusMessage *msg)
+static void dbus_heart_get_abnormal_data(GDBusMethodInvocation *invocation, GVariant *params)
{
- int type, period, ret, count, i;
+ int type = -1, period = -1;
+ int ret, count, i;
time_t starttime;
char *appid;
gpointer key, value;
- DBusMessage *reply;
- DBusMessageIter iter;
- DBusMessageIter arr;
GHashTableIter hiter;
struct heart_abnormal_table *table = NULL;
+ GVariantBuilder builder, *sub_builder;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &type,
- DBUS_TYPE_INT32, &period, DBUS_TYPE_INVALID);
- if (!ret) {
- _E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
- }
- if (type < 0 || ABNORMAL_TYPE_MAX < type) {
+ g_variant_get(params, "(ii)", &type, &period);
+ if (type < 0 || ABNORMAL_TYPE_MAX < type || period < 0) {
_E("Wrong message arguments! %d", type);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
starttime = time(NULL);
switch (period) {
break;
default:
_E("Wrong message arguments! %d", period);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
if (starttime < 0)
logging_read_foreach(ABNORMAL_NAME, NULL, NULL, starttime, time(NULL),
heart_abnormal_fill_array, heart_abnormal_list);
- reply = dbus_message_new_method_return(msg);
-
- dbus_message_iter_init_append(reply, &iter);
-
ret = pthread_mutex_lock(&heart_abnormal_mutex);
if (ret) {
_E("pthread_mutex_lock() failed, %d", ret);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- g_hash_table_iter_init(&hiter, heart_abnormal_list);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(si)", &arr);
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(si)"));
+
+ g_hash_table_iter_init(&hiter, heart_abnormal_list);
while (g_hash_table_iter_next(&hiter, &key, &value)) {
- DBusMessageIter sub;
table = (struct heart_abnormal_table *)value;
if (!table)
break;
if (!count)
continue;
- dbus_message_iter_open_container(&arr, DBUS_TYPE_STRUCT, NULL, &sub);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &appid);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &count);
- dbus_message_iter_close_container(&arr, &sub);
+ g_variant_builder_add(sub_builder, "(si)", appid, count);
}
- dbus_message_iter_close_container(&iter, &arr);
+ g_variant_builder_add_value(&builder, g_variant_new("a(si)", sub_builder));
+ g_variant_builder_unref(sub_builder);
ret = pthread_mutex_unlock(&heart_abnormal_mutex);
if (ret) {
_E("pthread_mutex_unlock() failed, %d", ret);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
g_hash_table_remove_all(heart_abnormal_list);
- return reply;
+
+ g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
}
+static const char dbus_methods_xml[] =
+" <method name='GetAbnormalData'>"
+" <arg type='i' name='Type' direction='in'/>"
+" <arg type='i' name='Period' direction='in'/>"
+" <arg type='a(si)' name='CountPerApp' direction='out'/>"
+" </method>";
+
static struct d_bus_method dbus_methods[] = {
- { "GetAbnormalData", "ii", "a(si)", edbus_heart_get_abnormal_data },
+ { "GetAbnormalData", dbus_heart_get_abnormal_data },
};
static int heart_abnormal_init(void *data)
return RESOURCED_ERROR_FAIL;
}
- ret = d_bus_register_methods(RESOURCED_PATH_LOGGING, dbus_methods,
- ARRAY_SIZE(dbus_methods));
- if (ret != RESOURCED_ERROR_NONE) {
- _E("DBus method registration for %s is failed",
- RESOURCED_PATH_LOGGING);
- }
+ heart_dbus_declare_methods(dbus_methods_xml, dbus_methods, ARRAY_SIZE(dbus_methods));
+
ret = d_bus_register_signal(CRASH_PATH_CRASH,
CRASH_INTERFACE_CRASH, PROCESS_CRASHED,
heart_abnormal_process_crashed, NULL);
static int heart_battery_direct_get_capacity(void)
{
- int capacity, ret;
- DBusMessage *msg;
+ int capacity;
- msg = d_bus_call_method_sync(DEVICED_BUS_NAME, DEVICED_PATH_BATTERY,
+ capacity = d_bus_call_method_sync(DEVICED_BUS_NAME, DEVICED_PATH_BATTERY,
DEVICED_INTERFACE_BATTERY,
GET_BATTERY_CAPACITY,
NULL, NULL);
- if (!msg) {
+ if (capacity < 0) {
_E("Failed to sync DBUS message.");
return RESOURCED_ERROR_FAIL;
}
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &capacity, DBUS_TYPE_INVALID);
- dbus_message_unref(msg);
- if (!ret) {
- _E("Failed: dbus_message_get_args()");
- return RESOURCED_ERROR_FAIL;
- }
+
return capacity;
}
static enum charger_status_type heart_battery_direct_get_charger_status(void)
{
- int status, ret;
- DBusMessage *msg;
+ int status;
- msg = d_bus_call_method_sync(DEVICED_BUS_NAME, DEVICED_PATH_BATTERY,
+ status = d_bus_call_method_sync(DEVICED_BUS_NAME, DEVICED_PATH_BATTERY,
DEVICED_INTERFACE_BATTERY,
GET_CHARGER_STATUS,
NULL, NULL);
- if (!msg) {
+ if (status < 0) {
_E("Failed to sync DBUS message.");
return RESOURCED_ERROR_FAIL;
}
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &status, DBUS_TYPE_INVALID);
- dbus_message_unref(msg);
- if (!ret) {
- _E("Failed: dbus_message_get_args()");
- return RESOURCED_ERROR_FAIL;
- }
if (status > 0)
return CHARGING;
/* ========================= DBUS -> DEVICED on demand END ================= */
/* ============================ DBUS -> DEVICED handler ====================== */
-static void heart_battery_capacity_status(void *data, DBusMessage *msg)
+static void heart_battery_capacity_status(GVariant *params)
{
/*
* This handler is called when battery capacity value change in 1%
* "f1ae1d1f270e9 battery: add battery capacity dbus signal broadcast")
*/
- int ret, capacity;
+ int capacity;
- ret = dbus_message_is_signal(msg, DEVICED_INTERFACE_BATTERY, GET_BATTERY_CAPACITY);
- if (!ret) {
- _E("dbus_message_is_signal error");
- return;
- }
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &capacity, DBUS_TYPE_INVALID);
- if (!ret) {
+ g_variant_get(params, "(i)", &capacity);
+ if (capacity < 0) {
_E("Failed: dbus_message_get_args()");
return;
}
}
}
-static void heart_battery_charger_status(void *data, DBusMessage *msg)
+static void heart_battery_charger_status(GVariant *params)
{
/*
* This handler is called when USB cable with charging capabilities
* 0 - charger was disconnected
* 1 - charger was connected
*/
- int ret, charger_status, cap_history_size;
+ int charger_status, cap_history_size;
- ret = dbus_message_is_signal(msg, DEVICED_INTERFACE_BATTERY, GET_CHARGER_STATUS);
- if (!ret) {
- _E("dbus_message_is_signal error");
- return;
- }
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &charger_status, DBUS_TYPE_INVALID);
- if (!ret) {
+ g_variant_get(params, "(i)", &charger_status);
+ if (charger_status < 0) {
_E("Failed: dbus_message_get_args()");
return;
}
/* ============================ DBUS interface ====================== */
-static DBusMessage *dbus_get_battery_capacity_history_latest(DBusMessage *msg)
+static void dbus_get_battery_capacity_history_latest(GDBusMethodInvocation *invocation, GVariant *params)
{
- int i, ret, size, charge, max_size;
- DBusMessage *reply;
- DBusMessageIter d_iter;
- DBusMessageIter arr;
+ int i, size, charge, max_size;
GArray *arrays = NULL;
+ GVariantBuilder builder, *sub_builder;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &charge, DBUS_TYPE_INT32, &max_size, DBUS_TYPE_INVALID);
- if (!ret) {
+ g_variant_get(params, "(ii)", &charge, &max_size);
+ if (charge < 0 || max_size < 0) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- reply = dbus_message_new_method_return(msg);
+
size = g_slist_length(capacity_history_list);
if (!size) {
_I("capacity history is empty");
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- dbus_message_iter_init_append(reply, &d_iter);
arrays = g_array_new(FALSE, FALSE, sizeof(struct heart_battery_capacity *));
if (!arrays) {
_E("Failed to alloc array");
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
if (heart_battery_get_capacity_history_latest(arrays, charge, max_size) != RESOURCED_ERROR_NONE) {
_E("Failed to get capacity history latest");
_E("No battery capacity history data");
goto exit;
}
- dbus_message_iter_open_container(&d_iter, DBUS_TYPE_ARRAY, "(iii)", &arr);
+
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(iii)"));
+
for (i = 0; i < arrays->len; i++) {
- DBusMessageIter sub;
struct heart_battery_capacity *lbc;
lbc = g_array_index(arrays, struct heart_battery_capacity *, i);
if (!lbc)
break;
- dbus_message_iter_open_container(&arr, DBUS_TYPE_STRUCT, NULL, &sub);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &lbc->capacity);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &lbc->used_time);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &lbc->charging_time);
- dbus_message_iter_close_container(&arr, &sub);
+
+ g_variant_builder_add(sub_builder, "(iii)", lbc->capacity,
+ lbc->used_time, lbc->charging_time);
free(lbc);
}
- dbus_message_iter_close_container(&d_iter, &arr);
+ g_variant_builder_add_value(&builder, g_variant_new("a(iii)", sub_builder));
+ g_variant_builder_unref(sub_builder);
exit:
g_array_free(arrays, TRUE);
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
}
-static DBusMessage *dbus_get_battery_capacity_history(DBusMessage *msg)
+static void dbus_get_battery_capacity_history(GDBusMethodInvocation *invocation, GVariant *params)
{
int ret, size, period, index;
- DBusMessage *reply;
- DBusMessageIter d_iter;
- DBusMessageIter arr;
struct heart_battery_capacity *lbc;
GSList *iter;
time_t curr = time(NULL);
+ GVariantBuilder builder, *sub_builder;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &period, DBUS_TYPE_INVALID);
- if (!ret) {
+ g_variant_get(params, "(i)", &period);
+ if (period < 0) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
switch (period) {
case DATA_LATEST:
break;
default:
_E("Wrong message arguments! %d", period);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- reply = dbus_message_new_method_return(msg);
size = g_slist_length(capacity_history_list);
if (!size) {
_I("capacity history is empty");
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- dbus_message_iter_init_append(reply, &d_iter);
- dbus_message_iter_open_container(&d_iter, DBUS_TYPE_ARRAY, "(iii)", &arr);
ret = pthread_mutex_lock(&heart_battery_mutex);
if (ret) {
_E("pthread_mutex_lock() failed, %d", ret);
- dbus_message_iter_close_container(&d_iter, &arr);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation)
+ return;
}
+
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(su)"));
+
gslist_for_each_item(iter, capacity_history_list) {
- DBusMessageIter sub;
lbc = (struct heart_battery_capacity *)iter->data;
if (!lbc)
break;
if (index && (lbc->timestamp < curr - (index * 3600)))
continue;
- dbus_message_iter_open_container(&arr, DBUS_TYPE_STRUCT, NULL, &sub);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &lbc->capacity);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &lbc->used_time);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &lbc->charging_time);
- dbus_message_iter_close_container(&arr, &sub);
+
+ g_variant_builder_add(sub_builder, "(iii)", lbc->capacity,
+ lbc->used_time, lbc->charging_time);
}
+
ret = pthread_mutex_unlock(&heart_battery_mutex);
if (ret) {
_E("pthread_mutex_unlock() failed, %d", ret);
- dbus_message_iter_close_container(&d_iter, &arr);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ g_variant_builder_unref(sub_builder);
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- dbus_message_iter_close_container(&d_iter, &arr);
- return reply;
+
+ g_variant_builder_add_value(&builder, g_variant_new("a(iii)", sub_builder));
+ g_variant_builder_unref(sub_builder);
+
+ g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
}
-static DBusMessage *dbus_get_battery_used_time(DBusMessage *msg)
+static void dbus_get_battery_used_time(GDBusMethodInvocation *invocation, GVariant *params)
{
- int ret;
- DBusMessage *reply;
- DBusMessageIter iter;
-
heart_battery_update_used_time(logging_get_time(CLOCK_BOOTTIME),
batt_stat.curr_charger_status);
- ret = batt_used.used_time_sec;
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
- return reply;
+ g_dbus_method_invocation_return_value(invocation,
+ g_variant_new("(i)", batt_used.used_time_sec));
}
static int get_battery_remaining_time(int mode, enum charger_status_type status)
}
}
-static DBusMessage *dbus_get_battery_remaining_time(DBusMessage *msg)
+static void dbus_get_battery_remaining_time(GDBusMethodInvocation *invocation, GVariant *params)
{
- DBusMessage *reply;
- DBusMessageIter iter;
int ret, mode;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &mode, DBUS_TYPE_INVALID);
- if (!ret) {
+ g_variant_get(params, "(i)", &mode);
+ if (mode < 0) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation)
+ return;
}
if (!battery_learning_mode)
} else
ret = get_battery_remaining_time(mode, DISCHARGING);
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
_I("Remaining_time %d (mode: %d)", ret, mode);
-
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(i)", ret));
}
-static DBusMessage *dbus_get_battery_charging_time(DBusMessage *msg)
+static void dbus_get_battery_charging_time(GDBusMethodInvocation *invocation, GVariant *params)
{
- DBusMessage *reply;
- DBusMessageIter iter;
- int ret;
-
- ret = get_battery_remaining_time(POWER_NORMAL_MODE, CHARGING);
-
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
+ int ret = get_battery_remaining_time(POWER_NORMAL_MODE, CHARGING);
_I("Remaining_charging_time %d", ret);
-
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(i)", ret));
}
-static DBusMessage *dbus_get_battery_discharge_rate_level(DBusMessage *msg)
+static void dbus_get_battery_discharge_rate_level(GDBusMethodInvocation *invocation, GVariant *params)
{
- DBusMessage *reply;
- DBusMessageIter iter;
- int ret;
-
- ret = batt_stat.discharge_rate_level;
-
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
+ int ret = batt_stat.discharge_rate_level;
_I("discharge_rate_level %d", ret);
-
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(i)", ret));
}
-static DBusMessage *dbus_battery_save_to_file(DBusMessage *msg)
+static void dbus_battery_save_to_file(GDBusMethodInvocation *invocation, GVariant *params)
{
int ret;
- DBusMessage *reply;
- DBusMessageIter iter;
ret = heart_battery_status_save_to_db();
if (ret) {
_E("save to db failed");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation)
+ return;
}
ret = heart_battery_capacity_save_to_file(HEART_BATTERY_CAPACITY_DATA_FILE);
if (ret) {
_E("save to file failed");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation)
+ return;
}
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
- return reply;
-}
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(i)", ret));
+}
+
+static const char dbus_methods_xml[] =
+" <method name='GetBatteryCapacityHistory'>"
+" <arg type='i' name='Period' direction='in'/>"
+" <arg type='a(iii)' name='CapacityHistory' direction='out'/>"
+" </method>"
+" <method name='GetBatteryCapacityHistoryLatest'>"
+" <arg type='i' name='Charge' direction='in'/>"
+" <arg type='i' name='MaxSize' direction='in'/>"
+" <arg type='a(iii)' name='CapacityHistory' direction='out'/>"
+" </method>"
+" <method name='GetBatteryUsedTime'>"
+" <arg type='i' name='UsedTime' direction='out'/>"
+" </method>"
+" <method name='GetBatteryRemainingTime'>"
+" <arg type='i' name='Mode' direction='in'/>"
+" <arg type='i' name='RemainingTime' direction='out'/>"
+" </method>"
+" <method name='GetBatteryChargingTime'>"
+" <arg type='i' name='ChargingTime' direction='out'/>"
+" </method>"
+" <method name='GetBatteryDischargeRateLevel'>"
+" <arg type='i' name='DischargeRateLevel' direction='out'/>"
+" </method>"
+" <method name='SaveBatteryData'>"
+" <arg type='i' name='ZeroOnSuccess' direction='out'/>"
+" </method>";
static struct d_bus_method dbus_methods[] = {
- { "GetBatteryCapacityHistory", "i", "a(iii)", dbus_get_battery_capacity_history },
- { "GetBatteryCapacityHistoryLatest", "ii", "a(iii)", dbus_get_battery_capacity_history_latest },
- { "GetBatteryUsedTime", NULL, "i", dbus_get_battery_used_time },
- { "GetBatteryRemainingTime", "i", "i", dbus_get_battery_remaining_time },
- { "GetBatteryChargingTime", NULL, "i", dbus_get_battery_charging_time },
- { "GetBatteryDischargeRateLevel", NULL, "i", dbus_get_battery_discharge_rate_level },
- { "SaveBatteryData", NULL, "i", dbus_battery_save_to_file },
+ { "GetBatteryCapacityHistory", dbus_get_battery_capacity_history },
+ { "GetBatteryCapacityHistoryLatest", dbus_get_battery_capacity_history_latest },
+ { "GetBatteryUsedTime", dbus_get_battery_used_time },
+ { "GetBatteryRemainingTime", dbus_get_battery_remaining_time },
+ { "GetBatteryChargingTime", dbus_get_battery_charging_time },
+ { "GetBatteryDischargeRateLevel", dbus_get_battery_discharge_rate_level },
+ { "SaveBatteryData", dbus_battery_save_to_file },
};
/* ========================= DBUS interface END ==================== */
return RESOURCED_ERROR_FAIL;
}
- ret = d_bus_register_methods(RESOURCED_PATH_LOGGING, dbus_methods,
- ARRAY_SIZE(dbus_methods));
- if (ret != RESOURCED_ERROR_NONE) {
- _E("DBus method registration for %s is failed",
- RESOURCED_PATH_LOGGING);
- }
+ heart_dbus_declare_methods(dbus_methods_xml, dbus_methods, ARRAY_SIZE(dbus_methods));
+
ret = d_bus_register_signal(DEVICED_PATH_BATTERY,
DEVICED_INTERFACE_BATTERY, GET_BATTERY_CAPACITY,
heart_battery_capacity_status, NULL);
return logging_modify_appid(CPU_NAME, old_appid, new_appid, pid);
}
-static DBusMessage *dbus_heart_get_cpu_data(DBusMessage *msg)
+static void dbus_heart_get_cpu_data(GDBusMethodInvocation *invocation, GVariant *params)
{
- int period, index, i, ret;
- char *appid;
+ int period = -1, index, i, ret;
+ char *appid = NULL;
struct heart_cpu_table *table;
- DBusMessage *reply;
- DBusMessageIter iter;
time_t utime = 0, stime = 0;
- int uid;
+ int uid = -1;
GHashTable *hashtable;
- ret = dbus_message_get_args(msg, NULL,
- DBUS_TYPE_INT32, &uid,
- DBUS_TYPE_STRING, &appid,
- DBUS_TYPE_INT32, &period, DBUS_TYPE_INVALID);
-
- if (!ret) {
+ g_variant_get(params, "(isi)", &uid, &appid, &period);
+ if (uid < 0 || !appid || period < 0) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
switch (period) {
case DATA_LATEST:
break;
default:
_E("Wrong message arguments! %d", period);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
hashtable = heart_cpu_get_user_app_list(uid);
if (!hashtable) {
_E("Fail to get app list");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
if (!g_hash_table_size(hashtable)) {
_E("hash table is empty");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
ret = pthread_mutex_lock(&heart_cpu_mutex);
if (ret) {
_E("pthread_mutex_lock() failed, %d", ret);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
table = g_hash_table_lookup(hashtable, (gconstpointer)appid);
- if (!table)
+ if (!table) {
+ D_BUS_REPLY_NULL(invocation);
goto unlock_exit;
+ }
if (period == DATA_LATEST) {
utime = table->total_utime;
stime = table->total_stime;
stime += ci->stime;
}
}
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &utime);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &stime);
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(ii)",
+ utime, stime));
+
unlock_exit:
ret = pthread_mutex_unlock(&heart_cpu_mutex);
- if (ret) {
+ if (ret)
_E("pthread_mutex_unlock() failed, %d", ret);
- reply = dbus_message_new_method_return(msg);
- return reply;
- }
- return reply;
}
-static DBusMessage *dbus_heart_get_cpu_data_list(DBusMessage *msg)
+static void dbus_heart_get_cpu_data_list(GDBusMethodInvocation *invocation, GVariant *params)
{
int period, index, i, ret;
gpointer value;
GHashTableIter h_iter;
struct heart_cpu_table *table;
- DBusMessage *reply;
- DBusMessageIter d_iter;
- DBusMessageIter arr;
char *appid;
unsigned long utime, stime, ftime, total;
int uid;
GHashTable *hashtable;
- utime = stime = ftime = total = 0;
+ GVariantBuilder builder, *sub_builder;
- ret = dbus_message_get_args(msg, NULL,
- DBUS_TYPE_INT32, &uid,
- DBUS_TYPE_INT32, &period, DBUS_TYPE_INVALID);
+ utime = stime = ftime = total = 0;
- if (!ret) {
+ g_variant_get(params, "(ii)", &uid, &period);
+ if (uid < 0 || period < 0) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
heart_cpu_update_app_list(NULL);
break;
default:
_E("Wrong message arguments! %d", period);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
hashtable = heart_cpu_get_user_app_list(uid);
if (!hashtable) {
_E("Fail to get app list");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
if (!g_hash_table_size(hashtable)) {
_E("hash table is empty");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &d_iter);
- dbus_message_iter_open_container(&d_iter, DBUS_TYPE_ARRAY, "(sii)", &arr);
ret = pthread_mutex_lock(&heart_cpu_mutex);
if (ret) {
_E("pthread_mutex_lock() failed, %d", ret);
- dbus_message_iter_close_container(&d_iter, &arr);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- g_hash_table_iter_init(&h_iter, hashtable);
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(sii)"));
+ g_hash_table_iter_init(&h_iter, hashtable);
while (g_hash_table_iter_next(&h_iter, &key, &value)) {
- DBusMessageIter sub;
-
table = (struct heart_cpu_table *)value;
if (!table)
break;
total = utime + stime;
if (total == 0)
continue;
- dbus_message_iter_open_container(&arr, DBUS_TYPE_STRUCT, NULL, &sub);
appid = table->appid;
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &appid);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &total);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_INT32, &ftime);
- dbus_message_iter_close_container(&arr, &sub);
+
+ g_variant_builder_add(sub_builder, "(sii)", appid, total, ftime);
}
ret = pthread_mutex_unlock(&heart_cpu_mutex);
if (ret) {
_E("pthread_mutex_unlock() failed, %d", ret);
- dbus_message_iter_close_container(&d_iter, &arr);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ g_variant_builder_unref(sub_builder);
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- dbus_message_iter_close_container(&d_iter, &arr);
+ g_variant_builder_add_value(&builder, g_variant_new("a(sii)", sub_builder));
+ g_variant_builder_unref(sub_builder);
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
}
-static DBusMessage *dbus_heart_reset_cpu_data(DBusMessage *msg)
+static void dbus_heart_reset_cpu_data(GDBusMethodInvocation *invocation, GVariant *params)
{
- int ret;
- DBusMessage *reply;
- DBusMessageIter iter_msg;
+ int ret = -1;
GHashTableIter iter_table;
gpointer key, value;
while (g_hash_table_iter_next(&iter_table, &key, &value))
ret = heart_cpu_hashtable_renew(((struct heart_cpu_dat_cache*)value)->list, time(NULL));
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter_msg);
- dbus_message_iter_append_basic(&iter_msg, DBUS_TYPE_INT32, &ret);
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(i)", ret));
}
-static DBusMessage *dbus_heart_update_cpu_data(DBusMessage *msg)
+static void dbus_heart_update_cpu_data(GDBusMethodInvocation *invocation, GVariant *params)
{
- int ret = 0;
- DBusMessage *reply;
- DBusMessageIter iter;
-
heart_cpu_update_app_list(NULL);
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
- return reply;
+
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(i)", 0));
}
-static DBusMessage *dbus_heart_sync_cpu_data(DBusMessage *msg)
+static void dbus_heart_sync_cpu_data(GDBusMethodInvocation *invocation, GVariant *params)
{
int ret = 0;
- DBusMessage *reply;
- DBusMessageIter iter;
+ GDBusMessage *reply = g_dbus_message_new_method_reply(
+ g_dbus_method_invocation_get_message(invocation));
+ if (!reply) {
+ _E("Failed to make reply message");
+ return;
+ }
heart_cpu_update_app_list(NULL);
- reply = dbus_message_new_method_return(msg);
-
ret = logging_sync(reply);
- if (!ret)
- return NULL;
+ if (ret)
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(i)", ret));
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
- return reply;
+ g_object_unref(reply);
}
-static DBusMessage *dbus_heart_save_to_file(DBusMessage *msg)
+static void dbus_heart_save_to_file(GDBusMethodInvocation *invocation, GVariant *params)
{
int ret;
- DBusMessage *reply;
- DBusMessageIter iter_msg;
GHashTableIter iter_table;
gpointer key, value;
ret = heart_cpu_save_to_file(cache);
if (ret) {
_E("save to file failed");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
cache->last_file_commit_time = logging_get_time(CLOCK_BOOTTIME);
}
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter_msg);
- dbus_message_iter_append_basic(&iter_msg, DBUS_TYPE_INT32, &ret);
-
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(i)", ret));
}
+static const char dbus_methods_xml[] =
+" <method name='GetCpuData'>"
+" <arg type='i' name='Uid' direction='in'/>"
+" <arg type='s' name='Appid' direction='in'/>"
+" <arg type='i' name='Period' direction='in'/>"
+" <arg type='i' name='Utime' direction='out'/>"
+" <arg type='i' name='Stime' direction='out'/>"
+" </method>"
+" <method name='GetCpuDataList'>"
+" <arg type='i' name='Uid' direction='in'/>"
+" <arg type='i' name='Period' direction='in'/>"
+" <arg type='a(sii)' name='CpuTimePerApp' direction='out'/>"
+" </method>"
+" <method name='ResetCpuData'>"
+" <arg type='i' name='ZeroOnSuccess' direction='out'/>"
+" </method>"
+" <method name='UpdateCpuData'>"
+" <arg type='i' name='Zero' direction='out'/>"
+" </method>"
+" <method name='SyncCpuData'>"
+" <arg type='i' name='ZeroOnSuccess' direction='out'/>"
+" </method>"
+" <method name='SaveCpuData'>"
+" <arg type='i' name='ZeroOnSuccess' direction='out'/>"
+" </method>";
+
static struct d_bus_method dbus_methods[] = {
- { "GetCpuData", "isi", "ii", dbus_heart_get_cpu_data },
- { "GetCpuDataList", "ii", "a(sii)", dbus_heart_get_cpu_data_list },
- { "ResetCpuData", NULL, "i", dbus_heart_reset_cpu_data },
- { "UpdateCpuData", NULL, "i", dbus_heart_update_cpu_data },
- { "SyncCpuData", NULL, "i", dbus_heart_sync_cpu_data },
- { "SaveCpuData", NULL, "i", dbus_heart_save_to_file },
+ { "GetCpuData", dbus_heart_get_cpu_data },
+ { "GetCpuDataList", dbus_heart_get_cpu_data_list },
+ { "ResetCpuData", dbus_heart_reset_cpu_data },
+ { "UpdateCpuData", dbus_heart_update_cpu_data },
+ { "SyncCpuData", dbus_heart_sync_cpu_data },
+ { "SaveCpuData", dbus_heart_save_to_file },
};
static int heart_cpu_reset(void *data)
}
}
- ret = d_bus_register_methods(RESOURCED_PATH_LOGGING, dbus_methods,
- ARRAY_SIZE(dbus_methods));
- if (ret != RESOURCED_ERROR_NONE) {
- _E("DBus method registration for %s is failed",
- RESOURCED_PATH_LOGGING);
- }
+ heart_dbus_declare_methods(dbus_methods_xml, dbus_methods, ARRAY_SIZE(dbus_methods));
register_notifier(RESOURCED_NOTIFIER_SERVICE_LAUNCH, heart_cpu_service_launch);
register_notifier(RESOURCED_NOTIFIER_APP_FOREGRD, heart_cpu_foreground_state);
static const struct heart_module_ops heart_cpu_ops = {
.name = "CPU",
.init = heart_cpu_init,
- .dump = heart_cpu_dump,
+ .dump = heart_cpu_dump,
.exit = heart_cpu_exit,
};
HEART_MODULE_REGISTER(&heart_cpu_ops)
--- /dev/null
+/*
+ * resourced
+ *
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * @file heart-dbus.c
+ *
+ * @desc dbus methods for heart module
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <glib.h>
+#include <gio/gio.h>
+
+#include "dbus-handler.h"
+#include "heart.h"
+#include "logging.h"
+#include "macro.h"
+#include "notifier.h"
+#include "trace.h"
+
+#define MAX_XML_LEN 16384
+
+static void dbus_update_data_list(GDBusMethodInvocation *invocation, GVariant *params)
+{
+ resourced_notify(RESOURCED_NOTIFIER_DATA_UPDATE, NULL);
+
+ logging_save_to_storage(true);
+ /* update data list from db */
+ logging_update(true);
+
+ D_BUS_REPLY_NULL(invocation);
+}
+
+static void dbus_flush_cache(GDBusMethodInvocation *invocation, GVariant *params)
+{
+ /* flush module cache */
+ logging_save_to_storage(true);
+
+ D_BUS_REPLY_NULL(invocation);
+}
+
+static const char dbus_methods_xml_prefix[] =
+"<node>"
+" <interface name='"RESOURCED_INTERFACE_LOGGING"'>"
+" <method name='UpdateDataList'>"
+" </method>"
+" <method name='Flush'>"
+" </method>";
+
+static const char dbus_methods_xml_suffix[] =
+" </interface>"
+"</node>";
+
+static int num_methods;
+static char dbus_methods_xml_body[MAX_XML_LEN];
+static struct d_bus_method dbus_methods[128] = {
+ { "UpdateDataList", dbus_update_data_list },
+ { "Flush", dbus_flush_cache },
+};
+
+void heart_dbus_declare_methods(const char *xml, const struct d_bus_method *methods,
+ const size_t size)
+{
+ int i;
+
+ g_strlcat(dbus_methods_xml_body, xml, MAX_XML_LEN);
+
+ for (i = 0; i < size; i++)
+ dbus_methods[num_methods++] = methods[i];
+}
+
+int heart_dbus_init(void)
+{
+ char dbus_methods_xml[MAX_XML_LEN] = { 0, };
+
+ g_strlcat(dbus_methods_xml, dbus_methods_xml_prefix, MAX_XML_LEN);
+ g_strlcat(dbus_methods_xml, dbus_methods_xml_body, MAX_XML_LEN);
+ g_strlcat(dbus_methods_xml, dbus_methods_xml_suffix, MAX_XML_LEN);
+
+ return d_bus_register_methods(RESOURCED_PATH_LOGGING, dbus_methods_xml,
+ dbus_methods, ARRAY_SIZE(dbus_methods));
+}
return true;
}
-static DBusMessage *dbus_get_memory_latest(DBusMessage *msg)
+static void dbus_get_memory_latest(GDBusMethodInvocation *invocation, GVariant *params)
{
int ret;
- DBusMessageIter iter;
- DBusMessage *reply;
char *appid;
unsigned int pss = 0, uss = 0;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &appid, DBUS_TYPE_INVALID);
-
- if (!ret) {
+ g_variant_get(params, "(s)", &appid);
+ if (!appid) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
ret = heart_memory_get_latest_data(appid, &pss, &uss);
if (ret) {
_E("heart_memory_get_latest_data failed %d", ret);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
-
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &pss);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &uss);
-
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(uu)",
+ pss, uss));
}
-static DBusMessage *dbus_get_memory_data(DBusMessage *msg)
+static void dbus_get_memory_data(GDBusMethodInvocation *invocation, GVariant *params)
{
- int ret, period;
- DBusMessageIter iter;
- DBusMessage *reply;
+ int period;
char *appid;
struct heart_memory_data *md;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &appid, DBUS_TYPE_INT32, &period, DBUS_TYPE_INVALID);
-
- if (!ret) {
+ g_variant_get(params, "(si)", &appid, &period);
+ if (!appid || period < 0) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
md = heart_memory_get_data(appid, period);
-
if (!md) {
- _E("heart_memory_get_data failed %d", ret);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ _E("heart_memory_get_data failed");
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
-
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &md->max_pss);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &md->avg_pss);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &md->max_uss);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &md->avg_uss);
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(uuuu)",
+ md->max_pss, md->avg_pss, md->max_uss, md->avg_uss));
free(md);
-
- return reply;
}
-static DBusMessage *dbus_get_memory_data_list(DBusMessage *msg)
+static void dbus_get_memory_data_list(GDBusMethodInvocation *invocation, GVariant *params)
{
int i, ret, period;
char *appid, *pkgid;
GArray *temp_array;
- DBusMessageIter iter;
- DBusMessageIter arr;
- DBusMessage *reply;
+ GVariantBuilder builder, *sub_builder;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &period, DBUS_TYPE_INVALID);
-
- if (!ret) {
+ g_variant_get(params, "(i)", &period);
+ if (period < 0) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
temp_array = g_array_new(false, false, sizeof(struct heart_memory_data *));
if (ret) {
_E("heart_memory_get_table failed %d", ret);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ssuuuu)", &arr);
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(ssuuuu)"));
for (i = 0; i < temp_array->len; i++) {
- DBusMessageIter sub;
struct heart_memory_data *md;
md = g_array_index(temp_array, struct heart_memory_data *, i);
- dbus_message_iter_open_container(&arr, DBUS_TYPE_STRUCT, NULL, &sub);
appid = md->appid;
pkgid = md->pkgid;
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &appid);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &pkgid);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &md->max_pss);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &md->avg_pss);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &md->max_uss);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &md->avg_uss);
-
- dbus_message_iter_close_container(&arr, &sub);
+
+ g_variant_builder_add(sub_builder, "(ssuuuu)", appid, pkgid,
+ md->max_pss, md->avg_pss, md->max_uss, md->avg_uss);
}
+ g_variant_builder_add_value(&builder, g_variant_new("a(ssuuuu)", sub_builder));
+ g_variant_builder_unref(sub_builder);
- dbus_message_iter_close_container(&iter, &arr);
+ g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
g_array_free(temp_array, true);
-
- return reply;
}
-static DBusMessage *dbus_get_memorydb(DBusMessage *msg)
+static void dbus_get_memorydb(GDBusMethodInvocation *invocation, GVariant *params)
{
- int i, ret, period;
+ int i, period;
char *appid, *pkgid;
GArray *temp_array;
- DBusMessageIter iter;
- DBusMessageIter arr;
- DBusMessage *reply;
+ GVariantBuilder builder, *sub_builder;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &period, DBUS_TYPE_INVALID);
-
- if (!ret) {
+ g_variant_get(params, "(i)", &period);
+ if (period < 0) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
+
temp_array = g_array_new(false, false, sizeof(struct heart_memory_data *));
_E("start get read query!!! %d", time(NULL));
- ret = heart_memory_get_query(temp_array, period);
+ heart_memory_get_query(temp_array, period);
_E("end get read query!!! %d", time(NULL));
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ssuuuu)", &arr);
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(ssuuuu)"));
for (i = 0; i < temp_array->len; i++) {
- DBusMessageIter sub;
struct heart_memory_data *md;
md = g_array_index(temp_array, struct heart_memory_data *, i);
- dbus_message_iter_open_container(&arr, DBUS_TYPE_STRUCT, NULL, &sub);
appid = md->appid;
pkgid = md->pkgid;
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &appid);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &pkgid);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &md->max_pss);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &md->avg_pss);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &md->max_uss);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &md->avg_uss);
-
- dbus_message_iter_close_container(&arr, &sub);
+
+ g_variant_builder_add(sub_builder, "(ssuuuu)", appid, pkgid,
+ md->max_pss, md->avg_pss, md->max_uss, md->avg_uss);
}
+ g_variant_builder_add_value(&builder, g_variant_new("a(ssuuuu)", sub_builder));
+ g_variant_builder_unref(sub_builder);
- dbus_message_iter_close_container(&iter, &arr);
+ g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
g_array_free(temp_array, true);
-
- return reply;
}
-static DBusMessage *dbus_get_memoryforeach(DBusMessage *msg)
+static void dbus_get_memoryforeach(GDBusMethodInvocation *invocation, GVariant *params)
{
- int i, ret, period;
+ int i, period;
char *appid, *pkgid;
GArray *temp_array;
- DBusMessageIter iter;
- DBusMessageIter arr;
- DBusMessage *reply;
-
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &period, DBUS_TYPE_INVALID);
+ GVariantBuilder builder, *sub_builder;
- if (!ret) {
+ g_variant_get(params, "(i)", &period);
+ if (period < 0) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
+
/* read from query */
temp_array = g_array_new(false, false, sizeof(struct heart_memory_data *));
_E("start get read foreach!!! %d", time(NULL));
- ret = logging_memory_get_foreach(temp_array, period);
+ logging_memory_get_foreach(temp_array, period);
_E("end get read foreach!!! %d", time(NULL));
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ssuuuu)", &arr);
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(ssuuuu)"));
for (i = 0; i < temp_array->len; i++) {
- DBusMessageIter sub;
struct heart_memory_data *md;
md = g_array_index(temp_array, struct heart_memory_data *, i);
- dbus_message_iter_open_container(&arr, DBUS_TYPE_STRUCT, NULL, &sub);
appid = md->appid;
pkgid = md->pkgid;
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &appid);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &pkgid);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &md->max_pss);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &md->avg_pss);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &md->max_uss);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &md->avg_uss);
-
- dbus_message_iter_close_container(&arr, &sub);
+
+ g_variant_builder_add(sub_builder, "(ssuuuu)", appid, pkgid,
+ md->max_pss, md->avg_pss, md->max_uss, md->avg_uss);
}
+ g_variant_builder_add_value(&builder, g_variant_new("a(ssuuuu)", sub_builder));
+ g_variant_builder_unref(sub_builder);
- dbus_message_iter_close_container(&iter, &arr);
+ g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
g_array_free(temp_array, true);
-
- return reply;
}
-static DBusMessage *dbus_memory_save_to_file(DBusMessage *msg)
+static void dbus_memory_save_to_file(GDBusMethodInvocation *invocation, GVariant *params)
{
int ret;
- DBusMessage *reply;
- DBusMessageIter iter;
ret = heart_memory_save_to_file(heart_memory_app_list, HEART_MEMORY_FILE);
if (ret) {
_E("save to file failed");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(i)", ret));
}
+static const char dbus_methods_xml[] =
+" <method name='GetMemoryLatest'>"
+" <arg type='s' name='Appid' direction='in'/>"
+" <arg type='u' name='Pss' direction='out'/>"
+" <arg type='u' name='Uss' direction='out'/>"
+" </method>"
+" <method name='GetMemoryData'>"
+" <arg type='s' name='Appid' direction='in'/>"
+" <arg type='i' name='Period' direction='in'/>"
+" <arg type='u' name='MaxPss' direction='out'/>"
+" <arg type='u' name='AvgPss' direction='out'/>"
+" <arg type='u' name='MaxUss' direction='out'/>"
+" <arg type='u' name='AvgUss' direction='out'/>"
+" </method>"
+" <method name='GetMemoryDataList'>"
+" <arg type='i' name='Period' direction='in'/>"
+" <arg type='a(ssuuuu)' name='MemoryUsagePerApp' direction='out'/>"
+" </method>"
+" <method name='GetMemoryDB'>"
+" <arg type='i' name='Period' direction='in'/>"
+" <arg type='a(ssuuuu)' name='MemoryUsagePerApp' direction='out'/>"
+" </method>"
+" <method name='GetMemoryforeach'>"
+" <arg type='i' name='Period' direction='in'/>"
+" <arg type='a(ssuuuu)' name='MemoryUsagePerApp' direction='out'/>"
+" </method>"
+" <method name='SaveMemoryData'>"
+" <arg type='i' name='ZeroOnSuccess' direction='out'/>"
+" </method>";
+
static struct d_bus_method dbus_methods[] = {
- { "GetMemoryLatest", "s", "uu", dbus_get_memory_latest },
- { "GetMemoryData", "si", "uuuu", dbus_get_memory_data },
- { "GetMemoryDataList", "i", "a(ssuuuu)", dbus_get_memory_data_list },
- { "GetMemoryDB", "i", "a(ssuuuu)", dbus_get_memorydb },
- { "GetMemoryforeach", "i", "a(ssuuuu)", dbus_get_memoryforeach },
- { "SaveMemoryData", NULL, "i", dbus_memory_save_to_file },
- /* Add methods here */
+ { "GetMemoryLatest", dbus_get_memory_latest },
+ { "GetMemoryData", dbus_get_memory_data },
+ { "GetMemoryDataList", dbus_get_memory_data_list },
+ { "GetMemoryDB", dbus_get_memorydb },
+ { "GetMemoryforeach", dbus_get_memoryforeach },
+ { "SaveMemoryData", dbus_memory_save_to_file },
};
static int heart_memory_init(void *data)
register_notifier(RESOURCED_NOTIFIER_APP_FOREGRD, heart_memory_state_cb);
register_notifier(RESOURCED_NOTIFIER_APP_BACKGRD, heart_memory_state_cb);
- ret = d_bus_register_methods(RESOURCED_PATH_LOGGING, dbus_methods,
- ARRAY_SIZE(dbus_methods));
-
- if (ret != RESOURCED_ERROR_NONE) {
- _E("DBus method registration for %s is failed", RESOURCED_PATH_LOGGING);
- return RESOURCED_ERROR_FAIL;
- }
+ heart_dbus_declare_methods(dbus_methods_xml, dbus_methods, ARRAY_SIZE(dbus_methods));
last_file_update_time = logging_get_time(CLOCK_BOOTTIME);
static pthread_t heart_storage_verifying_thread = 0;
static GQueue *queue = NULL;
-static DBusMessage *dbus_insert_log(DBusMessage *msg)
+static void dbus_insert_log(GDBusMethodInvocation *invocation, GVariant *params)
{
int ret;
int pid;
char *pkgid = NULL;
char *data = NULL;
- DBusMessage *reply;
- ret = dbus_message_get_args(msg, NULL,
- DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_STRING, &pkgid,
- DBUS_TYPE_STRING, &data,
- DBUS_TYPE_INVALID);
- if (!ret) {
+
+ g_variant_get(params, "(uss)", &pid, &pkgid, &data);
+ if (pid == 0 || !pkgid) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
_SD("Insert record (%s, %s)", pkgid, data);
if (ret != RESOURCED_ERROR_NONE)
_E("Write request failed");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
}
void heart_storage_delete_cb(struct logging_table_form *table, void *user_data)
pthread_mutex_unlock(&heart_storage_verifying_mutex);
}
-static DBusMessage *dbus_verify_log(DBusMessage *msg)
+static void dbus_verify_log(GDBusMethodInvocation *invocation, GVariant *params)
{
- int ret;
char *pkgid = NULL;
- DBusMessage *reply = NULL;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pkgid, DBUS_TYPE_INVALID);
- reply = dbus_message_new_method_return(msg);
- if (!ret || !pkgid) {
+
+ g_variant_get(params, "(s)", &pkgid);
+ if (!pkgid) {
_E("Wrong message arguments!");
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
/* flush module cache */
logging_save_to_storage(true);
heart_storage_verifying_thread_create(pkgid);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
}
+static const char dbus_methods_xml[] =
+" <method name='Insert'>"
+" <arg type='u' name='Pid' direction='in'/>"
+" <arg type='s' name='Pkgid' direction='in'/>"
+" <arg type='s' name='UserData' direction='in'/>"
+" </method>"
+" <method name='Verify'>"
+" <arg type='s' name='Pkgid' direction='in'/>"
+" </method>";
+
static struct d_bus_method dbus_methods[] = {
- { "Insert", "ss", NULL, dbus_insert_log },
- { "Verify", "s", NULL, dbus_verify_log }
+ { "Insert", dbus_insert_log },
+ { "Verify", dbus_verify_log },
};
static bool is_storage_logging(void)
return RESOURCED_ERROR_FAIL;
}
- ret = d_bus_register_methods(RESOURCED_PATH_LOGGING, dbus_methods, ARRAY_SIZE(dbus_methods));
- if (ret != RESOURCED_ERROR_NONE)
- _E("DBus method registration for %s is failed", RESOURCED_PATH_LOGGING);
+ heart_dbus_declare_methods(dbus_methods_xml, dbus_methods, ARRAY_SIZE(dbus_methods));
register_notifier(RESOURCED_NOTIFIER_LOGGING_WRITE, heart_storage_write);
return RESOURCED_ERROR_NONE;
}
static const struct heart_module_ops heart_storage_ops = {
- .name = "STORAGE",
- .init = heart_storage_init,
- .exit = heart_storage_exit,
+ .name = "STORAGE",
+ .init = heart_storage_init,
+ .exit = heart_storage_exit,
};
HEART_MODULE_REGISTER(&heart_storage_ops)
heart_module = g_slist_remove(heart_module, (gpointer)ops);
}
-static const struct heart_module_ops *heart_module_find(const char *name)
+const struct heart_module_ops *heart_module_find(const char *name)
{
GSList *iter;
struct heart_module_ops *module;
return RESOURCED_ERROR_NONE;
}
-static DBusMessage *dbus_update_data_list(DBusMessage *msg)
-{
- int ret;
- DBusMessage *reply = NULL;
-
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INVALID);
- reply = dbus_message_new_method_return(msg);
- if (!ret) {
- _E("Wrong message arguments!");
- return reply;
- }
-
- resourced_notify(RESOURCED_NOTIFIER_DATA_UPDATE, NULL);
-
- logging_save_to_storage(true);
- /* update data list from db */
- logging_update(true);
-
- return reply;
-}
-
-static DBusMessage *dbus_flush_cache(DBusMessage *msg)
-{
- int ret;
- DBusMessage *reply = NULL;
-
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INVALID);
- reply = dbus_message_new_method_return(msg);
- if (!ret) {
- _E("Wrong message arguments!");
- return reply;
- }
- /* flush module cache */
- logging_save_to_storage(true);
-
- return reply;
-}
-
-static struct d_bus_method dbus_methods[] = {
- { "UpdateDataList", NULL, NULL, dbus_update_data_list },
- { "Flush", NULL, NULL, dbus_flush_cache }
-};
-
static int resourced_heart_init(void *data)
{
- int ret, module_num = 0;
+ int module_num = 0;
config_parse(HEART_CONF_FILE_PATH, heart_load_config, &module_num);
return RESOURCED_ERROR_NONE;
}
- ret = d_bus_register_methods(RESOURCED_PATH_LOGGING, dbus_methods, ARRAY_SIZE(dbus_methods));
- if (ret != RESOURCED_ERROR_NONE)
- _E("DBus method registration for %s is failed", RESOURCED_PATH_LOGGING);
-
heart_module_init(data);
+ heart_dbus_init();
+
return RESOURCED_ERROR_NONE;
}
#include <stdio.h>
#include <time.h>
+#include "dbus-handler.h"
+
#define HEART_CONF_FILE_PATH RD_CONFIG_FILE(heart)
#define HEART_FILE_PATH RD_SYS_DATA"/heart"
#define HEART_USER_FILE_PATH "%s/data/heart"
void heart_module_add(const struct heart_module_ops *mod);
void heart_module_remove(const struct heart_module_ops *mod);
+const struct heart_module_ops *heart_module_find(const char *name);
+
+void heart_dbus_declare_methods(const char *xml, const struct d_bus_method *methods,
+ const size_t size);
+int heart_dbus_init(void);
#endif /*__HEART_H__*/
int logging_modify_appid(char *module_name, char *old_appid, char *new_appid, int pid);
void logging_update(int force);
void logging_save_to_storage(int force);
-int logging_sync(DBusMessage *reply);
+int logging_sync(GDBusMessage *reply);
int logging_leveldb_put(char *key, unsigned int key_len, char *value, unsigned int value_len);
int logging_leveldb_putv(char *key, unsigned int key_len, const char *fmt, ...);
int logging_leveldb_read(char *key, unsigned int key_len, char *value, unsigned int value_len);
static struct logging_object *logging_instance = NULL;
static fd_handler_h sync_fd;
-static DBusMessage *sync_reply;
+static GDBusMessage *sync_reply;
static int sync_pipes[2] = {-1, -1};
time_t logging_get_time(int clk_id)
static bool logging_sync_reply(int pipe_fd, void *arg)
{
int ret = -1;
- DBusMessageIter iter;
if (read(pipe_fd, &ret, sizeof(ret)) != sizeof(ret)) {
_E("Failed to read the return value of sync thread");
ret = -1;
}
- dbus_message_iter_init_append(sync_reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
+ g_dbus_message_set_body(sync_reply, g_variant_new("(i)", ret));
if (d_bus_reply_message(sync_reply) != RESOURCED_ERROR_NONE)
_E("Failed to reply sync request");
- dbus_message_unref(sync_reply);
-
return true;
}
pthread_exit(NULL);
}
-int logging_sync(DBusMessage *reply)
+int logging_sync(GDBusMessage *reply)
{
if (sync_pipes[1] < 0) {
_E("Pipe for sync function is not ready");
#include "procfs.h"
#include "util.h"
-static void lowmem_dbus_oom_set_threshold(void *data, DBusMessage *msg)
+static void lowmem_dbus_oom_set_threshold(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- int ret;
- int level, thres;
+ int level = -1, thres = -1;
- ret = dbus_message_is_signal(msg, RESOURCED_INTERFACE_OOM,
- SIGNAL_OOM_SET_THRESHOLD);
-
- if (ret == 0) {
- _D("there is no oom set threshold signal");
- return;
- }
-
- ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &level,
- DBUS_TYPE_INT32, &thres, DBUS_TYPE_INVALID);
-
- if (ret == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(ii)", &level, &thres);
+ if (level < 0 || thres < 0) {
+ _D("Invalid parameter");
return;
}
lowmem_memcg_set_threshold(MEMCG_MEMORY, level, thres);
}
-static void lowmem_dbus_oom_set_leave_threshold(void *data, DBusMessage *msg)
+static void lowmem_dbus_oom_set_leave_threshold(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- int ret;
- int thres;
+ int thres = -1;
- ret = dbus_message_is_signal(msg, RESOURCED_INTERFACE_OOM,
- SIGNAL_OOM_SET_LEAVE_THRESHOLD);
-
- if (ret == 0) {
- _D("there is no oom set leave threshold signal");
+ g_variant_get(params, "(i)", &thres);
+ if (thres < 0) {
+ _D("Invalid parameter");
return;
}
- ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &thres,
- DBUS_TYPE_INVALID);
-
- if (ret == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
- }
-
lowmem_memcg_set_leave_threshold(MEMCG_MEMORY, thres);
}
-static void lowmem_dbus_oom_trigger(void *data, DBusMessage *msg)
+static void lowmem_dbus_oom_trigger(GVariant *params)
{
- int ret;
-
- ret = dbus_message_is_signal(msg, RESOURCED_INTERFACE_OOM,
- SIGNAL_OOM_TRIGGER);
- if (ret == 0) {
- _D("there is no oom trigger signal");
- return;
- }
-
lowmem_change_memory_state(LOWMEM_LOW, 1);
lowmem_trigger_reclaim(OOM_FORCE | OOM_NOMEMORY_CHECK);
lowmem_change_memory_state(LOWMEM_NORMAL, 0);
}
-static void lowmem_dbus_set_perceptible(void *data, DBusMessage *msg)
+static void lowmem_dbus_set_perceptible(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- int ret;
- pid_t pid;
-
- ret = dbus_message_is_signal(msg, RESOURCED_INTERFACE_OOM,
- SIGNAL_OOM_SET_PERCEPTIBLE);
- if (ret == 0) {
- _D("there is no set perceptible signal");
- return;
- }
+ pid_t pid = 0;
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(u)", &pid);
+ if (pid == 0) {
+ _D("Invalid paramter");
return;
}
+
proc_set_oom_score_adj(pid, OOMADJ_BACKGRD_PERCEPTIBLE);
}
-static void lowmem_dbus_set_platform(void *data, DBusMessage *msg)
+static void lowmem_dbus_set_platform(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- int ret;
- pid_t pid;
-
- ret = dbus_message_is_signal(msg, RESOURCED_INTERFACE_OOM,
- SIGNAL_OOM_SET_PLATFORM);
- if (ret == 0) {
- _D("there is no set platform swap signal");
- return;
- }
+ pid_t pid = 0;
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(u)", &pid);
+ if (pid == 0) {
+ _D("Invalid parameter");
return;
}
lowmem_trigger_swap(pid, MEMCG_SWAP);
static int lowmem_launch_oompopup(void)
{
- return launch_system_app_by_dbus(SYSTEM_POPUP_BUS_NAME,
+ char *args[2] = { "_SYSPOPUP_CONTENT_", "lowmemory_oom" };
+ return d_bus_call_method_sync(SYSTEM_POPUP_BUS_NAME,
SYSTEM_POPUP_PATH_SYSTEM, SYSTEM_POPUP_IFACE_SYSTEM,
- "PopupLaunch", 2, "_SYSPOPUP_CONTENT_", "lowmemory_oom");
+ "PopupLaunch", "ss", args);
}
static inline void get_total_memory(void)
#include <resourced.h>
#include <pthread.h>
#include <time.h>
-#include <dbus/dbus.h>
+#include <gio/gio.h>
#define INVALID_PROCESS_INFO_FIELD_VALUE -1
char task_name[TASK_NAME_SIZE]; /**< The name assigned to task */
int *pid_list; /**< Pointer to the process id array in the dbus message */
void *usage_info_list; /**< Pointer to the memory containing the usage info results */
- DBusMessage *task_msg; /**< Pointer to the dbus message sent by runtime-info. */
+ GDBusMethodInvocation *task_invocation; /**< Pointer to the invocation sent by runtime-info. */
};
void proc_get_memory_usage(int pid, struct process_memory_info_s *mem_info);
--- /dev/null
+/*
+ * resourced
+ *
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/**
+ * @file proc-usgae-stats.h
+ * @desc Handles the dbus method calls made by the runtime-info APIs
+ **/
+
+#ifndef __PROC_USAGE_STATS_H__
+#define __PROC_USAGE_STATS_H__
+
+#include <gio/gio.h>
+
+/**
+ * @brief DBus method to return the memory usage information of input processes
+ * @since_tizen 2.4
+ *
+ * @param[in] invocation The dbus invocation
+ * @param[in] params Parameters sent by the runtime info API
+ * This should be an array of process IDs.
+ *
+ * @retval The response dbus contains an array of structs
+ * (structure similar to process_memory_info_s). The structs contain the
+ * memory usage info fields for the processes (in the same order).
+ * For invalid process IDs, the fields of the process_memory_info_s struct
+ * will be set to INVALID_PROCESS_INFO_FIELD_VALUE.
+ * If the input dbus message does not contain array of integers or if there
+ * are errors in computation, collection and sending of usage info, then the
+ * response dbus message contains only an integer whose value will the error value.
+ */
+void dbus_proc_memory_usage(GDBusMethodInvocation *invocation, GVariant *params);
+
+/**
+ * @brief DBus method to return the cpu usage information of input processes
+ * @since_tizen 2.4
+ *
+ * @param[in] invocation The dbus invocation
+ * @param[in] params Parameters sent by the runtime info API
+ * This should be an array of process IDs.
+ *
+ * @retval The response contains an array of structs
+ * (structure similar to process_cpu_usage_s). The structs contain the
+ * cpu usage info fields for the processes (in the same order).
+ * For invalid process IDs, the fields of the process_cpu_usage_s struct
+ * will be set to INVALID_PROCESS_INFO_FIELD_VALUE.
+ * If the input dbus message does not contain array of integers or if there
+ * are errors in computation, collection and sending of usage info, then the
+ * response dbus message contains only an integer whose value will the error value.
+ */
+void dbus_proc_cpu_usage(GDBusMethodInvocation *invocation, GVariant *params);
+
+#endif /* __PROC_USAGE_STATS_H__ */
pa[1] = "1";
pa[2] = buf;
- ret = d_bus_broadcast_signal_str(DEVICED_PATH_PROCESS, DEVICED_INTERFACE_PROCESS,
+ ret = d_bus_broadcast_signal(DEVICED_PATH_PROCESS, DEVICED_INTERFACE_PROCESS,
SIGNAL_NAME_OOMADJ_SET, "sis", pa);
if (ret < 0)
_E("Fail to send dbus signal to deviced!!");
#include "trace.h"
#include "dbus-handler.h"
#include "proc-process.h"
+#include "proc-usage-stats.h"
#include "proc-usage-stats-helper.h"
#include "procfs.h"
#include "lowmem-handler.h"
return proc_watchdog_state;
}
-static DBusMessage *dbus_get_meminfo(DBusMessage *msg)
+static void dbus_get_meminfo(GDBusMethodInvocation *invocation, GVariant *params)
{
unsigned int mem_total, mem_free, mem_available, cached, used;
unsigned int swap_total, swap_free, swap;
- DBusMessageIter iter;
- DBusMessage *reply;
struct meminfo mi;
int r;
- reply = dbus_message_new_method_return(msg);
-
r = proc_get_meminfo(&mi,
MEMINFO_MASK_MEM_TOTAL |
MEMINFO_MASK_MEM_FREE |
MEMINFO_MASK_SWAP_FREE);
if (r < 0) {
_E("Failed to get meminfo: %m");
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
mem_total = mi.value[MEMINFO_ID_MEM_TOTAL];
_D("memory info total = %u, free = %u, cache = %u, used = %u, swap = %u",
mem_total, mem_free, cached, used, swap);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &mem_total);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &mem_free);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &cached);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &used);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &swap);
-
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(uuuuu)",
+ mem_total, mem_free, cached, used, swap));
}
-static DBusMessage *dbus_reclaim_memory(DBusMessage *msg)
+static void dbus_reclaim_memory(GDBusMethodInvocation *invocation, GVariant *params)
{
- DBusMessageIter iter;
- DBusMessage *reply;
int ret = -1;
_D("reclaiming memory!");
ret = proc_sys_node_trigger(SYS_VM_SHRINK_MEMORY);
ret = proc_sys_node_trigger(SYS_VM_COMPACT_MEMORY);
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(i)", ret));
}
-static DBusMessage *dbus_pre_poweroff(DBusMessage *msg)
+static void dbus_pre_poweroff(GDBusMethodInvocation *invocation, GVariant *params)
{
- DBusMessageIter iter;
- DBusMessage *reply;
- int ret = -1;
-
_D("pre power off: unmounting cgroup fs");
proc_sweep_memory(PROC_SWEEP_EXCLUDE_ACTIVE, INIT_PID);
resourced_notify(RESOURCED_NOTIFIER_POWER_OFF, NULL);
umount2("/sys/fs/cgroup", MNT_FORCE|MNT_DETACH);
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(i)", -1));
}
-static void proc_dbus_active_signal_handler(void *data, DBusMessage *msg)
+static void proc_dbus_active_signal_handler(GVariant *params)
{
_cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- int ret, type;
- char *str;
- pid_t pid;
-
- ret = dbus_message_is_signal(msg, RESOURCED_INTERFACE_PROCESS, SIGNAL_PROC_ACTIVE);
- if (ret == 0) {
- _D("there is no active signal");
- return;
- }
+ int type;
+ char *str = NULL;
+ pid_t pid = 0;
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &str, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(si)", &str, &pid);
+ if (!str || pid == 0) {
+ _D("there is no message");
return;
}
resourced_proc_status_change(type, pid, NULL, NULL, PROC_TYPE_NONE);
}
-static DBusMessage *dbus_get_app_cpu(DBusMessage *msg)
+static void dbus_get_app_cpu(GDBusMethodInvocation *invocation, GVariant *params)
{
- int ret;
- DBusMessageIter iter;
- DBusMessage *reply;
- char *appid;
+ char *appid = NULL;
unsigned long total, utime, stime, starttime;
struct proc_app_info *pai = NULL;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &appid,
- DBUS_TYPE_INVALID);
- if (!ret) {
+ g_variant_get(params, "(s)", &appid);
+ if (!appid) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
pai = find_app_info_by_appid(appid);
if (!pai) {
_E("There is no appid %s", appid);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
if (proc_get_cpu_time(pai->main_pid, &utime, &stime, &starttime) != RESOURCED_ERROR_NONE) {
_E("proc_get_cpu_time = %s (%d)", appid, pai->main_pid);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
_D("cpu usage of %s (%d), utime = %u, stime = %u", appid, pai->main_pid, utime, stime);
total = utime + stime;
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &total);
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(u)", total));
}
-static DBusMessage *dbus_get_app_memory(DBusMessage *msg)
+static void dbus_get_app_memory(GDBusMethodInvocation *invocation, GVariant *params)
{
- int ret;
- DBusMessageIter iter;
- DBusMessage *reply;
char *appid;
unsigned int usage = 0;
struct proc_app_info *pai = NULL;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &appid,
- DBUS_TYPE_INVALID);
- if (!ret) {
+ g_variant_get(params, "(s)", &appid);
+ if (!appid) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
pai = find_app_info_by_appid(appid);
if (!pai || !pai->main_pid) {
_E("There is no appid %s", appid);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
if (proc_get_procstat_mem_usage(pai->main_pid, &usage) < 0) {
_E("lowmem_get_proc_mem_usage failed for appid = %s (%d)",
appid, pai->main_pid);
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
_D("memory usage of %s (%d), rss = %u", appid, pai->main_pid, usage);
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &usage);
- return reply;
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(u)", usage));
}
-static DBusMessage *dbus_get_memory_list(DBusMessage *msg)
+static void dbus_get_memory_list(GDBusMethodInvocation *invocation, GVariant *params)
{
_cleanup_app_list_close_ GSList *proc_app_list = PAL_INIT_VALUE;
- DBusMessageIter iter;
- DBusMessageIter arr;
- DBusMessage *reply;
GSList *giter;
char *appid;
struct proc_app_info *pai;
unsigned int usage = 0;
+ GVariantBuilder builder, *sub_builder;
- reply = dbus_message_new_method_return(msg);
- proc_app_list = proc_app_list_open();
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(su)"));
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(su)", &arr);
+ proc_app_list = proc_app_list_open();
gslist_for_each_item(giter, proc_app_list) {
- DBusMessageIter sub;
pai = (struct proc_app_info *)giter->data;
if (!pai || !pai->main_pid)
continue;
continue;
appid = pai->appid;
- dbus_message_iter_open_container(&arr, DBUS_TYPE_STRUCT, NULL, &sub);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &appid);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &usage);
- dbus_message_iter_close_container(&arr, &sub);
+
+ g_variant_builder_add(sub_builder, "(su)", appid, usage);
}
- dbus_message_iter_close_container(&iter, &arr);
- return reply;
+ g_variant_builder_add_value(&builder, g_variant_new("a(su)", sub_builder));
+ g_variant_builder_unref(sub_builder);
+
+ g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
}
-static DBusMessage *dbus_get_cpu_list(DBusMessage *msg)
+static void dbus_get_cpu_list(GDBusMethodInvocation *invocation, GVariant *params)
{
_cleanup_app_list_close_ GSList *proc_app_list = PAL_INIT_VALUE;
- DBusMessageIter iter;
- DBusMessageIter arr;
- DBusMessage *reply;
GSList *giter;
char *appid;
struct proc_app_info *pai;
unsigned long uptime, utime, stime, starttime;
int ret;
-
- reply = dbus_message_new_method_return(msg);
+ GVariantBuilder builder, *sub_builder;
ret = proc_get_uptime(&uptime);
if (ret) {
_E("Failed to get uptime");
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(su)", &arr);
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(su)"));
+
proc_app_list = proc_app_list_open();
gslist_for_each_item(giter, proc_app_list) {
- DBusMessageIter sub;
unsigned long percent;
pai = (struct proc_app_info *)giter->data;
if (!pai->main_pid)
if (proc_get_cpu_time(pai->main_pid, &utime, &stime, &starttime) != RESOURCED_ERROR_NONE)
continue;
appid = pai->appid;
- dbus_message_iter_open_container(&arr, DBUS_TYPE_STRUCT, NULL, &sub);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &appid);
percent = 100 * (((utime + stime) * 1000 / HZ) / (uptime - (starttime / HZ)));
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &percent);
- dbus_message_iter_close_container(&arr, &sub);
+
+ g_variant_builder_add(sub_builder, "(su)", appid, percent);
}
- dbus_message_iter_close_container(&iter, &arr);
- return reply;
+ g_variant_builder_add_value(&builder, g_variant_new("a(su)", sub_builder));
+ g_variant_builder_unref(sub_builder);
+
+ g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
}
-static DBusMessage *dbus_get_memory_lists(DBusMessage *msg)
+static void dbus_get_memory_lists(GDBusMethodInvocation *invocation, GVariant *params)
{
_cleanup_app_list_close_ GSList *proc_app_list = PAL_INIT_VALUE;
- DBusMessageIter iter;
- DBusMessageIter arr;
- DBusMessage *reply;
GSList *giter;
char *appid;
- int type, ret;
+ int type;
struct proc_app_info *pai;
unsigned int usage = 0;
+ GVariantBuilder builder, *sub_builder;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &type,
- DBUS_TYPE_INVALID);
- if (!ret) {
+ g_variant_get(params, "(i)", &type);
+ if (type < 0 || type >= PROC_TYPE_MAX) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(su)", &arr);
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(su)"));
+
proc_app_list = proc_app_list_open();
gslist_for_each_item(giter, proc_app_list) {
- DBusMessageIter sub;
pai = (struct proc_app_info *)giter->data;
if (!pai || !pai->main_pid)
continue;
continue;
appid = pai->appid;
- dbus_message_iter_open_container(&arr, DBUS_TYPE_STRUCT, NULL, &sub);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &appid);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &usage);
- dbus_message_iter_close_container(&arr, &sub);
+
+ g_variant_builder_add(sub_builder, "(su)", appid, usage);
}
- dbus_message_iter_close_container(&iter, &arr);
- return reply;
+ g_variant_builder_add_value(&builder, g_variant_new("a(su)", sub_builder));
+ g_variant_builder_unref(sub_builder);
+
+ g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
}
-static DBusMessage *dbus_get_cpu_lists(DBusMessage *msg)
+static void dbus_get_cpu_lists(GDBusMethodInvocation *invocation, GVariant *params)
{
_cleanup_app_list_close_ GSList *proc_app_list = PAL_INIT_VALUE;
- DBusMessageIter iter;
- DBusMessageIter arr;
- DBusMessage *reply;
GSList *giter;
int ret, type;
char *appid;
struct proc_app_info *pai;
unsigned long uptime, utime, stime, starttime;
+ GVariantBuilder builder, *sub_builder;
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &type,
- DBUS_TYPE_INVALID);
- if (!ret) {
+ g_variant_get(params, "(i)", &type);
+ if (type < 0 || type >= PROC_TYPE_MAX) {
_E("Wrong message arguments!");
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- reply = dbus_message_new_method_return(msg);
-
ret = proc_get_uptime(&uptime);
if (ret) {
_E("Failed to get uptime");
- return reply;
+ D_BUS_REPLY_NULL(invocation);
+ return;
}
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(su)", &arr);
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(su)"));
+
proc_app_list = proc_app_list_open();
gslist_for_each_item(giter, proc_app_list) {
- DBusMessageIter sub;
unsigned long percent;
pai = (struct proc_app_info *)giter->data;
if (!pai->main_pid)
if (proc_get_cpu_time(pai->main_pid, &utime, &stime, &starttime) != RESOURCED_ERROR_NONE)
continue;
appid = pai->appid;
- dbus_message_iter_open_container(&arr, DBUS_TYPE_STRUCT, NULL, &sub);
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &appid);
percent = (((utime + stime)*100 /HZ) / (uptime - (starttime/HZ)));
- dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &percent);
- dbus_message_iter_close_container(&arr, &sub);
+
+ g_variant_builder_add(sub_builder, "(su)", appid, percent);
}
- dbus_message_iter_close_container(&iter, &arr);
- return reply;
+ g_variant_builder_add_value(&builder, g_variant_new("a(su)", sub_builder));
+ g_variant_builder_unref(sub_builder);
+
+ g_dbus_method_invocation_return_value(invocation, g_variant_builder_end(&builder));
}
-static void proc_dbus_exclude_signal_handler(void *data, DBusMessage *msg)
+static void proc_dbus_exclude_signal_handler(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- int ret;
- char *str;
- pid_t pid;
+ char *str = NULL;
+ pid_t pid = 0;
struct proc_exclude pe;
int len;
- ret = dbus_message_is_signal(msg, RESOURCED_INTERFACE_PROCESS, SIGNAL_PROC_EXCLUDE);
- if (ret == 0) {
- _D("there is no active signal");
- return;
- }
-
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &str, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(si)", &str, &pid);
+ if (!str || !pid == 0) {
+ _D("there is no message");
return;
}
-
/*
* allowed strings: wakeup, exclude, include
*/
return;
}
-static void proc_dbus_exclude_appid_signal_handler(void *data, DBusMessage *msg)
+static void proc_dbus_exclude_appid_signal_handler(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- int ret;
- char *str;
- char *appid;
+ char *str = NULL;
+ char *appid = NULL;
struct proc_exclude pe;
int len;
struct proc_status ps = {0};
- ret = dbus_message_is_signal(msg, RESOURCED_INTERFACE_PROCESS,
- SIGNAL_PROC_EXCLUDEAPPID);
- if (ret == 0) {
- _D("there is no active signal");
- return;
- }
-
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &str,
- DBUS_TYPE_STRING, &appid, DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(ss)", &str, &appid);
+ if (!str || !appid) {
+ _D("there is no message");
return;
}
- if (!appid)
- return;
-
ps.pai = find_app_info_by_appid(appid);
if (!ps.pai) {
_E("no entry of %s in app list", appid);
}
-static void proc_dbus_prelaunch_signal_handler(void *data, DBusMessage *msg)
+static void proc_dbus_prelaunch_signal_handler(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- int ret;
- char *appid;
- char *pkgid;
- int flags, categories;
+ char *appid = NULL;
+ char *pkgid = NULL;
+ int flags = -1;
+ int categories = -1;
struct proc_status ps;
struct proc_app_info *pai;
- ret = dbus_message_is_signal(msg, RESOURCED_INTERFACE_PROCESS,
- SIGNAL_PROC_PRELAUNCH);
- if (ret == 0) {
- _D("there is no prelaunch signal");
- return;
- }
-
- if (dbus_message_get_args(msg, &err,
- DBUS_TYPE_STRING, &appid,
- DBUS_TYPE_STRING, &pkgid,
- DBUS_TYPE_INT32, &flags,
- DBUS_TYPE_INT32, &categories, DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(ssii)", &appid, &pkgid, &flags, &categories);
+ if (!appid || !pkgid || flags < 0 || categories < 0) {
+ _D("there is no message");
return;
}
resourced_notify(RESOURCED_NOTIFIER_APP_PRELAUNCH, &ps);
}
-static void proc_dbus_sweep_signal_handler(void *data, DBusMessage *msg)
+static void proc_dbus_sweep_signal_handler(GVariant *params)
{
- int ret;
-
- ret = dbus_message_is_signal(msg, RESOURCED_INTERFACE_PROCESS,
- SIGNAL_PROC_SWEEP);
-
- if (ret == 0) {
- _D("there is no sweep signal");
- return;
- }
-
proc_sweep_memory(PROC_SWEEP_INCLUDE_ACTIVE, INIT_PID);
}
return false;
}
-static void proc_dbus_watchdog_result(void *data, DBusMessage *msg)
+static void proc_dbus_watchdog_result(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- int type;
+ int type = -1;
- if (dbus_message_is_signal(msg, RESOURCED_INTERFACE_PROCESS, SIGNAL_PROC_WATCHDOG_RESULT) == 0) {
- _D("there is no watchdog result signal");
- return;
- }
-
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &type, DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(i)", &type);
+ if (type < 0) {
+ _D("there is no message");
return;
}
static int proc_dbus_show_popup(const char *value)
{
- char str_val[32];
int i, ret_val = 0;
+ char *args[4] = { WATCHDOG_KEY1, WATCHDOG_VALUE_1, WATCHDOG_KEY2 };
- snprintf(str_val, sizeof(str_val), "%s", value);
+ args[3] = strndup(value, strlen(value));
i = 0;
do {
- ret_val = launch_system_app_by_dbus(SYSTEM_POPUP_BUS_NAME, SYSTEM_POPUP_PATH_SYSTEM,
- SYSTEM_POPUP_IFACE_SYSTEM, WATCHDOG_LAUNCHING_PARAM, 4,
- WATCHDOG_KEY1, WATCHDOG_VALUE_1, WATCHDOG_KEY2, str_val);
+ ret_val = d_bus_call_method_sync(SYSTEM_POPUP_BUS_NAME, SYSTEM_POPUP_PATH_SYSTEM,
+ SYSTEM_POPUP_IFACE_SYSTEM, WATCHDOG_LAUNCHING_PARAM, "ssss", args);
if (!ret_val)
break;
_E("Re-try to sync DBUS message, err_count : %d", i);
- } while (i++ < RETRY_MAX);
+ } while (i++ < 5);
+
+ free(args[3]);
return ret_val;
}
-static void proc_dbus_watchdog_handler(void *data, DBusMessage *msg)
+static void proc_dbus_watchdog_handler(GVariant *params)
{
- int pid, command, ret;
+ int ret;
+ int pid = -1;
+ int command = -1;
char appname[PROC_NAME_MAX];
struct proc_status ps;
- if (dbus_message_is_signal(msg, RESOURCED_INTERFACE_PROCESS, SIGNAL_PROC_WATCHDOG) == 0) {
- _D("there is no watchdog result signal");
- return;
- }
-
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32,
- &command, DBUS_TYPE_INVALID);
-
- if (ret == 0) {
+ g_variant_get(params, "(ii)", &pid, &command);
+ if (pid < 0 || command < 0) {
_D("there is no message");
return;
}
static void send_dump_signal(char *signal)
{
+ char *arg[1];
pid_t pid = getpid();
+ arg[0] = (char *)malloc(sizeof(pid_t));
+ snprintf(arg[0], sizeof(pid_t), "%u", pid);
d_bus_broadcast_signal(DUMP_SERVICE_OBJECT_PATH,
- DUMP_SERVICE_INTERFACE_NAME, signal, DBUS_TYPE_INT32, &pid);
+ DUMP_SERVICE_INTERFACE_NAME, signal, "i", arg);
+
+ free(arg[0]);
}
-static void proc_dbus_dump_handler(void *data, DBusMessage *msg)
+static void proc_dbus_dump_handler(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- dbus_bool_t ret;
- char *path;
- int mode;
+ char *path = NULL;
+ int mode = -1;
- if (dbus_message_is_signal(msg, DUMP_SERVICE_INTERFACE_NAME, SIGNAL_DUMP) == 0) {
- _D("there is no process group signal");
+ g_variant_get(params, "(is)", &mode, &path);
+ if (mode < 0 || !path) {
+ _D("there is no message");
return;
}
- ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &mode,
- DBUS_TYPE_STRING, &path, DBUS_TYPE_INVALID);
- if (ret == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
- return;
- }
_D("received dump request: path %s", path);
send_dump_signal(SIGNAL_DUMP_START);
resourced_proc_dump(mode, path);
send_dump_signal(SIGNAL_DUMP_FINISH);
}
-static void proc_dbus_systemservice_handler(void *data, DBusMessage *msg)
+static void proc_dbus_systemservice_handler(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- dbus_bool_t ret;
- pid_t pid;
+ pid_t pid = 0;
- if (dbus_message_is_signal(msg, RESOURCED_INTERFACE_PROCESS, SIGNAL_PROC_SYSTEMSERVICE) == 0) {
- _D("there is no process group signal");
+ g_variant_get(params, "(i)", &pid);
+ if (pid == 0) {
+ _D("there is no message");
return;
}
- ret = dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID);
- if (ret == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
- return;
- }
resourced_proc_status_change(PROC_CGROUP_SET_SYSTEM_SERVICE, pid,
NULL, NULL, PROC_TYPE_NONE);
}
-static DBusMessage *dbus_signal_trigger(DBusMessage *msg)
+static void dbus_signal_trigger(GDBusMethodInvocation *invocation, GVariant *params)
{
- DBusMessage *reply;
- dbus_bool_t ret;
- int pid, command, ret_val;
+ int pid = 0, command = 0, ret_val;
char appname[PROC_NAME_MAX];
- ret = dbus_message_get_args(msg, NULL, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32,
- &command, DBUS_TYPE_INVALID);
+ g_variant_get(params, "(ii)", &pid, &command);
- if (ret == TRUE) {
+ if (pid > 0 && command > 0) {
ret_val = proc_get_cmdline(pid, appname);
if (ret_val != RESOURCED_ERROR_NONE) {
_E("ERROR : invalid pid(%d)", pid);
}
}
}
- } else {
+ } else
_E("ERROR: Wrong message arguments!");
- }
- reply = dbus_message_new_method_return(msg);
- return reply;
+ D_BUS_REPLY_NULL(invocation);
}
-static void proc_dbus_lcd_on(void *data, DBusMessage *msg)
+static void proc_dbus_lcd_on(GVariant *params)
{
- if (dbus_message_is_signal(msg, DEVICED_INTERFACE_DISPLAY,
- SIGNAL_DEVICED_LCDON) == 0) {
- _D("there is no lcd on signal");
- return;
- }
-
current_lcd_state = LCD_STATE_ON;
resourced_notify(RESOURCED_NOTIFIER_LCD_ON, NULL);
/* nothing */
}
-static void proc_dbus_lcd_off(void *data, DBusMessage *msg)
+static void proc_dbus_lcd_off(GVariant *params)
{
- if (dbus_message_is_signal(msg, DEVICED_INTERFACE_DISPLAY,
- SIGNAL_DEVICED_LCDOFF) == 0) {
- _D("there is no lcd on signal");
- return;
- }
-
current_lcd_state = LCD_STATE_OFF;
resourced_notify(RESOURCED_NOTIFIER_LCD_OFF, NULL);
}
-static void booting_done_signal_handler(void *data, DBusMessage *msg)
+static void booting_done_signal_handler(GVariant *params)
{
- if (dbus_message_is_signal(msg, DEVICED_INTERFACE_CORE,
- SIGNAL_DEVICED_BOOTINGDONE) == 0) {
- _D("there is no lcd on signal");
- return;
- }
/*
* initialize all modules again
* If some modules weren't initialized at this time,
resourced_notify(RESOURCED_NOTIFIER_BOOTING_DONE, NULL);
}
-static void early_booting_done_signal_handler(void *data, DBusMessage *msg)
+static void early_booting_done_signal_handler(GVariant *params)
{
- if (dbus_message_is_signal(msg, DEVICED_INTERFACE_CORE,
- SIGNAL_DEVICED_EARLY_BOOTING_DONE) == 0) {
- _D("there is no lcd on signal");
- return;
- }
-
_I("launching remaining modules (booting done)");
modules_init_early(NULL);
}
-static void low_battery_signal_handler(void *data, DBusMessage *msg)
+static void low_battery_signal_handler(GVariant *params)
{
- if (dbus_message_is_signal(msg, DEVICED_INTERFACE_BATTERY,
- SIGNAL_DEVICED_LOW_BATTERY) == 0) {
- _D("there is no low battery signal");
- return;
- }
-
resourced_notify(RESOURCED_NOTIFIER_LOW_BATTERY, NULL);
}
-static void poweroff_signal_handler(void *data, DBusMessage *msg)
+static void poweroff_signal_handler(GVariant *params)
{
- if (dbus_message_is_signal(msg, DEVICED_INTERFACE_POWEROFF,
- SIGNAL_DEVICED_POWEROFF_STATE) == 0) {
- _D("there is no power off signal");
- return;
- }
-
_E("quit mainloop at poweroff");
resourced_quit_mainloop();
}
-static void systemtime_changed_signal_handler(void *data, DBusMessage *msg)
+static void systemtime_changed_signal_handler(GVariant *params)
{
- if (dbus_message_is_signal(msg, DEVICED_INTERFACE_TIME,
- SIGNAL_DEVICED_SYSTEMTIME_CHANGED) == 0) {
- _D("there is no system time changed signal");
- return;
- }
-
resourced_notify(RESOURCED_NOTIFIER_SYSTEMTIME_CHANGED, NULL);
}
-static void proc_dbus_aul_launch(void *data, DBusMessage *msg)
+static void proc_dbus_aul_launch(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- pid_t pid;
+ pid_t pid = 0;
int status, apptype;
- char *appid, *pkgid, *pkgtype;
+ char *appid = NULL;
+ char *pkgid = NULL;
+ char *pkgtype = NULL;
- if (dbus_message_is_signal(msg, AUL_APPSTATUS_INTERFACE_NAME,
- SIGNAL_AMD_LAUNCH) == 0) {
- _D("there is no aul launch signal");
- return;
- }
-
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_STRING, &appid, DBUS_TYPE_STRING, &pkgid,
- DBUS_TYPE_STRING, &pkgtype, DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(isss)", &pid, &appid, &pkgid, &pkgtype);
+ if (pid == 0 || !appid || !pkgid || !pkgtype) {
+ _D("there is no message");
return;
}
resourced_proc_status_change(status, pid, appid, pkgid, apptype);
}
-static void proc_dbus_aul_resume(void *data, DBusMessage *msg)
+static void proc_dbus_aul_resume(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- pid_t pid;
+ pid_t pid = 0;
int status = PROC_CGROUP_SET_RESUME_REQUEST, apptype;
- char *appid, *pkgid, *pkgtype;
+ char *appid = NULL;
+ char *pkgid = NULL;
+ char *pkgtype = NULL;
- if (dbus_message_is_signal(msg, AUL_APPSTATUS_INTERFACE_NAME,
- SIGNAL_AMD_RESUME) == 0) {
- _D("there is no aul resume signal");
- return;
- }
-
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_STRING, &appid, DBUS_TYPE_STRING, &pkgid,
- DBUS_TYPE_STRING, &pkgtype, DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(isss)", &pid, &appid, &pkgid, &pkgtype);
+ if (pid == 0 || !appid || !pkgid || !pkgtype) {
+ _D("there is no message");
return;
}
resourced_proc_status_change(status, pid, appid, pkgid, apptype);
}
-static void proc_dbus_aul_terminate(void *data, DBusMessage *msg)
+static void proc_dbus_aul_terminate(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- pid_t pid;
+ pid_t pid = 0;
int status = PROC_CGROUP_SET_TERMINATE_REQUEST;
- char *appid, *pkgid, *pkgtype;
+ char *appid = NULL;
+ char *pkgid = NULL;
+ char *pkgtype = NULL;
- if (dbus_message_is_signal(msg, AUL_APPSTATUS_INTERFACE_NAME,
- SIGNAL_AMD_TERMINATE) == 0) {
- _D("there is no aul terminate signal");
- return;
- }
-
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_STRING, &appid, DBUS_TYPE_STRING, &pkgid,
- DBUS_TYPE_STRING, &pkgtype, DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(isss)", &pid, &appid, &pkgid, &pkgtype);
+ if (pid == 0 || !appid || !pkgid || !pkgtype) {
+ _D("there is no message");
return;
}
resourced_proc_status_change(status, pid, appid, pkgid, PROC_TYPE_NONE);
}
-static void proc_dbus_aul_changestate(void *data, DBusMessage *msg)
+static void proc_dbus_aul_changestate(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- pid_t pid;
+ pid_t pid = 0;
int status, apptype;
- char *appid, *pkgid, *statstr, *pkgtype;
-
- if (dbus_message_is_signal(msg, AUL_APPSTATUS_INTERFACE_NAME,
- SIGNAL_AMD_STATE) == 0) {
- _D("there is no aul changestate signal");
- return;
- }
+ char *appid = NULL;
+ char *pkgid = NULL;
+ char *statstr = NULL;
+ char *pkgtype = NULL;
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_STRING, &appid, DBUS_TYPE_STRING, &pkgid,
- DBUS_TYPE_STRING, &statstr, DBUS_TYPE_STRING, &pkgtype,
- DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(issss)", &pid, &appid, &pkgid, &statstr, &pkgtype);
+ if (pid == 0 || !appid || !pkgid || !statstr || !pkgtype) {
+ _D("there is no message");
return;
}
resourced_proc_status_change(status, pid, appid, pkgid, apptype);
}
-static void proc_dbus_aul_group(void *data, DBusMessage *msg)
+static void proc_dbus_aul_group(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- pid_t ownerpid, childpid;
- char *appid;
-
- if (dbus_message_is_signal(msg, AUL_APPSTATUS_INTERFACE_NAME,
- SIGNAL_AMD_GROUP) == 0) {
- _D("there is no aul group signal");
- return;
- }
+ pid_t ownerpid = 0;
+ pid_t childpid = 0;
+ char *appid = NULL;
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &ownerpid,
- DBUS_TYPE_INT32, &childpid, DBUS_TYPE_STRING, &appid,
- DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(iis)", &ownerpid, &childpid, &appid);
+ if (ownerpid == 0 || childpid == 0 || !appid) {
+ _D("there is no message");
return;
}
proc_set_group(ownerpid, childpid, appid);
}
-static void proc_dbus_aul_terminated(void *data, DBusMessage *msg)
+static void proc_dbus_aul_terminated(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- pid_t pid;
+ pid_t pid = 0;
int status = PROC_CGROUP_SET_TERMINATED;
- if (dbus_message_is_signal(msg, AUL_APPSTATUS_INTERFACE_NAME,
- SIGNAL_AMD_TERMINATED) == 0) {
- _D("there is no aul terminate signal");
- return;
- }
-
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(i)", &pid);
+ if (pid == 0) {
+ _D("there is no message");
return;
}
resourced_proc_status_change(status, pid, NULL, NULL, PROC_TYPE_NONE);
}
-static void proc_dbus_suspend_hint(void *data, DBusMessage *msg)
+static void proc_dbus_suspend_hint(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- pid_t pid;
+ pid_t pid = 0;
struct proc_app_info *pai = NULL;
struct proc_status ps = {0};
enum proc_state state;
- if (dbus_message_is_signal(msg, AUL_SUSPEND_INTERFACE_NAME,
- SIGNAL_AMD_SUSPNED) == 0) {
- _D("there is no aul terminate signal");
- return;
- }
-
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid,
- DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(i)", &pid);
+ if (pid == 0) {
+ _D("there is no message");
return;
}
}
}
+static const char dbus_methods_xml[] =
+"<node>"
+" <interface name='"RESOURCED_INTERFACE_PROCESS"'>"
+" <method name='Signal'>"
+" <arg type='i' name='Pid' direction='in'/>"
+" <arg type='i' name='Command' direction='in'/>"
+" </method>"
+" <method name='GetAppCpu'>"
+" <arg type='s' name='Appid' direction='in'/>"
+" <arg type='u' name='CpuUsage' direction='out'/>"
+" </method>"
+" <method name='GetCpuList'>"
+" <arg type='a(su)' name='PidWithCpuUsagePercent' direction='out'/>"
+" </method>"
+" <method name='GetCpuLists'>"
+" <arg type='i' name='AppType' direction='in'/>"
+" <arg type='a(su)' name='UsagePercent' direction='out'/>"
+" </method>"
+" <method name='GetAppMemory'>"
+" <arg type='s' name='Appid' direction='in'/>"
+" <arg type='u' name='MemoryUsage' direction='out'/>"
+" </method>"
+" <method name='GetMemoryList'>"
+" <arg type='a(su)' name='PidWithMemoryUsage' direction='out'/>"
+" </method>"
+" <method name='GetMemoryLists'>"
+" <arg type='i' name='AppType' direction='in'/>"
+" <arg type='a(su)' name='PidWithMemoryUsage' direction='out'/>"
+" </method>"
+" <method name='GetMemInfo'>"
+" <arg type='u' name='MemTotal' direction='out'/>"
+" <arg type='u' name='MemFree' direction='out'/>"
+" <arg type='u' name='MemCached' direction='out'/>"
+" <arg type='u' name='MemUsed' direction='out'/>"
+" <arg type='u' name='MemSwap' direction='out'/>"
+" </method>"
+" <method name='ReclaimMemory'>"
+" </method>"
+" <method name='PrePoweroff'>"
+" </method>"
+/* Following functions are defined in proc-usage-stats.c */
+" <method name='ProcMemoryUsage'>"
+" <arg type='ai' name='ProcList' direction='in'/>"
+" </method>"
+" <method name='ProcCpuUsage'>"
+" <arg type='ai' name='ProcList' direction='in'/>"
+" </method>"
+" </interface>"
+"</node>";
+
static struct d_bus_method dbus_methods[] = {
- { "Signal", "ii", NULL, dbus_signal_trigger },
- { "GetAppCpu", "s", "u", dbus_get_app_cpu },
- { "GetCpuList", NULL, "a(su)", dbus_get_cpu_list },
- { "GetCpuLists", "i", "a(su)", dbus_get_cpu_lists },
- { "GetAppMemory", "s", "u", dbus_get_app_memory },
- { "GetMemoryList", NULL, "a(su)", dbus_get_memory_list },
- { "GetMemoryLists", "i", "a(su)", dbus_get_memory_lists },
- { "GetMemInfo", NULL, "uuuuu", dbus_get_meminfo },
- { "ReclaimMemory", NULL, NULL, dbus_reclaim_memory },
- { "PrePoweroff", NULL, NULL, dbus_pre_poweroff },
+ { "Signal", dbus_signal_trigger },
+ { "GetAppCpu", dbus_get_app_cpu },
+ { "GetCpuList", dbus_get_cpu_list },
+ { "GetCpuLists", dbus_get_cpu_lists },
+ { "GetAppMemory", dbus_get_app_memory },
+ { "GetMemoryList", dbus_get_memory_list },
+ { "GetMemoryLists", dbus_get_memory_lists },
+ { "GetMemInfo", dbus_get_meminfo },
+ { "ReclaimMemory", dbus_reclaim_memory },
+ { "PrePoweroff", dbus_pre_poweroff },
+/* Following functions are defined in proc-usage-stats.c */
+ { "ProcMemoryUsage", dbus_proc_memory_usage },
+ { "ProcCpuUsage", dbus_proc_cpu_usage },
/* Add methods here */
};
g_source_set_callback(watchdog_check_timer, check_watchdog_cb, NULL, NULL);
g_source_attach(watchdog_check_timer, NULL);
- return d_bus_register_methods(RESOURCED_PATH_PROCESS, dbus_methods,
- ARRAY_SIZE(dbus_methods));
+ return d_bus_register_methods(RESOURCED_PATH_PROCESS, dbus_methods_xml,
+ dbus_methods, ARRAY_SIZE(dbus_methods));
+ return 0;
}
static int proc_dbus_exit(void *data)
if (rt_task->pipe_fds[1] >= 0)
close(rt_task->pipe_fds[1]);
- dbus_message_unref(rt_task->task_msg);
-
free(rt_task);
}
#include <errno.h>
#include "proc-main.h"
+#include "proc-usage-stats.h"
#include "proc-usage-stats-helper.h"
#include "resourced.h"
#include "macro.h"
#include "util.h"
#include "fd-handler.h"
-/**
- * @brief DBus method to return the memory usage information of input processes
- * @since_tizen 2.4
- *
- * @param[in] msg The dbus message sent by the runtime info API.
- * This should be an array of process IDs.
- *
- * @retval The response dbus message contains an array of structs
- * (structure similar to process_memory_info_s). The structs contain the
- * memory usage info fields for the processes (in the same order).
- * For invalid process IDs, the fields of the process_memory_info_s struct
- * will be set to INVALID_PROCESS_INFO_FIELD_VALUE.
- * If the input dbus message does not contain array of integers or if there
- * are errors in computation, collection and sending of usage info, then the
- * response dbus message contains only an integer whose value will the error value.
- */
-static DBusMessage *dbus_proc_memory_usage(DBusMessage *msg);
-
-/**
- * @brief DBus method to return the cpu usage information of input processes
- * @since_tizen 2.4
- *
- * @param[in] msg The dbus message sent by the runtime info API.
- * This should be an array of process IDs.
- *
- * @retval The response dbus message contains an array of structs
- * (structure similar to process_cpu_usage_s). The structs contain the
- * cpu usage info fields for the processes (in the same order).
- * For invalid process IDs, the fields of the process_cpu_usage_s struct
- * will be set to INVALID_PROCESS_INFO_FIELD_VALUE.
- * If the input dbus message does not contain array of integers or if there
- * are errors in computation, collection and sending of usage info, then the
- * response dbus message contains only an integer whose value will the error value.
- */
-static DBusMessage *dbus_proc_cpu_usage(DBusMessage *msg);
-
-/* dbus_methods to register with libdbus */
-static struct d_bus_method dbus_methods[] = {
- { "ProcMemoryUsage", "ai", NULL, dbus_proc_memory_usage },
- { "ProcCpuUsage", "ai", NULL, dbus_proc_cpu_usage },
-};
-
/* g file handler for the read end of the pipe.
* Receives the error status from the runtime info task thread and collects
* the usage info calculated and sends it in a dbus message or send an error dbus message back
*/
static bool proc_runtime_info_task_cb(int fd, void *data)
{
- int i, j, ret, rsize, struct_size;
+ int i, ret, rsize;
int result[7];
- DBusMessage *reply;
- DBusMessageIter iter, iter_arr, iter_struct;
+ GDBusMessage *reply;
+ GVariantBuilder builder, *sub_builder;
struct runtime_info_task *rt_task;
/* In case of errors in glib file hander, the returned dbus message
goto error;
}
- /* Create a reply message with the needed structure */
- reply = dbus_message_new_method_return(rt_task->task_msg);
- if (!reply) {
- _E("task %s: out of memory to allocate for reply dbus message. not attempting again!!!", rt_task->task_name);
- return false;
- }
- dbus_message_iter_init_append(reply, &iter);
- if (rt_task->task_type == RUNTIME_INFO_TASK_MEMORY) {
- struct_size = 7;
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(iiiiiii)", &iter_arr);
- } else {
- struct_size = 2;
- dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ii)", &iter_arr);
- }
+ g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
+ if (rt_task->task_type == RUNTIME_INFO_TASK_MEMORY)
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(iiiiiii)"));
+ else
+ sub_builder = g_variant_builder_new(G_VARIANT_TYPE("a(ii)"));
+
/* Populate the reply message with the usage info */
for (i = 0; i < rt_task->task_size; ++i) {
- dbus_message_iter_open_container(&iter_arr, DBUS_TYPE_STRUCT, NULL, &iter_struct);
-
/* Write the fields of the usage info struct to an int array
* (this is so that the code of dbus message append could be more elegant) */
ret = proc_read_from_usage_struct(rt_task->usage_info_list, i, result, rt_task->task_type);
goto error;
}
- for (j = 0; j < struct_size; ++j)
- dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_INT32, &result[j]);
-
- dbus_message_iter_close_container(&iter_arr, &iter_struct);
+ if (rt_task->task_type == RUNTIME_INFO_TASK_MEMORY)
+ g_variant_builder_add(sub_builder, "(iiiiiii)", result[0], result[1],
+ result[2], result[3], result[4], result[5], result[6]);
+ else
+ g_variant_builder_add(sub_builder, "(ii)", result[0], result[1]);
}
- dbus_message_iter_close_container(&iter, &iter_arr);
+
+ if (rt_task->task_type == RUNTIME_INFO_TASK_MEMORY)
+ g_variant_builder_add_value(&builder, g_variant_new("a(iiiiiii)", sub_builder));
+ else
+ g_variant_builder_add_value(&builder, g_variant_new("a(ii)", sub_builder));
+ g_variant_builder_unref(sub_builder);
+
goto send_message;
error:
return false;
_D("task %s: error occured in collection of usage info, sending error message", rt_task->task_name);
-
- ret = -EREMOTEIO;
- reply = dbus_message_new_method_return(rt_task->task_msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
+ g_variant_builder_add_value(&builder, g_variant_new("(i)", -EREMOTEIO));
send_message:
- /* Send the reply message back to the caller. Best effort feature. */
+ reply = g_dbus_message_new_method_reply(g_dbus_method_invocation_get_message(rt_task->task_invocation));
+ if (!reply) {
+ _E("task %s: out of memory to allocate for reply gdbus message. not attempting again!!!", rt_task->task_name);
+ return false;
+ }
_D("task %s: sending reply dbus message", rt_task->task_name);
+ g_dbus_message_set_body(reply, g_variant_builder_end(&builder));
ret = d_bus_reply_message(reply);
if (ret != RESOURCED_ERROR_NONE)
_E("task %s: sending message failed. not attempting again!!!", rt_task->task_name);
+ g_object_unref(reply);
proc_free_runtime_info_task(rt_task);
- dbus_message_unref(reply);
return false;
}
return NULL;
}
-DBusMessage *proc_runtime_info_request_handler(DBusMessage *msg, runtime_info_task_type type)
+void proc_runtime_info_request_handler(GDBusMethodInvocation *invocation,
+ GVariant *params, runtime_info_task_type type)
{
int ret;
pthread_t task_thread;
struct runtime_info_task *rt_task;
- DBusMessage *reply;
- DBusMessageIter iter;
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
- dbus_bool_t bret;
static fd_handler_h fd_handler;
+ GVariantIter *iter = NULL;
+ int tmp;
+ int i = 0;
rt_task = NULL;
- dbus_message_iter_init(msg, &iter);
- if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
- dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_INT32) {
- _E("wrong message arguments. expected array of integers");
- ret = -EIO;
- goto error;
- }
-
/* Create runtime_info_task for current task */
rt_task = (struct runtime_info_task *)calloc(1, (sizeof(struct runtime_info_task)));
if (!rt_task) {
proc_get_task_name(rt_task->task_name, sizeof(rt_task->task_name),
type);
rt_task->task_type = type;
- dbus_message_ref(msg);
- rt_task->task_msg = msg;
+ rt_task->task_invocation = invocation;
_D("Received %s usage request, task name is %s",
(rt_task->task_type == RUNTIME_INFO_TASK_MEMORY) ? "memory" : "cpu",
rt_task->task_name);
- bret = dbus_message_get_args(rt_task->task_msg, &err, DBUS_TYPE_ARRAY, DBUS_TYPE_INT32,
- &rt_task->pid_list, &rt_task->task_size, DBUS_TYPE_INVALID);
- if (!bret) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
- _E("task %s: not able to extract list of process IDs from the dbus message", rt_task->task_name);
- ret = -EIO;
- goto error;
- }
+ /* Parse arguments to the pids and count it */
+ g_variant_get(params, "(ai)", &iter);
+ rt_task->task_size = g_variant_iter_n_children(iter);
+ rt_task->pid_list = (int *)malloc(rt_task->task_size * sizeof(int));
+ while (g_variant_iter_loop(iter, "i", &tmp))
+ rt_task->pid_list[i++] = tmp;
if (rt_task->task_type == RUNTIME_INFO_TASK_MEMORY)
rt_task->usage_info_list = (void *)malloc(sizeof(struct process_memory_info_s) * rt_task->task_size);
} else
pthread_detach(task_thread);
_D("task %s: created thread for task", rt_task->task_name);
- return NULL;
+ return;
error:
/* In case of error, return only a failure value in the reply dbus message */
if (rt_task)
_D("task %s: error occured, sending error reply message", rt_task->task_name);
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret);
+
+ D_BUS_REPLY_NULL(invocation);
proc_free_runtime_info_task(rt_task);
- return reply;
}
-static DBusMessage *dbus_proc_memory_usage(DBusMessage *msg)
+void dbus_proc_memory_usage(GDBusMethodInvocation *invocation, GVariant *params)
{
- return proc_runtime_info_request_handler(msg, RUNTIME_INFO_TASK_MEMORY);
+ proc_runtime_info_request_handler(invocation, params, RUNTIME_INFO_TASK_MEMORY);
}
-static DBusMessage *dbus_proc_cpu_usage(DBusMessage *msg)
+void dbus_proc_cpu_usage(GDBusMethodInvocation *invocation, GVariant *params)
{
- return proc_runtime_info_request_handler(msg, RUNTIME_INFO_TASK_CPU);
+ proc_runtime_info_request_handler(invocation, params, RUNTIME_INFO_TASK_CPU);
}
+/*
+ * These D-Bus methods are registered at proc-monitor.c
+ * because gdbus allows to register object
+ * having same path and interface only one time.
+ */
+
static int proc_usage_stats_init(void *data)
{
- d_bus_register_methods(RESOURCED_PATH_PROCESS, dbus_methods, ARRAY_SIZE(dbus_methods));
return RESOURCED_ERROR_NONE;
}
return ret;
}
-static void swap_start_pid_dbus_signal_handler(void *data, DBusMessage *msg)
+static void swap_start_pid_dbus_signal_handler(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
int ret;
pid_t pid;
struct memcg *memcg_swap;
struct swap_status_msg ss_msg;
- ret = dbus_message_is_signal(msg, RESOURCED_INTERFACE_SWAP, SIGNAL_NAME_SWAP_START_PID);
- if (ret == 0) {
- _D("there is no swap type signal");
- return;
- }
-
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(i)", &pid);
+ if (pid <= 0) {
+ _D("Invalid parameter");
return;
}
_I("swap cgroup entered : pid : %d", (int)pid);
}
-static void swap_type_dbus_signal_handler(void *data, DBusMessage *msg)
+static void swap_type_dbus_signal_handler(GVariant *params)
{
- _cleanup_dbus_error_free_ DBusError err = DBUS_ERROR_INIT;
enum swap_state state;
- if (dbus_message_is_signal(msg, RESOURCED_INTERFACE_SWAP, SIGNAL_NAME_SWAP_TYPE) == 0) {
- _D("there is no swap state signal");
- return;
- }
-
- if (dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID) == 0) {
- if (dbus_error_is_set(&err))
- _D("there is no message: %s %s", err.name, err.message);
- else
- _D("there is no message");
+ g_variant_get(params, "(i)", &state);
+ if (state <= SWAP_ARG_START || state >= SWAP_ARG_END) {
+ _D("Invalid parameter");
return;
}
swap_change_state(state);
}
-static DBusMessage *dbus_getswaptype(DBusMessage *msg)
+static void dbus_getswaptype(GDBusMethodInvocation *invocation, GVariant *params)
{
- DBusMessageIter iter;
- DBusMessage *reply;
- enum swap_state state;
-
- state = swap_get_state();
-
- reply = dbus_message_new_method_return(msg);
- dbus_message_iter_init_append(reply, &iter);
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &state);
-
- return reply;
+ g_dbus_method_invocation_return_value(invocation,
+ g_variant_new("(i)", swap_get_state()));
}
+static const char dbus_methods_xml[] =
+"<node>"
+" <interface name='"RESOURCED_INTERFACE_SWAP"'>"
+" <method name='GetSwapType'>"
+" <arg type='i' name='SwapState' direction='out'/>"
+" </method>"
+" </interface>"
+"</node>";
+
static struct d_bus_method dbus_methods[] = {
- { "GetSwapType", NULL, "i", dbus_getswaptype },
+ { "GetSwapType", dbus_getswaptype },
/* Add methods here */
};
d_bus_register_signals(dbus_signals, ARRAY_SIZE(dbus_signals));
- ret = d_bus_register_methods(RESOURCED_PATH_SWAP, dbus_methods,
- ARRAY_SIZE(dbus_methods));
+ ret = d_bus_register_methods(RESOURCED_PATH_SWAP, dbus_methods_xml,
+ dbus_methods, ARRAY_SIZE(dbus_methods));
ret_msg_if(ret != RESOURCED_ERROR_NONE,
"DBus method registration for %s is failed",
projects / platform / core / system / resourced.git / commitdiff