Refactor enum 'oom_score' for high readability

Rename 'oom_score' enumeration and refactor all of code related to
this enumeration to improve readability

resourced uses enum 'oom_score' and this enum has four elements
(OOM_SCORE_HIGH, OOM_SCORE_MEDIUM, OOM_SCORE_LOW, OOM_SCORE_MAX).
Each element means foreground app + /proc group,
most recently used background app group,
least recently used background app group, and all process group respectively.
However, it is too difficult to match element and group.
In addition, order of the element is wrong.

Name 'oom_score' is changed to 'oom_level' and
each element name is changed like below:
OOM_SCORE_LOW	 -> OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED = 0
OOM_SCORE_MEDIUM -> OOM_LEVEL_BACKGROUND_MOST_RECENTLY_USED = 1
OOM_SCORE_HIGH	 -> OOM_LEVEL_FOREGROUND_AND_PROC = 2
OOM_SCORE_MAX	 -> OOM_LEVEL_ALL = 3

Change-Id: I499f1ef23a83d0e436f91b8de5437fece7c916ac
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 8c15d6f75005142d9d91e833920e675fcf63cf78..ebde437d21f077a5109e7861a0521a0f0d2a06ed 100644 (file)
--- a/src/common/cgroup/memory-cgroup.c
+++ b/src/common/cgroup/memory-cgroup.c
@@ -97,34 +97,40 @@ int cgroup_get_type(int oom_score_adj)
                return MEMCG_ROOT;
 }
 
-int cgroup_get_lowest_oom_score_adj(int score)
-{
-       if (score < OOM_SCORE_HIGH || score > OOM_SCORE_MAX) {
-               _E("oom score should be located between OOM_SCORE_HIGH and OOM_SCORE_MAX");
-       }
-
-       if (score == OOM_SCORE_HIGH)
-               return OOMADJ_SU;
-       else if (score == OOM_SCORE_MEDIUM)
-               return OOMADJ_BACKGRD_PERCEPTIBLE;
-       else if (score == OOM_SCORE_LOW)
-               return OOMADJ_BACKGRD_UNLOCKED + OOMADJ_APP_INCREASE;
-       else
-               return OOMADJ_SU;
-}
-
-int cgroup_get_highest_oom_score_adj(int score)
-{
-       if (score < OOM_SCORE_HIGH || score > OOM_SCORE_MAX) {
-               _E("oom score should be located between OOM_SCORE_HIGH and OOM_SCORE_MAX");
-       }
-
-       if (score == OOM_SCORE_HIGH)
-               return OOMADJ_FOREGRD_UNLOCKED;
-       else if (score == OOM_SCORE_MEDIUM)
-               return OOMADJ_BACKGRD_UNLOCKED;
-       else
-               return OOMADJ_APP_MAX;
+int cgroup_get_lowest_oom_score_adj(enum oom_level oom_level)
+{
+        switch (oom_level) {
+        case OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED:
+                return OOMADJ_BACKGRD_UNLOCKED + OOMADJ_APP_INCREASE;
+        case OOM_LEVEL_BACKGROUND_MOST_RECENTLY_USED:
+                return OOMADJ_BACKGRD_PERCEPTIBLE;
+        case OOM_LEVEL_FOREGROUND_AND_PROC:
+                return OOMADJ_SU;
+        default:
+                if (oom_level < OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED
+                                || oom_level > OOM_LEVEL_ALL)
+                        _E("oom level is out of range");
+
+                return OOMADJ_SU;
+        }
+}
+
+int cgroup_get_highest_oom_score_adj(enum oom_level oom_level)
+{
+        switch (oom_level) {
+        case OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED:
+                return OOMADJ_APP_MAX;
+        case OOM_LEVEL_BACKGROUND_MOST_RECENTLY_USED:
+                return OOMADJ_BACKGRD_UNLOCKED;
+        case OOM_LEVEL_FOREGROUND_AND_PROC:
+                return OOMADJ_FOREGRD_UNLOCKED;
+        default:
+                if (oom_level < OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED
+                                || oom_level > OOM_LEVEL_ALL)
+                        _E("oom level is out of range");
+
+                return OOMADJ_APP_MAX;
+        }
 }
 
 struct cgroup *get_cgroup_tree(int idx)

diff --git a/src/common/cgroup/memory-cgroup.h b/src/common/cgroup/memory-cgroup.h
index 295449e3efbee0bcfad9c0c867e0e710f5dac683..5ae3ffa838009edeb969e2c3cd99105cacccee52 100644 (file)
--- a/src/common/cgroup/memory-cgroup.h
+++ b/src/common/cgroup/memory-cgroup.h
@@ -72,11 +72,11 @@ enum {
        MEM_LEVEL_MAX,
 };
 
-enum oom_score {
-       OOM_SCORE_HIGH,
-       OOM_SCORE_MEDIUM,
-       OOM_SCORE_LOW,
-       OOM_SCORE_MAX,
+enum oom_level {
+       OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED,
+       OOM_LEVEL_BACKGROUND_MOST_RECENTLY_USED,
+       OOM_LEVEL_FOREGROUND_AND_PROC,
+       OOM_LEVEL_ALL,
 };
 
 enum lowmem_control_type {
@@ -259,17 +259,17 @@ int cgroup_get_type(int oom_score_adj);
 
 /**
  * @desc Get the highest oom_score_adj of the cgroup type
- * @param type - cgroup type
+ * @param oom_level - oom level
  * @return oom_score_adj
  */
-int cgroup_get_highest_oom_score_adj(int type);
+int cgroup_get_highest_oom_score_adj(enum oom_level oom_level);
 
 /**
  * @desc Get the lowest oom_score_adj of the cgroup type
- * @param type - cgroup type
+ * @param oom_level - oom level
  * @return oom_score_adj
  */
-int cgroup_get_lowest_oom_score_adj(int type);
+int cgroup_get_lowest_oom_score_adj(enum oom_level oom_level);
 struct memcg_info *get_memcg_info(int idx);
 struct cgroup *get_cgroup_tree(int idx);
 

diff --git a/src/resource-limiter/memory/lowmem-controller.c b/src/resource-limiter/memory/lowmem-controller.c
index 91443f9b8e7d436b9a77d24e433bc30cbc424fdd..4c4ef4b6815d5316411f06153ad59cb05cad409e 100644 (file)
--- a/src/resource-limiter/memory/lowmem-controller.c
+++ b/src/resource-limiter/memory/lowmem-controller.c
@@ -458,7 +458,8 @@ static int oom_mem_control(void *data)
        lowmem_change_lowmem_state(MEM_LEVEL_OOM);
 
        if (available_mb < get_root_memcg_info()->threshold_leave_mb) {
-               lowmem_queue_new_request(OOM_IN_DEPTH, OOM_SCORE_LOW,
+               lowmem_queue_new_request(OOM_IN_DEPTH,
+                               OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED,
                                get_root_memcg_info()->threshold_leave_mb,
                                lowmem_get_num_max_victims(), medium_cb);
        }

diff --git a/src/resource-limiter/memory/lowmem-dbus.c b/src/resource-limiter/memory/lowmem-dbus.c
index 1719d0fd21dc90265b745cdf84ebb5001ae1d95a..deb8a63a7a6bac0df2c5e80ba072bcf9feefdc5c 100644 (file)
--- a/src/resource-limiter/memory/lowmem-dbus.c
+++ b/src/resource-limiter/memory/lowmem-dbus.c
@@ -64,8 +64,8 @@ static void lowmem_dbus_oom_set_leave_threshold(GVariant *params)
 
 static void lowmem_dbus_oom_trigger(GVariant *params)
 {
-       lowmem_trigger_reclaim(OOM_NOMEMORY_CHECK,
-                               MAX_MEMORY_CGROUP_VICTIMS, OOM_SCORE_LOW, 0);
+       lowmem_trigger_reclaim(OOM_NOMEMORY_CHECK, MAX_MEMORY_CGROUP_VICTIMS,
+                       OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED, 0);
 }
 
 static void lowmem_dbus_set_perceptible(GVariant *params)

diff --git a/src/resource-limiter/memory/lowmem.c b/src/resource-limiter/memory/lowmem.c
index f8f41eb32a93baca018e89e311e1bfab394f1514..b9883960d4f8b119d0bdc8e4094815f44a9d10b6 100644 (file)
--- a/src/resource-limiter/memory/lowmem.c
+++ b/src/resource-limiter/memory/lowmem.c
@@ -208,10 +208,10 @@ static GArray *lowmem_task_info_proc_array = NULL;
 #define LOWMEM_DESTROY_REQUEST(_ctl)           \
        g_slice_free(typeof(*(_ctl)), _ctl);    \
 
-#define LOWMEM_SET_REQUEST(c, __flags, __score, __size, __count, __cb) \
+#define LOWMEM_SET_REQUEST(c, __flags, __oom_level, __size, __count, __cb)     \
 {                                                                      \
-       (c)->flags      = __flags; (c)->score   = __score;              \
-       (c)->size_mb= __size;  (c)->count       = __count;              \
+       (c)->flags      = __flags; (c)->oom_level       = __oom_level;          \
+       (c)->size_mb= __size;  (c)->count               = __count;              \
        (c)->callback   = __cb;                                         \
 }
 
@@ -742,15 +742,16 @@ leave:
        return victim_cnt;
 }
 
-static int calculate_range_of_oom(enum oom_score score, int *min, int *max)
+static int calculate_range_of_oom(enum oom_level oom_level, int *min, int *max)
 {
-       if (score > OOM_SCORE_MAX || score < OOM_SCORE_HIGH) {
-               _E("[LMK] oom score (%d) is out of scope", score);
+       if (oom_level < OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED
+                       || oom_level > OOM_LEVEL_ALL) {
+               _E("[LMK] oom level (%d) is out of scope", oom_level);
                return RESOURCED_ERROR_FAIL;
        }
 
-       *max = cgroup_get_highest_oom_score_adj(score);
-       *min = cgroup_get_lowest_oom_score_adj(score);
+       *max = cgroup_get_highest_oom_score_adj(oom_level);
+       *min = cgroup_get_lowest_oom_score_adj(oom_level);
 
        return RESOURCED_ERROR_NONE;
 }
@@ -765,7 +766,7 @@ static void lowmem_handle_request(struct lowmem_control *ctl)
        unsigned int total_size_mb = 0;
        unsigned int current_size = 0;
        unsigned int reclaim_size_mb, shortfall_mb = 0;
-       enum oom_score oom_score = ctl->score;
+       enum oom_level oom_level = ctl->oom_level;
 
        available_mb = proc_get_mem_available();
        reclaim_size_mb = ctl->size_mb  > available_mb                  /* MB */
@@ -778,7 +779,7 @@ static void lowmem_handle_request(struct lowmem_control *ctl)
 
 retry:
        /* Prepare LMK to start doing it's job. Check preconditions. */
-       if (calculate_range_of_oom(oom_score, &start_oom, &end_oom))
+       if (calculate_range_of_oom(oom_level, &start_oom, &end_oom))
                goto done;
 
        lmk_start_threshold_mb = get_root_memcg_info()->threshold_mb[MEM_LEVEL_OOM];
@@ -822,19 +823,21 @@ retry:
                   (Make sluggish or kill same victims continuously)
                   Thus, otherwise, just return in first operation and wait some period.
         */
-       if (oom_score == OOM_SCORE_LOW) {
-               oom_score = OOM_SCORE_MEDIUM;
+       if (oom_level == OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED) {
+               oom_level = OOM_LEVEL_BACKGROUND_MOST_RECENTLY_USED;
                goto retry;
-       } else if ((oom_score == OOM_SCORE_MEDIUM) && (ctl->flags & OOM_IN_DEPTH)) {
-               oom_score = OOM_SCORE_HIGH;
+       } else if ((oom_level == OOM_LEVEL_BACKGROUND_MOST_RECENTLY_USED)
+                       && (ctl->flags & OOM_IN_DEPTH)) {
+               oom_level = OOM_LEVEL_FOREGROUND_AND_PROC;
                if(ctl->flags & OOM_FORCE)
                        max_victim_cnt = FOREGROUND_VICTIMS;
                goto retry;
-       } else if ((oom_score == OOM_SCORE_HIGH) && (ctl->flags & OOM_IN_DEPTH)) {
+       } else if ((oom_level == OOM_LEVEL_FOREGROUND_AND_PROC)
+                       && (ctl->flags & OOM_IN_DEPTH)) {
                status = LOWMEM_RECLAIM_RETRY;
-               ctl->score = OOM_SCORE_MAX;
+               ctl->oom_level = OOM_LEVEL_ALL;
        }
-       else if (oom_score == OOM_SCORE_MAX) {
+       else if (oom_level == OOM_LEVEL_ALL) {
                status = LOWMEM_RECLAIM_RETRY;
        }
 done:
@@ -960,7 +963,8 @@ void lowmem_trigger_swap(pid_t pid, char *path, bool move)
                        return;
                }
 
-               lowest_oom_score_adj = cgroup_get_lowest_oom_score_adj(OOM_SCORE_LOW);
+               lowest_oom_score_adj = cgroup_get_lowest_oom_score_adj(
+                               OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED);
 
                if (oom_score_adj < lowest_oom_score_adj) {
                        oom_score_adj = lowest_oom_score_adj;
@@ -1158,7 +1162,7 @@ static void lowmem_force_reclaim_cb(struct lowmem_control *ctl)
        lowmem_change_memory_state(MEM_LEVEL_HIGH, 0);
 }
 
-int lowmem_trigger_reclaim(int flags, int victims, enum oom_score score, int threshold_mb)
+int lowmem_trigger_reclaim(int flags, int victims, enum oom_level oom_level, int threshold_mb)
 {
        struct lowmem_control *ctl = LOWMEM_NEW_REQUEST();
 
@@ -1167,19 +1171,20 @@ int lowmem_trigger_reclaim(int flags, int victims, enum oom_score score, int thr
 
        flags |= OOM_FORCE | OOM_IN_DEPTH | OOM_SINGLE_SHOT;
        victims = victims > 0 ? victims : MAX_MEMORY_CGROUP_VICTIMS;
-       score = score > 0 ? score : OOM_SCORE_LOW;
+       oom_level = oom_level > OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED ?
+               oom_level : OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED;
        threshold_mb = threshold_mb > 0 ? threshold_mb : get_root_memcg_info()->threshold_leave_mb;
 
        lowmem_change_memory_state(MEM_LEVEL_CRITICAL, 1);
        LOWMEM_SET_REQUEST(ctl, flags,
-               score, threshold_mb, victims,
+               oom_level, threshold_mb, victims,
                lowmem_force_reclaim_cb);
        lowmem_queue_request(&lmw, ctl);
 
        return 0;
 }
 
-int lowmem_queue_new_request(unsigned int flags, enum oom_score score,
+int lowmem_queue_new_request(unsigned int flags, enum oom_level oom_level,
                                unsigned int size_mb, unsigned int count,
                                void (*callback)(struct lowmem_control *))
 {
@@ -1189,7 +1194,7 @@ int lowmem_queue_new_request(unsigned int flags, enum oom_score score,
                return RESOURCED_ERROR_OUT_OF_MEMORY;
 
        ctl->flags      = flags;
-       ctl->score      = score;
+       ctl->oom_level  = oom_level;
        ctl->size_mb    = size_mb;
        ctl->count      = count;
        ctl->callback   = callback;
@@ -1199,7 +1204,7 @@ int lowmem_queue_new_request(unsigned int flags, enum oom_score score,
        return RESOURCED_ERROR_NONE;
 }
 
-void lowmem_trigger_swap_reclaim(enum oom_score score, unsigned long long swap_size_bytes)
+void lowmem_trigger_swap_reclaim(enum oom_level oom_level, unsigned long long swap_size_bytes)
 {
        int size_mb, victims;
 
@@ -1207,7 +1212,7 @@ void lowmem_trigger_swap_reclaim(enum oom_score score, unsigned long long swap_s
                                 ? MAX_PROACTIVE_HIGH_VICTIMS : num_max_victims;
 
        size_mb = get_root_memcg_info()->threshold_leave_mb + BYTE_TO_MBYTE(swap_size_bytes);
-       lowmem_trigger_reclaim(0, victims, score, size_mb);
+       lowmem_trigger_reclaim(0, victims, oom_level, size_mb);
 }
 
 bool lowmem_fragmentated(void)
@@ -1276,7 +1281,8 @@ static void lowmem_proactive_oom_killer(int flags, char *appid)
 
                _D("history based proactive LMK : avg rss %u, available %u required = %u MB",
                        rss_mb, before_mb, size_mb);
-               lowmem_trigger_reclaim(0, victims, OOM_SCORE_LOW, size_mb);
+               lowmem_trigger_reclaim(0, victims,
+                               OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED, size_mb);
 
                return;
        }
@@ -1308,7 +1314,9 @@ reclaim:
         */
        _D("Run threshold based proactive LMK: memory level to reach: %u MB\n",
                proactive_leave_mb + THRESHOLD_MARGIN);
-       lowmem_trigger_reclaim(0, victims, OOM_SCORE_LOW, proactive_leave_mb + THRESHOLD_MARGIN);
+       lowmem_trigger_reclaim(0,
+                       victims, OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED,
+                       proactive_leave_mb + THRESHOLD_MARGIN);
 }
 
 unsigned int lowmem_get_proactive_thres(void)

diff --git a/src/resource-limiter/memory/lowmem.h b/src/resource-limiter/memory/lowmem.h
index d853241967f3ae79f35a2bff2c36176c2144c6b6..ea54103999232a6ad4e0ac1541ab1be01174a91d 100644 (file)
--- a/src/resource-limiter/memory/lowmem.h
+++ b/src/resource-limiter/memory/lowmem.h
@@ -41,8 +41,8 @@ extern "C" {
 
 unsigned int lowmem_get_task_mem_usage_rss(const struct task_info *tsk);
 void lowmem_trigger_swap(pid_t pid, char *path, bool move);
-int lowmem_trigger_reclaim(int flags, int victims, enum oom_score score, int threshold);
-void lowmem_trigger_swap_reclaim(enum oom_score score, unsigned long long swap_size_bytes);
+int lowmem_trigger_reclaim(int flags, int victims, enum oom_level oom_level, int threshold);
+void lowmem_trigger_swap_reclaim(enum oom_level oom_level, unsigned long long swap_size_bytes);
 bool lowmem_fragmentated(void);
 unsigned int lowmem_get_proactive_thres(void);
 void lowmem_change_memory_state(int state, int force);
@@ -116,8 +116,8 @@ struct lowmem_control {
         */
        /* Processing flags*/
        unsigned int flags;
-       /* Indictator for OOM score of targeted processes */
-       enum oom_score score;
+       /* Indictator for OOM level of targeted processes */
+       enum oom_level oom_level;
 
        /* Desired size to be restored - level to be reached (MB)*/
        unsigned int size_mb;
@@ -133,7 +133,7 @@ struct lowmem_control {
 };
 
 int lowmem_worker_is_running();
-int lowmem_queue_new_request(unsigned int flags, enum oom_score score,
+int lowmem_queue_new_request(unsigned int flags, enum oom_level oom_level,
                                unsigned int size_mb, unsigned int count,
                                void (*callback) (struct lowmem_control *));
 void lowmem_set_oom_popup(bool popup);

diff --git a/src/resource-optimizer/memory/swap/fileswap.c b/src/resource-optimizer/memory/swap/fileswap.c
index 9b8d5c9c8cf4f5e5de2fc92a9ce46666ce96aff8..8d5325d6a621cfb6d7781af6bcad85b21963e19d 100644 (file)
--- a/src/resource-optimizer/memory/swap/fileswap.c
+++ b/src/resource-optimizer/memory/swap/fileswap.c
@@ -91,9 +91,9 @@ static int swap_file_reclaim(void *data)
         * It means that there are many background processes or
         * some process makes memory leak.
         * So, it requires to trigger proactive oom killer
-        * with OOM_SCORE_MAX.
+        * with OOM_LEVEL_ALL.
         */
-       lowmem_trigger_swap_reclaim(OOM_SCORE_MAX, swap_size);
+       lowmem_trigger_swap_reclaim(OOM_LEVEL_ALL, swap_size);
        return -ENOSPC;
 }
 

diff --git a/src/resource-optimizer/memory/swap/swap.c b/src/resource-optimizer/memory/swap/swap.c
index 1d0d0cd1797b1df7fee9a9f46d0f0a071b0b20ea..2b74f43e1ee734a295d9565e0d1cd83decdff70e 100644 (file)
--- a/src/resource-optimizer/memory/swap/swap.c
+++ b/src/resource-optimizer/memory/swap/swap.c
@@ -180,7 +180,7 @@ static inline void swap_add_bundle(struct swap_thread_bundle *bundle)
        pthread_mutex_unlock(&swap_thread_queue.lock);
 }
 
-static int swap_move_to_cgroup_by_pid(enum oom_score score, pid_t pid)
+static int swap_move_to_cgroup_by_pid(enum oom_level oom_level, pid_t pid)
 {
        int error;
        int oom_score_adj;
@@ -194,7 +194,7 @@ static int swap_move_to_cgroup_by_pid(enum oom_score score, pid_t pid)
                return RESOURCED_ERROR_FAIL;
        }
 
-       lowest_oom_score_adj = cgroup_get_lowest_oom_score_adj(score);
+       lowest_oom_score_adj = cgroup_get_lowest_oom_score_adj(oom_level);
 
        if (oom_score_adj < lowest_oom_score_adj)
                oom_score_adj = lowest_oom_score_adj;
@@ -848,7 +848,7 @@ static void swap_start_pid_dbus_signal_handler(GVariant *params)
        cgroup_swap = get_cgroup_tree(MEMCG_THROTTLING);
        if (!cgroup_swap)
                return;
-       swap_move_to_cgroup_by_pid(OOM_SCORE_LOW, pid);
+       swap_move_to_cgroup_by_pid(OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED, pid);
        swap_start_handler(cgroup_swap->memcg_info->name);
        _I("[SWAP] swap cgroup entered : pid : %d", (int)pid);
 }

diff --git a/src/resource-optimizer/memory/swap/zramswap.c b/src/resource-optimizer/memory/swap/zramswap.c
index a2000fcc472eddc71cf3ff39b03e3b6209fb10e7..af0c46d145b6194040e954608955b34cd665d941 100644 (file)
--- a/src/resource-optimizer/memory/swap/zramswap.c
+++ b/src/resource-optimizer/memory/swap/zramswap.c
@@ -188,7 +188,7 @@ static int swap_zram_reclaim(void *data)
         */
        if (lowmem_fragmentated()) {
                if (zram_compact) {
-                       lowmem_trigger_swap_reclaim(OOM_SCORE_MAX, zram_control.zram_reclaim_bytes);
+                       lowmem_trigger_swap_reclaim(OOM_LEVEL_ALL, zram_control.zram_reclaim_bytes);
                        zram_compact = false;
                } else {
                        swap_zram_compact();
@@ -229,9 +229,9 @@ static int swap_zram_reclaim(void *data)
                return r;
        swapcg_usage_ratio = (float)(swap_usage_bytes / (swap_total_bytes - swap_available_bytes) *100);
        if (swapcg_usage_ratio > SWAPCG_CHECK_RATIO)
-               score = OOM_SCORE_LOW;
+               score = OOM_LEVEL_BACKGROUND_LEAST_RECENTLY_USED;
        else
-               score = OOM_SCORE_MAX;
+               score = OOM_LEVEL_ALL;
 
        lowmem_trigger_swap_reclaim(score, zram_control.zram_reclaim_bytes);
        zram_compact = false;

diff --git a/src/resource-optimizer/memory/swap/zswap.c b/src/resource-optimizer/memory/swap/zswap.c
index f6b0e5942d4f067fde0f3d4600a4eaad89a37f7f..1451ba8ff34ac027e172d18db6347a090131c485 100644 (file)
--- a/src/resource-optimizer/memory/swap/zswap.c
+++ b/src/resource-optimizer/memory/swap/zswap.c
@@ -107,7 +107,7 @@ static int swap_zswap_reclaim(void *data)
         * So, it requires to trigger proactive oom killer.
         */
 
-       lowmem_trigger_swap_reclaim(OOM_SCORE_MAX, swap_size_bytes);
+       lowmem_trigger_swap_reclaim(OOM_LEVEL_ALL, swap_size_bytes);
        return -ENOSPC;
 }