Rename memory state and rearrange code

Change-Id: I09961cc9ed126a79920a1688119ce1e245479a34
Signed-off-by: Unsung Lee <unsung.lee@samsung.com>

diff --git a/src/common/cgroup/memory-cgroup.c b/src/common/cgroup/memory-cgroup.c
index 09ac95b..7268e23 100644 (file)
--- a/src/common/cgroup/memory-cgroup.c
+++ b/src/common/cgroup/memory-cgroup.c
@@ -40,6 +40,7 @@
 #include "cgroup.h"
 #include "module.h"
 #include "util.h"
+#include "file-helper.h"
 
 #include <stdlib.h>
 
@@ -62,6 +63,55 @@ static struct memcg_info gmemcg_info[CGROUP_END] = {
        {MEMCG_LOW_PATH,},
 };
 
+static void set_limit_in_bytes(const char *dir, unsigned int limit)
+{
+       int error;
+       unsigned int prev;
+
+       error = cgroup_read_node_uint32(dir, MEMCG_LIMIT_BYTE, &prev);
+       if (error) {
+               _E("[DEBUG] Failed to get %s from %s", MEMCG_LIMIT_BYTE, dir);
+               return;
+       }
+
+       if (prev > limit) {
+               cgroup_write_node_uint32(dir, MEMCG_LIMIT_BYTE, limit);
+               cgroup_write_node_uint32(dir, MEMCG_SWAP_LIMIT_BYTE, limit);
+       }
+       else {
+               cgroup_write_node_uint32(dir, MEMCG_SWAP_LIMIT_BYTE, limit);
+               cgroup_write_node_uint32(dir, MEMCG_LIMIT_BYTE, limit);
+       }
+}
+
+int check_oom_and_set_limit(const char *dir, unsigned int limit)
+{
+       int error;
+       static unsigned int poo = -1;
+
+       if (poo == -1) { 
+               error = fread_uint("/proc/sys/vm/panic_on_oom", &poo);
+               if (error) {
+                       _E("[DEBUG] Failed to get %s from %s", "/proc/sys/vm/panic_on_oom", dir);
+                       return RESOURCED_ERROR_FAIL;
+               }
+       }
+
+       /* If panic_on_oom is true (> 1), oom should be disabled  */
+       if (poo != 0) {
+               _I("[DEBUG] %s's value is %d. That is, kernel panic will be inevitable on %s, when oom happens", "proc/sys/vm/panic_on_oom", poo, dir);
+               error = cgroup_write_node_uint32(dir, MEMCG_OOM_CONTROL, 1);
+               if (!error)
+                       set_limit_in_bytes(dir, limit);
+       }
+       else {
+               _I("[DEBUG] panic_on_oom = %u on %s", poo, dir);
+               set_limit_in_bytes(dir, limit);
+       }
+
+       return RESOURCED_ERROR_NONE;
+}
+
 static int memcg_write_params_info(struct memcg_info *mi)
 {
        unsigned int limit = mi->limit;
@@ -97,8 +147,7 @@ static int memcg_write_params_info(struct memcg_info *mi)
                return ret;
 
        /* write limit_in_bytes */
-       ret = cgroup_write_node_uint32(name,
-                       MEMCG_LIMIT_BYTE, limit);
+       ret = check_oom_and_set_limit(name, limit);
        _I("set %s's limit to %u", name, limit);
        return ret;
 }
@@ -141,8 +190,8 @@ void memcg_info_set_limit(struct memcg_info *mi, float ratio,
 
        mi->limit = (float)totalram * ratio;
        mi->limit_ratio = ratio;
-       mi->threshold[LOWMEM_LOW] = (unsigned int)(mi->limit * MEMCG_LOW_RATIO);
-       mi->threshold[LOWMEM_MEDIUM] = (unsigned int)(mi->limit * MEMCG_MEDIUM_RATIO);
+       mi->threshold[MEM_STATE_CRITICAL] = (unsigned int)(mi->limit * MEMCG_LOW_RATIO);
+       mi->threshold[MEM_STATE_OOM] = (unsigned int)(mi->limit * MEMCG_MEDIUM_RATIO);
        mi->threshold_leave = (float)mi->limit * MEMCG_FOREGROUND_LEAVE_RATIO;
        mi->oomleave = mi->limit - mi->threshold_leave;
 }

diff --git a/src/common/cgroup/memory-cgroup.h b/src/common/cgroup/memory-cgroup.h
index f317908..cae5d6e 100644 (file)
--- a/src/common/cgroup/memory-cgroup.h
+++ b/src/common/cgroup/memory-cgroup.h
@@ -75,12 +75,12 @@ extern "C" {
 #define DEFAULT_MEMLOG_NR_MAX           50
 
 enum {
-       LOWMEM_NORMAL,
-       LOWMEM_DEDUP,
-       LOWMEM_SWAP,
-       LOWMEM_LOW,
-       LOWMEM_MEDIUM,
-       LOWMEM_MAX_LEVEL,
+       MEM_STATE_HIGH,
+       MEM_STATE_MEDIUM,
+       MEM_STATE_LOW,
+       MEM_STATE_CRITICAL,
+       MEM_STATE_OOM,
+       MEM_STATE_MAX,
 };
 
 enum lowmem_control_type {
@@ -150,7 +150,7 @@ struct memcg_info {
        /* leave memory usage */
        unsigned int oomleave;
        /* thresholds, normal, swap, low, medium, and leave */
-       unsigned int threshold[LOWMEM_MAX_LEVEL];
+       unsigned int threshold[MEM_STATE_MAX];
        unsigned int threshold_leave;
        int evfd;
        int swappiness;
@@ -200,6 +200,7 @@ int memcg_get_swap_usage(char *memcg, unsigned int *usage);
 int memcg_set_eventfd(const char *memcg, const char *event, const char *value);
 int memcg_init_eventfd(int evfd, const char *memcg, const char *event, const char *value);
 
+int check_oom_and_set_limit(const char *dir, unsigned int limit);
 
 struct memcg_info *get_root_memcg_info(void);
 void memcg_params_init(void);

diff --git a/src/common/swap-common.h b/src/common/swap-common.h
index 1063c9b..37ea4f6 100644 (file)
--- a/src/common/swap-common.h
+++ b/src/common/swap-common.h
@@ -57,8 +57,8 @@ struct swap_status_msg {
 };
 
 enum swap_compact_reason {
-       SWAP_COMPACT_LOWMEM_LOW,
-       SWAP_COMPACT_LOWMEM_MEDIUM,
+       SWAP_COMPACT_MEM_STATE_CRITICAL,
+       SWAP_COMPACT_MEM_STATE_OOM,
        SWAP_COMPACT_SWAP_FULL,
        SWAP_COMPACT_RESASON_MAX,
 };

diff --git a/src/resource-limiter/memory/lowmem-limit.c b/src/resource-limiter/memory/lowmem-limit.c
index 3be0115..c0358ae 100644 (file)
--- a/src/resource-limiter/memory/lowmem-limit.c
+++ b/src/resource-limiter/memory/lowmem-limit.c
@@ -51,7 +51,6 @@
 #include "fd-handler.h"
 #include "dbus-handler.h"
 #include "safe-kill.h"
-#include "file-helper.h"
 
 #define MEM_CONF_FILE                   RD_CONFIG_FILE(limiter)
 #define MEMLIMIT_CONFIG_SECTION        "MemLimit"
@@ -219,8 +218,12 @@ static gboolean liveness_check_cb(gpointer data)
                goto mle_timer_init;
        }
 
-       if (kill(mle->pid, 0) == 0)
+       if (kill(mle->pid, 0) == 0) {
+               _D("pid (%d) is still alive, so kill directly using SIGKILL", mle->pid);
                safe_kill(mle->pid, SIGKILL);
+       }
+
+       _D("[DEBUG] pid (%d) is dead", mle->pid);
 
 mle_timer_init:
        mle->pid = -1;
@@ -326,33 +329,10 @@ remove_mle:
        return false;
 }
 
-static void set_limit_in_bytes(const char *dir, unsigned int limit)
-{
-       int error;
-       unsigned int prev;
-
-       error = cgroup_read_node_uint32(dir, MEMCG_LIMIT_BYTE, &prev);
-       if (error) {
-               _E("[DEBUG] Failed to get %s from %s", MEMCG_LIMIT_BYTE, dir);
-               return;
-       }
-
-       if (prev > (limit * 1.2)) {
-               cgroup_write_node_uint32(dir, MEMCG_LIMIT_BYTE, (limit * 1.2));
-               cgroup_write_node_uint32(dir, MEMCG_SWAP_LIMIT_BYTE, (limit * 1.2));
-       }
-       else {
-               cgroup_write_node_uint32(dir, MEMCG_SWAP_LIMIT_BYTE, (limit * 1.2));
-               cgroup_write_node_uint32(dir, MEMCG_LIMIT_BYTE, (limit * 1.2));
-       }
-}
-
 int lowmem_reassign_limit(const char *dir,
                unsigned int limit, enum proc_action action)
 {
        int fd;
-       int error;
-       unsigned int poo;
        fd_handler_h fdh = NULL;
        gpointer hash_entry;
        struct memory_limit_event *mle = NULL;
@@ -380,23 +360,7 @@ int lowmem_reassign_limit(const char *dir,
                }
        }
 
-       error = fread_uint("/proc/sys/vm/panic_on_oom", &poo);
-       if (error) {
-               _E("[DEBUG] Failed to get %s from %s", "/proc/sys/vm/panic_on_oom", dir);
-               return RESOURCED_ERROR_FAIL;
-       }
-
-       /* If panic_on_oom is true (> 1), oom should be disabled  */
-       if (poo != 0) {
-               _I("%s's value is %d. That is, kernel panic will be inevitable, when oom happens", "proc/sys/vm/panic_on_oom", poo);
-               error = cgroup_write_node_uint32(dir, MEMCG_OOM_CONTROL, 1);
-               if (!error)
-                       set_limit_in_bytes(dir, limit);
-       }
-       else {
-               set_limit_in_bytes(dir, limit);
-       }
-
+       check_oom_and_set_limit(dir, limit * 1.2);
        snprintf(buf, sizeof(buf), "%d", limit);
 
        if (mle) {

diff --git a/src/resource-limiter/memory/vmpressure-lowmem-handler.c b/src/resource-limiter/memory/vmpressure-lowmem-handler.c
index f664dbc..1a6bb52 100644 (file)
--- a/src/resource-limiter/memory/vmpressure-lowmem-handler.c
+++ b/src/resource-limiter/memory/vmpressure-lowmem-handler.c
@@ -343,15 +343,15 @@ static void lowmem_request_destroy(gpointer data)
 /*-------------------------------------------------*/
 
 /* low memory action function for cgroup */
-static void memory_cgroup_medium_act(enum cgroup_type type, struct memcg_info *mi);
+static void memory_cgroup_proactive_lmk_act(enum cgroup_type type, struct memcg_info *mi);
 /* low memory action function */
-static void normal_act(void);
-static void swap_act(void);
-static void low_act(void);
-static void medium_act(void);
+static void high_mem_act(void);
+static void swap_activate_act(void);
+static void swap_compact_act(void);
+static void lmk_act(void);
 
 
-static size_t cur_mem_state = LOWMEM_NORMAL;
+static size_t cur_mem_state = MEM_STATE_HIGH;
 static int num_max_victims = MAX_MEMORY_CGROUP_VICTIMS;
 static int num_vict_between_check = MAX_VICTIMS_BETWEEN_CHECK;
 
@@ -366,12 +366,6 @@ static bool memcg_swap_status;
 static bool bg_reclaim;
 static int fragmentation_size;
 
-enum memory_level {
-       MEMORY_LEVEL_NORMAL,
-       MEMORY_LEVEL_LOW,
-       MEMORY_LEVEL_CRITICAL,
-};
-
 static const char *convert_cgroup_type_to_str(int type)
 {
        static const char *type_table[] =
@@ -395,7 +389,7 @@ static const char *convert_memstate_to_str(int mem_state)
 {
        static const char *state_table[] = {"mem normal", "mem dedup", "mem swap", "mem low",
                        "mem medium"};
-       if (mem_state >= 0 && mem_state < LOWMEM_MAX_LEVEL)
+       if (mem_state >= 0 && mem_state < MEM_STATE_MAX)
                return state_table[mem_state];
        return "";
 }
@@ -1053,7 +1047,7 @@ retry:
        if (calculate_range_of_oom(cgroup_type, &start_oom, &end_oom))
                goto done;
 
-       lmk_start_threshold = get_root_memcg_info()->threshold[LOWMEM_MEDIUM];
+       lmk_start_threshold = get_root_memcg_info()->threshold[MEM_STATE_OOM];
        shortfall = is_memory_recovered(&available, ctl->size);
 
        if (!shortfall || !reclaim_size) {
@@ -1193,7 +1187,7 @@ process_again:
 static void change_lowmem_state(unsigned int mem_state)
 {
        cur_mem_state = mem_state;
-       lmk_start_threshold = get_root_memcg_info()->threshold[LOWMEM_MEDIUM];
+       lmk_start_threshold = get_root_memcg_info()->threshold[MEM_STATE_OOM];
 
        resourced_notify(RESOURCED_NOTIFIER_MEM_STATE_CHANGED,
                (void *)&cur_mem_state);
@@ -1206,16 +1200,16 @@ static void lowmem_swap_memory(char *path)
 {
        unsigned int available;
 
-       if (cur_mem_state == LOWMEM_NORMAL)
+       if (cur_mem_state == MEM_STATE_HIGH)
                return;
 
        if (swap_get_state() != SWAP_ON)
                return;
 
        available = proc_get_mem_available();
-       if (cur_mem_state != LOWMEM_SWAP &&
-           available <= get_root_memcg_info()->threshold[LOWMEM_SWAP])
-               swap_act();
+       if (cur_mem_state != MEM_STATE_LOW &&
+           available <= get_root_memcg_info()->threshold[MEM_STATE_LOW])
+               swap_activate_act();
 
        resourced_notify(RESOURCED_NOTIFIER_SWAP_START, path);
        memcg_swap_status = true;
@@ -1252,7 +1246,7 @@ void lowmem_trigger_swap(pid_t pid, char *path, bool move)
        }
 
        /* Correponding process is already managed per app or service.
-        * In addition, if this process is already located in the CGROUP_LOW, then just do swap
+        * In addition, if some process is already located in the CGROUP_LOW, then just do swap
         */
        resourced_notify(RESOURCED_NOTIFIER_SWAP_START, path);
 }
@@ -1263,18 +1257,20 @@ static void memory_level_send_system_event(int lv)
        const char *str;
 
        switch (lv) {
-       case MEMORY_LEVEL_NORMAL:
-               str = EVT_VAL_MEMORY_NORMAL;
-               break;
-       case MEMORY_LEVEL_LOW:
-               str = EVT_VAL_MEMORY_SOFT_WARNING;
-               break;
-       case MEMORY_LEVEL_CRITICAL:
-               str = EVT_VAL_MEMORY_HARD_WARNING;
-               break;
-       default:
-               _E("Invalid state");
-               return;
+               case MEM_STATE_HIGH:
+               case MEM_STATE_MEDIUM:
+               case MEM_STATE_LOW:
+                       str = EVT_VAL_MEMORY_NORMAL;
+                       break;
+               case MEM_STATE_CRITICAL:
+                       str = EVT_VAL_MEMORY_SOFT_WARNING;
+                       break;
+               case MEM_STATE_OOM:
+                       str = EVT_VAL_MEMORY_HARD_WARNING;
+                       break;
+               default:
+                       _E("Invalid state");
+                       return;
        }
 
        b = bundle_create();
@@ -1288,7 +1284,7 @@ static void memory_level_send_system_event(int lv)
        bundle_free(b);
 }
 
-static void normal_act(void)
+static void high_mem_act(void)
 {
        int ret, status;
 
@@ -1298,10 +1294,10 @@ static void normal_act(void)
        if (status != VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL) {
                vconf_set_int(VCONFKEY_SYSMAN_LOW_MEMORY,
                              VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL);
-               memory_level_send_system_event(MEMORY_LEVEL_NORMAL);
+               memory_level_send_system_event(MEM_STATE_HIGH);
        }
 
-       change_lowmem_state(LOWMEM_NORMAL);
+       change_lowmem_state(MEM_STATE_HIGH);
 
        if (swap_get_state() == SWAP_ON && memcg_swap_status) {
                resourced_notify(RESOURCED_NOTIFIER_SWAP_UNSET_LIMIT, get_memcg_info(CGROUP_LOW));
@@ -1312,7 +1308,7 @@ static void normal_act(void)
                        (void *)CGROUP_FREEZER_ENABLED);
 }
 
-static void swap_act(void)
+static void swap_activate_act(void)
 {
        int ret, status;
 
@@ -1323,9 +1319,9 @@ static void swap_act(void)
        if (status != VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL) {
                vconf_set_int(VCONFKEY_SYSMAN_LOW_MEMORY,
                                VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL);
-               memory_level_send_system_event(MEMORY_LEVEL_NORMAL);
+               memory_level_send_system_event(MEM_STATE_LOW);
        }
-       change_lowmem_state(LOWMEM_SWAP);
+       change_lowmem_state(MEM_STATE_LOW);
        if (proc_get_freezer_status() == CGROUP_FREEZER_PAUSED)
                resourced_notify(RESOURCED_NOTIFIER_FREEZER_CGROUP_STATE,
                        (void *)CGROUP_FREEZER_ENABLED);
@@ -1354,9 +1350,9 @@ static void dedup_act(enum ksm_scan_mode mode)
                if (status != VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL) {
                        vconf_set_int(VCONFKEY_SYSMAN_LOW_MEMORY,
                                        VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL);
-                       memory_level_send_system_event(MEMORY_LEVEL_NORMAL);
+                       memory_level_send_system_event(MEM_STATE_MEDIUM);
                }
-               change_lowmem_state(LOWMEM_DEDUP);
+               change_lowmem_state(MEM_STATE_MEDIUM);
 
                data = KSM_SCAN_PARTIAL;
                resourced_notify(RESOURCED_NOTIFIER_DEDUP_SCAN, &data);
@@ -1366,21 +1362,21 @@ static void dedup_act(enum ksm_scan_mode mode)
        }
 }
 
-static void low_act(void)
+static void swap_compact_act(void)
 {
-       change_lowmem_state(LOWMEM_LOW);
-       resourced_notify(RESOURCED_NOTIFIER_SWAP_COMPACT, (void *)SWAP_COMPACT_LOWMEM_LOW);
-       memory_level_send_system_event(MEMORY_LEVEL_LOW);
+       change_lowmem_state(MEM_STATE_CRITICAL);
+       resourced_notify(RESOURCED_NOTIFIER_SWAP_COMPACT, (void *)SWAP_COMPACT_MEM_STATE_CRITICAL);
+       memory_level_send_system_event(MEM_STATE_CRITICAL);
 }
 
 static void medium_cb(struct lowmem_control *ctl)
 {
        if (ctl->status == LOWMEM_RECLAIM_DONE)
                oom_popup = false;
-       lowmem_change_memory_state(LOWMEM_NORMAL, 0);
+       lowmem_change_memory_state(MEM_STATE_HIGH, 0);
 }
 
-static void medium_act(void)
+static void lmk_act(void)
 {
        unsigned int available;
        int ret;
@@ -1397,7 +1393,7 @@ static void medium_act(void)
        if (ret)
                _D("vconf_get_int fail %s", VCONFKEY_SYSMAN_LOW_MEMORY);
 
-       memory_level_send_system_event(MEMORY_LEVEL_CRITICAL);
+       memory_level_send_system_event(MEM_STATE_OOM);
        if (status != VCONFKEY_SYSMAN_LOW_MEMORY_HARD_WARNING) {
                if (proc_get_freezer_status() == CGROUP_FREEZER_ENABLED)
                        resourced_notify(RESOURCED_NOTIFIER_FREEZER_CGROUP_STATE,
@@ -1407,7 +1403,7 @@ static void medium_act(void)
        }
        available = proc_get_mem_available();
 
-       change_lowmem_state(LOWMEM_MEDIUM);
+       change_lowmem_state(MEM_STATE_OOM);
 
        if (available < get_root_memcg_info()->threshold_leave) {
                struct lowmem_control *ctl;
@@ -1421,7 +1417,7 @@ static void medium_act(void)
                }
        }
 
-       resourced_notify(RESOURCED_NOTIFIER_SWAP_COMPACT, (void *)SWAP_COMPACT_LOWMEM_MEDIUM);
+       resourced_notify(RESOURCED_NOTIFIER_SWAP_COMPACT, (void *)SWAP_COMPACT_MEM_STATE_OOM);
 
        /*
         * Flush resourced memory such as other processes.
@@ -1439,25 +1435,25 @@ static void lowmem_trigger_memory_state_action(int mem_state)
         * But it should except this condition if mem_state is already medium.
         * Otherwise, recalim worker couldn't run any more.
         */
-       if (mem_state != LOWMEM_MEDIUM && cur_mem_state == mem_state)
+       if (mem_state != MEM_STATE_OOM && cur_mem_state == mem_state)
                return;
 
        switch (mem_state) {
-       case LOWMEM_NORMAL:
-               normal_act();
+       case MEM_STATE_HIGH:
+               high_mem_act();
                break;
-       case LOWMEM_DEDUP:
+       case MEM_STATE_MEDIUM:
                dedup_act(KSM_SCAN_PARTIAL);
                break;
-       case LOWMEM_SWAP:
-               swap_act();
+       case MEM_STATE_LOW:
+               swap_activate_act();
                break;
-       case LOWMEM_LOW:
+       case MEM_STATE_CRITICAL:
                dedup_act(KSM_SCAN_FULL);
-               low_act();
+               swap_compact_act();
                break;
-       case LOWMEM_MEDIUM:
-               medium_act();
+       case MEM_STATE_OOM:
+               lmk_act();
                break;
        default:
                assert(0);
@@ -1481,7 +1477,7 @@ static void lowmem_dump_cgroup_procs(struct memcg_info *mi)
        g_array_free(pids_array, true);
 }
 
-static void memory_cgroup_medium_act(enum cgroup_type type, struct memcg_info *mi)
+static void memory_cgroup_proactive_lmk_act(enum cgroup_type type, struct memcg_info *mi)
 {
        struct lowmem_control *ctl;
 
@@ -1499,10 +1495,10 @@ static void memory_cgroup_medium_act(enum cgroup_type type, struct memcg_info *m
 static unsigned int check_mem_state(unsigned int available)
 {
        int mem_state;
-       for (mem_state = LOWMEM_MAX_LEVEL - 1; mem_state > LOWMEM_NORMAL; mem_state--) {
-               if (mem_state != LOWMEM_MEDIUM && available <= get_root_memcg_info()->threshold[mem_state])
+       for (mem_state = MEM_STATE_MAX - 1; mem_state > MEM_STATE_HIGH; mem_state--) {
+               if (mem_state != MEM_STATE_OOM && available <= get_root_memcg_info()->threshold[mem_state])
                        break;
-               else if (mem_state == LOWMEM_MEDIUM && available <= lmk_start_threshold)
+               else if (mem_state == MEM_STATE_OOM && available <= lmk_start_threshold)
                        break;
        }
 
@@ -1581,35 +1577,35 @@ static int set_memory_config(struct parse_result *result, void *user_data)
 
        if (!strncmp(result->name, "ThresholdDedup", strlen("ThresholdDedup")+1)) {
                int value = atoi(result->value);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_DEDUP, value);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, value);
        } else if (!strncmp(result->name, "ThresholdSwap", strlen("ThresholdSwap")+1)) {
                int value = atoi(result->value);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_SWAP, value);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, value);
        } else if (!strncmp(result->name, "ThresholdLow", strlen("ThresholdLow")+1)) {
                int value = atoi(result->value);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_LOW, value);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, value);
        } else if (!strncmp(result->name, "ThresholdMedium", strlen("ThresholdMedium")+1)) {
                int value = atoi(result->value);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_MEDIUM, value);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, value);
        } else if (!strncmp(result->name, "ThresholdLeave", strlen("ThresholdLeave")+1)) {
                int value = atoi(result->value);
                memcg_set_leave_threshold(CGROUP_ROOT, value);
        } else if (!strncmp(result->name, "ThresholdRatioDedup", strlen("ThresholdRatioDedup")+1)) {
                double ratio = atoi(result->value);
                int value = (double)totalram * ratio / 100.0;
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_DEDUP, BYTE_TO_MBYTE(value));
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, BYTE_TO_MBYTE(value));
        } else if (!strncmp(result->name, "ThresholdRatioSwap", strlen("ThresholdRatioSwap")+1)) {
                double ratio = atoi(result->value);
                int value = (double)totalram * ratio / 100.0;
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_SWAP, BYTE_TO_MBYTE(value));
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, BYTE_TO_MBYTE(value));
        } else if (!strncmp(result->name, "ThresholdRatioLow", strlen("ThresholdRatioLow")+1)) {
                double ratio = atoi(result->value);
                int value = (double)totalram * ratio / 100.0;
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_LOW, BYTE_TO_MBYTE(value));
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, BYTE_TO_MBYTE(value));
        } else if (!strncmp(result->name, "ThresholdRatioMedium", strlen("ThresholdRatioMedium")+1)) {
                double ratio = atoi(result->value);
                int value = (double)totalram * ratio / 100.0;
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_MEDIUM, BYTE_TO_MBYTE(value));
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, BYTE_TO_MBYTE(value));
        } else if (!strncmp(result->name, "ThresholdRatioLeave", strlen("ThresholdRatioLeave")+1)) {
                double ratio = atoi(result->value);
                int value = (double)totalram * ratio / 100.0;
@@ -1677,78 +1673,78 @@ static void setup_memcg_params(void)
                /* set thresholds for ram size 64M */
                proactive_threshold = PROACTIVE_64_THRES;
                proactive_leave = PROACTIVE_64_LEAVE;
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_DEDUP, CGROUP_ROOT_64_THRES_DEDUP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_SWAP, CGROUP_ROOT_64_THRES_SWAP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_LOW, CGROUP_ROOT_64_THRES_LOW);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_MEDIUM, CGROUP_ROOT_64_THRES_MEDIUM);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_64_THRES_DEDUP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_64_THRES_SWAP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_64_THRES_LOW);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_64_THRES_MEDIUM);
                memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_64_THRES_LEAVE);
                num_max_victims = CGROUP_ROOT_64_NUM_VICTIMS;
        } else if (total_ramsize <= MEM_SIZE_256) {
                /* set thresholds for ram size 256M */
                proactive_threshold = PROACTIVE_256_THRES;
                proactive_leave = PROACTIVE_256_LEAVE;
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_DEDUP, CGROUP_ROOT_256_THRES_DEDUP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_SWAP, CGROUP_ROOT_256_THRES_SWAP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_LOW, CGROUP_ROOT_256_THRES_LOW);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_MEDIUM, CGROUP_ROOT_256_THRES_MEDIUM);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_256_THRES_DEDUP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_256_THRES_SWAP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_256_THRES_LOW);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_256_THRES_MEDIUM);
                memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_256_THRES_LEAVE);
                num_max_victims = CGROUP_ROOT_256_NUM_VICTIMS;
        } else if (total_ramsize <= MEM_SIZE_448) {
                /* set thresholds for ram size 448M */
                proactive_threshold = PROACTIVE_448_THRES;
                proactive_leave = PROACTIVE_448_LEAVE;
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_DEDUP, CGROUP_ROOT_448_THRES_DEDUP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_SWAP, CGROUP_ROOT_448_THRES_SWAP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_LOW, CGROUP_ROOT_448_THRES_LOW);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_MEDIUM, CGROUP_ROOT_448_THRES_MEDIUM);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_448_THRES_DEDUP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_448_THRES_SWAP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_448_THRES_LOW);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_448_THRES_MEDIUM);
                memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_448_THRES_LEAVE);
                num_max_victims = CGROUP_ROOT_448_NUM_VICTIMS;
        } else if (total_ramsize <= MEM_SIZE_512) {
                /* set thresholds for ram size 512M */
                proactive_threshold = PROACTIVE_512_THRES;
                proactive_leave = PROACTIVE_512_LEAVE;
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_DEDUP, CGROUP_ROOT_512_THRES_DEDUP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_SWAP, CGROUP_ROOT_512_THRES_SWAP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_LOW, CGROUP_ROOT_512_THRES_LOW);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_MEDIUM, CGROUP_ROOT_512_THRES_MEDIUM);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_512_THRES_DEDUP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_512_THRES_SWAP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_512_THRES_LOW);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_512_THRES_MEDIUM);
                memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_512_THRES_LEAVE);
                num_max_victims = CGROUP_ROOT_512_NUM_VICTIMS;
        }  else if (total_ramsize <= MEM_SIZE_768) {
                /* set thresholds for ram size 512M */
                proactive_threshold = PROACTIVE_768_THRES;
                proactive_leave = PROACTIVE_768_LEAVE;
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_DEDUP, CGROUP_ROOT_768_THRES_DEDUP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_SWAP, CGROUP_ROOT_768_THRES_SWAP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_LOW, CGROUP_ROOT_768_THRES_LOW);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_MEDIUM, CGROUP_ROOT_768_THRES_MEDIUM);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_768_THRES_DEDUP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_768_THRES_SWAP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_768_THRES_LOW);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_768_THRES_MEDIUM);
                memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_768_THRES_LEAVE);
                num_max_victims = CGROUP_ROOT_768_NUM_VICTIMS;
        } else if (total_ramsize <= MEM_SIZE_1024) {
                /* set thresholds for ram size more than 1G */
                proactive_threshold = PROACTIVE_1024_THRES;
                proactive_leave = PROACTIVE_1024_LEAVE;
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_DEDUP, CGROUP_ROOT_1024_THRES_DEDUP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_SWAP, CGROUP_ROOT_1024_THRES_SWAP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_LOW, CGROUP_ROOT_1024_THRES_LOW);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_MEDIUM, CGROUP_ROOT_1024_THRES_MEDIUM);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_1024_THRES_DEDUP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_1024_THRES_SWAP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_1024_THRES_LOW);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_1024_THRES_MEDIUM);
                memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_1024_THRES_LEAVE);
                num_max_victims = CGROUP_ROOT_1024_NUM_VICTIMS;
        } else if (total_ramsize <= MEM_SIZE_2048) {
                proactive_threshold = PROACTIVE_2048_THRES;
                proactive_leave = PROACTIVE_2048_LEAVE;
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_DEDUP, CGROUP_ROOT_2048_THRES_DEDUP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_SWAP, CGROUP_ROOT_2048_THRES_SWAP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_LOW, CGROUP_ROOT_2048_THRES_LOW);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_MEDIUM, CGROUP_ROOT_2048_THRES_MEDIUM);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_2048_THRES_DEDUP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_2048_THRES_SWAP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_2048_THRES_LOW);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_2048_THRES_MEDIUM);
                memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_2048_THRES_LEAVE);
                num_max_victims = CGROUP_ROOT_2048_NUM_VICTIMS;
        } else {
                proactive_threshold = PROACTIVE_3072_THRES;
                proactive_leave = PROACTIVE_3072_LEAVE;
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_DEDUP, CGROUP_ROOT_3072_THRES_DEDUP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_SWAP, CGROUP_ROOT_3072_THRES_SWAP);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_LOW, CGROUP_ROOT_3072_THRES_LOW);
-               memcg_set_threshold(CGROUP_ROOT, LOWMEM_MEDIUM, CGROUP_ROOT_3072_THRES_MEDIUM);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_3072_THRES_DEDUP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_3072_THRES_SWAP);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_3072_THRES_LOW);
+               memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_3072_THRES_MEDIUM);
                memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_3072_THRES_LEAVE);
                num_max_victims = CGROUP_ROOT_3072_NUM_VICTIMS;
        }
@@ -1902,9 +1898,9 @@ static void lowmem_press_cgroup_handler(enum cgroup_type type, struct memcg_info
                return;
        }
 
-       threshold = mi->threshold[LOWMEM_MEDIUM];
+       threshold = mi->threshold[MEM_STATE_OOM];
        if (usage >= threshold)
-               memory_cgroup_medium_act(type, mi);
+               memory_cgroup_proactive_lmk_act(type, mi);
        else
                _I("anon page %u MB < medium threshold %u MB", BYTE_TO_MBYTE(usage),
                                BYTE_TO_MBYTE(threshold));
@@ -1943,7 +1939,7 @@ static int lowmem_press_register_eventfd(struct memcg_info *mi)
        const char *name = mi->name;
        static fd_handler_h handler;
 
-       if (mi->threshold[LOWMEM_MEDIUM] == LOWMEM_THRES_INIT)
+       if (mi->threshold[MEM_STATE_OOM] == LOWMEM_THRES_INIT)
                return 0;
 
        evfd = memcg_set_eventfd(name, MEMCG_EVENTFD_MEMORY_PRESSURE,
@@ -1977,7 +1973,7 @@ static int lowmem_press_setup_eventfd(void)
 
 static void lowmem_force_reclaim_cb(struct lowmem_control *ctl)
 {
-       lowmem_change_memory_state(LOWMEM_NORMAL, 0);
+       lowmem_change_memory_state(MEM_STATE_HIGH, 0);
 }
 
 int lowmem_trigger_reclaim(int flags, int victims, enum cgroup_type type, int threshold)
@@ -1992,7 +1988,7 @@ int lowmem_trigger_reclaim(int flags, int victims, enum cgroup_type type, int th
        type = type > 0 ? type : CGROUP_LOW;
        threshold = threshold > 0 ? threshold : get_root_memcg_info()->threshold_leave;
 
-       lowmem_change_memory_state(LOWMEM_LOW, 1);
+       lowmem_change_memory_state(MEM_STATE_CRITICAL, 1);
        LOWMEM_SET_REQUEST(ctl, flags,
                type, threshold, victims,
                lowmem_force_reclaim_cb);
@@ -2044,7 +2040,7 @@ static void lowmem_proactive_oom_killer(int flags, char *appid)
        before = proc_get_mem_available();
 
        /* If memory state is medium or normal, just return and kill in oom killer */
-       if (before < get_root_memcg_info()->threshold[LOWMEM_MEDIUM] || before > proactive_leave)
+       if (before < get_root_memcg_info()->threshold[MEM_STATE_OOM] || before > proactive_leave)
                return;
 
        victims = num_max_victims  > MAX_PROACTIVE_HIGH_VICTIMS
@@ -2068,13 +2064,13 @@ static void lowmem_proactive_oom_killer(int flags, char *appid)
                 * after launching app, ensure that available memory is
                 * above threshold_leave
                 */
-               if (after >= get_root_memcg_info()->threshold[LOWMEM_MEDIUM])
+               if (after >= get_root_memcg_info()->threshold[MEM_STATE_OOM])
                        return;
 
-               if (proactive_threshold - rss >= get_root_memcg_info()->threshold[LOWMEM_MEDIUM])
+               if (proactive_threshold - rss >= get_root_memcg_info()->threshold[MEM_STATE_OOM])
                        size = proactive_threshold;
                else
-                       size = rss + get_root_memcg_info()->threshold[LOWMEM_MEDIUM] + THRESHOLD_MARGIN;
+                       size = rss + get_root_memcg_info()->threshold[MEM_STATE_OOM] + THRESHOLD_MARGIN;
 
                _D("history based proactive LMK : avg rss %u, available %u required = %u MB",
                        rss, before, size);
@@ -2184,7 +2180,7 @@ static void load_configs(const char *path)
 static void print_mem_configs(void)
 {
        /* print info of Memory section */
-       for (int mem_lvl = 0; mem_lvl < LOWMEM_MAX_LEVEL; mem_lvl++)
+       for (int mem_lvl = 0; mem_lvl < MEM_STATE_MAX; mem_lvl++)
                _I("set threshold for state '%s' to %u MB",
                convert_memstate_to_str(mem_lvl), get_root_memcg_info()->threshold[mem_lvl]);
 

diff --git a/src/resource-optimizer/memory/compaction/compaction.c b/src/resource-optimizer/memory/compaction/compaction.c
index 86a045a..b116218 100644 (file)
--- a/src/resource-optimizer/memory/compaction/compaction.c
+++ b/src/resource-optimizer/memory/compaction/compaction.c
@@ -513,7 +513,7 @@ static int compact_mem_state_changed(void *data)
        if (mem_info) {
                int new_state = *((int *)data);
 
-               if (new_state < LOWMEM_NORMAL || new_state >= LOWMEM_MAX_LEVEL) {
+               if (new_state < MEM_STATE_HIGH || new_state >= MEM_STATE_MAX) {
                        result = RESOURCED_ERROR_FAIL;
                        goto leave;
                }

diff --git a/src/resource-optimizer/memory/swap/swap.c b/src/resource-optimizer/memory/swap/swap.c
index a942aff..59a210e 100644 (file)
--- a/src/resource-optimizer/memory/swap/swap.c
+++ b/src/resource-optimizer/memory/swap/swap.c
@@ -166,9 +166,9 @@ int do_dd(char *input, char *output, unsigned int size, unsigned int count)
 
 static const char *compact_reason_to_str(enum swap_compact_reason reason)
 {
-       static const char *reasons_table[] = {"lowmem: low", "lowmem: medium",
+       static const char *reasons_table[] = {"lowmem: critical", "lowmem: oom",
                        "swap: zram full"};
-       if (reason >= SWAP_COMPACT_LOWMEM_LOW && reason < SWAP_COMPACT_RESASON_MAX)
+       if (reason >= SWAP_COMPACT_MEM_STATE_CRITICAL && reason < SWAP_COMPACT_RESASON_MAX)
                return reasons_table[reason];
        return "";
 }
@@ -234,10 +234,12 @@ static int swap_use_hard_limit(char *memcg)
        _D("Swap request: %s cgroup usage is %u, hard limit set to %u (hard limit fraction %f)",
                        memcg, usage, memcg_limit, swap_hard_limit_fraction);
        if (memcg_limit != 0)
-               ret = cgroup_write_node_uint32(memcg, MEMCG_LIMIT_BYTE, memcg_limit);
-       else
+               ret = check_oom_and_set_limit(memcg, memcg_limit); 
+       else {
                /* If the group is empty don't set the limit to enable adding processes. */
+               ret = cgroup_write_node_int32(memcg, MEMCG_SWAP_LIMIT_BYTE, -1);
                ret = cgroup_write_node_int32(memcg, MEMCG_LIMIT_BYTE, -1);
+       }
 
        if (ret != RESOURCED_ERROR_NONE)
                _E("Not able to set hard limit of %s memory cgroup", memcg);
@@ -371,11 +373,6 @@ static int swap_reclaim_memcg(char *path)
 
        if (!path)
                return -EINVAL;
-/*     struct memcg_info *info = msg.memcg_info;
-
-
-       if (!info)
-               return -EINVAL;*/
 
        r = swap_compact_in_module();
        if (r) {
@@ -779,7 +776,8 @@ static int swap_cgroup_reset_limit(void *data)
        if (swap_node == SWAP_NODE_FORCE_RECLAIM)
                return RESOURCED_ERROR_NONE;
 
-       ret = cgroup_write_node_int32(mi->name, MEMCG_LIMIT_BYTE, mi->limit);
+       ret = check_oom_and_set_limit(mi->name, mi->limit);
+//     ret = cgroup_write_node_int32(mi->name, MEMCG_LIMIT_BYTE, mi->limit);
        if (ret != RESOURCED_ERROR_NONE)
                _E("Failed to change hard limit of %s cgroup to -1", mi->name);
        else