[Non-ACR] improve lock/unlock & get-app_id logic

Change-Id: Ifc7220f86cb76b1aa1eb7a98b95233f7e107d293
Signed-off-by: Abhishek Vijay <abhishek.v@samsung.com>

diff --git a/include/bm_util.h b/include/bm_util.h
index 3349270f9e53a4e42b64e2e33ca01aa228b7d080..dd88ea64a2d404462f9e07fffbc08ea60972735c 100644 (file)
--- a/include/bm_util.h
+++ b/include/bm_util.h
@@ -61,7 +61,7 @@ GDBusConnection* bm_get_dbus_connection_obj(void);
 
 void bd_get_focussed_app_id(char **app_name);
 
-void bm_get_name_for_pid(pid_t pid, char **pname);
+void bm_get_symlink_for_pid(pid_t pid, char **pname);
 
 void bm_data_free(gpointer data);
 

diff --git a/src/battery_dump/bm_listeners.c b/src/battery_dump/bm_listeners.c
index 5f4632d047f4c2a7bcfe1d83cf90da2d2c86cf62..480d58d40b60ae00bfbf81c197c76a0319de9331 100644 (file)
--- a/src/battery_dump/bm_listeners.c
+++ b/src/battery_dump/bm_listeners.c
@@ -51,6 +51,7 @@ static history_item_s *data_obj = NULL;
 static int listener_hsp = -1;
 static event_pool events_buf[10];
 static int buff_count = 0;
+static int lock_ref_count = 0;
 
 GHashTable *app_list = NULL;
 static GHashTable *pid_map = NULL;
@@ -215,8 +216,8 @@ static int bd_listener_set_battery_info()
                else
                        data_obj->battery_plugtype = BD_BPLT_NONE;
 
-               _DBG("battery_level = %d, battery_status = %d, battery_health = %d, \
-                       battery_plugtype = %d", data_obj->battery_level, data_obj->battery_status, \
+               _DBG("battery_level = %d, battery_status = %d, battery_health = %d, battery_plugtype = %d",
+                       data_obj->battery_level, data_obj->battery_status, \
                                data_obj->battery_health, data_obj->battery_plugtype);
 
                data_obj->battery_temperature = info.temperature;
@@ -771,15 +772,13 @@ static int bd_listener_set_power_lock_unlock_change_data(int lock, char *app_id)
 
        _INFO("lock change - %d, app - %s", lock, app_id);
 
-       static int prev_wakeup = 0;
        static int lock_hsp = 0;
+       static int prev_lock = -1;
 
-       if (prev_wakeup == lock) {
-               _DBG("prev & current wakeups are same");
+       if (prev_lock == lock) {
+               _WARN("same lock event");
                BM_FREE(app_id);
                return 1;
-       } else {
-               prev_wakeup = lock;
        }
 
        if (lock) {
@@ -801,7 +800,6 @@ static int bd_listener_set_power_lock_unlock_change_data(int lock, char *app_id)
                        _DBG("wakelock tag created, string_info - [%s]",
                                                data_obj->wakelock_tag->string_info->str);
 
-                       BM_FREE(app_id);
                } else {
                        _ERR(" object creation failure ");
                        BM_FREE(app_id);
@@ -816,6 +814,10 @@ static int bd_listener_set_power_lock_unlock_change_data(int lock, char *app_id)
                data_obj->state_1 &= ~(ST1_WAKE_LOCK_FLAG);
        }
 
+       prev_lock = lock;
+
+       BM_FREE(app_id);
+
        EXIT;
        return 0;
 }
@@ -1090,10 +1092,12 @@ static void bd_listener_create_event_data(int type, int val, char *app)
                _DBG("Event occur too early, not updating battery information ");
        }
 
-       if (type == LISTEN_BATTERY_CAPACITY_CHANGE && prev_battery_level == data_obj->battery_level)
+       if (type == LISTEN_BATTERY_CAPACITY_CHANGE && prev_battery_level == data_obj->battery_level) {
+               _DBG("same battery-levels, returning");
                return;
-       else
+       } else {
                prev_battery_level = data_obj->battery_level;
+       }
 
        if (data_obj->event_tag && type != LISTEN_APP_STATUS) {
                data_obj->event_tag->uid = 1000;
@@ -1122,6 +1126,8 @@ static void bd_listener_create_event_data(int type, int val, char *app)
                return;
        }
 
+       _DBG("SUCCESS - create event");
+
        EXIT;
        return;
 }
@@ -1601,14 +1607,20 @@ static void _bd_listener_charging_status_change(keynode_t *key, void* data)
 {
        ENTER;
 
-       int charging = 0;
+       int curr_state = 0;
+       static int prev_state = -1;
 
-       vconf_get_int(VCONFKEY_SYSMAN_CHARGER_STATUS, &charging);
+       vconf_get_int(VCONFKEY_SYSMAN_CHARGER_STATUS, &curr_state);
 
-       _INFO("device charging_status changed = %d ", charging);
+       _DBG("device charging_status changed = %d ", curr_state);
+
+       if (prev_state == curr_state) {
+               _WARN("same event received");
+               return;
+       }
 
        /* get event object */
-       event_pool *event = bd_listener_get_event_obj(LISTEN_CHARGING_STATUS_CHANGE, charging, NULL);
+       event_pool *event = bd_listener_get_event_obj(LISTEN_CHARGING_STATUS_CHANGE, curr_state, NULL);
        if (event == NULL) {
                _ERR("Failed to get event pool object");
                return;
@@ -1617,6 +1629,8 @@ static void _bd_listener_charging_status_change(keynode_t *key, void* data)
        /* create thread */
        bd_create_producer_thread(event, "charging_status_change");
 
+       prev_state = curr_state;
+
        EXIT;
        return;
 }
@@ -1745,84 +1759,90 @@ static void _bd_listener_notify_modem_power(TapiHandle *handle, const char *noti
        return;
 }
 
-static void _bd_listener_create_lock_event(char *lock_type, pid_t pid)
+static void _bd_listener_powerlock_signal_cb(GDBusConnection *conn, const gchar *sender, const gchar *path,
+                       const gchar *iface, const gchar *signal, GVariant *params, gpointer user_data)
 {
-       int val;
-       static int prev_lock = 0;
+       ENTER;
+
+       pid_t pid = -1;
+       char *lock_type = NULL;
+       unsigned int timeout;
        char *pname = NULL;
 
-       _INFO("lock [%s], pid [%d]", lock_type, pid);
+       g_variant_get(params, "(&sii)", &lock_type, &pid, &timeout);
+       BD_CHECK_VALIDITY_RETURN((pid > 0), {});
 
-       if (g_strcmp0(lock_type, "lcdoff") == 0)
-               val = 0;
-       else if (g_strcmp0(lock_type, "lcddim") == 0)
-               val = 1;
-       else if (g_strcmp0(lock_type, "lcdon") == 0)
-               val = 2;
-       else {
-               _DBG("different lock_type - [%s]", lock_type);
-               return;
-       }
+       _DBG("lock[%s], pid[%d], timeout[%d], ref_count[%d]", lock_type, pid, timeout, lock_ref_count);
 
-       if (prev_lock == val) {
-               _DBG("return due to same values");
-               return;
-       } else {
-               prev_lock = val;
-       }
+       if (lock_ref_count == 0) {
 
-       bm_get_name_for_pid(pid, &pname);
+               bm_get_symlink_for_pid(pid, &pname);
 
-       _DBG("received process name - [%s]", pname);
+               _DBG("creating wake-lock event, pid[%d], process[%s]", pid, pname);
 
-       /* get event object */
-       event_pool *event = bd_listener_get_event_obj(LISTEN_POWERLOCKUNLOCK_STATE, val, pname);
-       if (event == NULL) {
-               _ERR("Failed to get event pool object");
-               BM_FREE(pname);
-               return;
-       }
+               /* get event object */
+               event_pool *event = bd_listener_get_event_obj(LISTEN_POWERLOCKUNLOCK_STATE, 1, pname);
+               if (event == NULL) {
+                       _ERR("Failed to get event pool object");
+                       BM_FREE(pname);
+                       return;
+               }
 
-       /* create thread */
-       bd_create_producer_thread(event, "lock_event");
+               /* create thread */
+               bd_create_producer_thread(event, "lock_event");
+
+               ++lock_ref_count;
+
+       } else {
+               _DBG("lock acquired, ref_count[%d]", ++lock_ref_count);
+       }
 
        EXIT;
        return;
 }
 
-static void _bd_listener_powerlock_signal_cb(GDBusConnection *conn, const gchar *sender, const gchar *path,
+static void _bd_listener_powerunlock_signal_cb(GDBusConnection *conn, const gchar *sender, const gchar *path,
                        const gchar *iface, const gchar *signal, GVariant *params, gpointer user_data)
 {
        ENTER;
 
-       pid_t pid;
-       char *lock_type;
+       pid_t pid = -1;
+       char *lock_type = NULL;
        unsigned int timeout;
+       char *pname = NULL;
 
        g_variant_get(params, "(&sii)", &lock_type, &pid, &timeout);
+       BD_CHECK_VALIDITY_RETURN((pid > 0), {});
 
-       _INFO(" powerlock value changed =%s Pid=%d, timeout=%d", lock_type, pid, timeout);
+       _DBG("un-lock[%s], pid[%d], timeout[%d], ref_count[%d]", lock_type, pid, timeout, lock_ref_count);
 
-       _bd_listener_create_lock_event(lock_type, pid);
-
-       EXIT;
-       return;
-}
+       if (lock_ref_count == 0) {
+               _ERR("improper wakelock, no event created");
+               return;
+       } else if (lock_ref_count > 0) {
+               --lock_ref_count;
+               _DBG("received unlock event, count[%d]", lock_ref_count);
+       }
 
-static void _bd_listener_powerunlock_signal_cb(GDBusConnection *conn, const gchar *sender, const gchar *path,
-                       const gchar *iface, const gchar *signal, GVariant *params, gpointer user_data)
-{
-       ENTER;
+       if (lock_ref_count == 0) {
 
-       pid_t pid;
-       char *lock_type;
-       unsigned int timeout;
+               bm_get_symlink_for_pid(pid, &pname);
 
-       g_variant_get(params, "(&sii)", &lock_type, &pid, &timeout);
+               _DBG("creating wake-unlock event, pid[%d], process[%s]", pid, pname);
 
-       _INFO(" powerUnlock value changed =%s Pid=%d, timeout=%d", lock_type, pid, timeout);
+               /* get event object */
+               event_pool *event = bd_listener_get_event_obj(LISTEN_POWERLOCKUNLOCK_STATE, 0, pname);
+               if (event == NULL) {
+                       _ERR("Failed to get event pool object");
+                       BM_FREE(pname);
+                       return;
+               }
 
-       _bd_listener_create_lock_event(lock_type, pid);
+               /* create thread */
+               bd_create_producer_thread(event, "lock_event");
+       } else {
+               _DBG("still holding lock, ref_count[%d]", lock_ref_count);
+       }
 
        EXIT;
        return;

diff --git a/src/bm_util.c b/src/bm_util.c
index 54a03410d2bfb24631def1d99a99433895748c05..3b30fab1d4ffd21401feab69c07bf9842d8de202 100644 (file)
--- a/src/bm_util.c
+++ b/src/bm_util.c
@@ -15,16 +15,23 @@
  *
  */
 
+#include <unistd.h>
 #include <cynara-client.h>
 #include <cynara-session.h>
 #include <cynara-creds-gdbus.h>
 
+#include <errno.h>
+#include <string.h>
+#include <sys/stat.h>
+
 #include "bm_util.h"
 #include "bm_common.h"
 
 static cynara *p_cynara;
 GDBusConnection* connection_obj = NULL;
 
+enum { PATH_BUFFER_SIZE = 64, BUFFERSIZE = 1024 };
+
 GDBusErrorEntry bm_svc_errors[] = {
        {BATTERY_MONITOR_ERROR_NONE, BATTERY_MONITOR_SVC_ERROR_PREFIX".NoError"},
        {BATTERY_MONITOR_ERROR_OUT_OF_MEMORY, BATTERY_MONITOR_SVC_ERROR_PREFIX".OutOfMemory"},
@@ -369,7 +376,7 @@ void bd_get_focussed_app_id(char **app_name)
        return;
 }
 
-void bm_get_name_for_pid(pid_t pid, char **pname)
+void bm_get_symlink_for_pid(pid_t pid, char **pname)
 {
        _INFO("pid = [%d]", pid);
 
@@ -378,35 +385,37 @@ void bm_get_name_for_pid(pid_t pid, char **pname)
        app_manager_get_app_id(pid, &app_id);
 
        if (app_id == NULL) { /*it might be a daemon, ex-/usr/bin/batterymonitor-svcd*/
-               char buf[PATH_MAX];
-               int fd, r;
-
-               snprintf(buf, PATH_MAX, "/proc/%d/comm", pid);
-
-               if (access(buf, F_OK) != 0) {
-                       _ERR("maybe pid no more exists");
+               char path[PATH_BUFFER_SIZE], buf[BUFFERSIZE];
+               int path_len = 0, lst = 0;
+               ssize_t len = -1;
+               struct stat st_buf;
+
+               /* prepare pid-exe path */
+               path_len = snprintf(path, PATH_BUFFER_SIZE, "/proc/%d/exe", pid);
+               if (path_len < 1 || path_len >= PATH_BUFFER_SIZE) {
+                       _ERR("insufficient buffer size");
                        return;
                }
 
-               fd = open(buf, O_RDONLY);
-               if (fd < 0) {
-                       _ERR("process(%d) does not exist now.", pid);
+               _DBG("exe path - [%s]", path);
+
+               /* check availability */
+               lst = lstat(path, &st_buf);
+               if (lst != 0 || !S_ISLNK(st_buf.st_mode)) {
+                       _ERR("sym-link un-available");
                        return;
                }
 
-               r = read(fd, buf, PATH_MAX);
-               if ((r > 0) && (r < PATH_MAX)) {
-                       buf[r-1] = '\0';
+               /* read symbolic link */
+               len = readlink(path, buf, sizeof(buf)-1);
+               if (len != -1) {
+                       buf[len] = '\0';
                } else {
-                       _ERR("read error");
-                       if (close(fd) == -1)
-                               _ERR("fd close error");
+                       _ERR("read bytes - [%d], error [%s]", len, strerror(errno));
                        return;
                }
 
-               if (close(fd) == -1) {
-                       _ERR("fd close error");
-               }
+               _DBG("read sym-link - [%s]", buf);
 
                app_id = strdup(buf);
        }