#define RELEASE_AGENT "release_agent"
#define NOTIFY_ON_RELEASE "notify_on_release"
+
#define MAKE_NAME(name) CGROUP_##name##_NAME
#define cgroup_name_cpy(dst, src, length) \
do { \
} \
} while(0)
+/*
+ * This structure has full hierarchy of cgroups on running system.
+ * It is exported through lowmem-handler.h file.
+ **/
+static struct cgroup cgroup_tree[CGROUP_END] = {
+ {"/", CGROUP_TOP, CGROUP_DEFAULT_USE_HIERARCHY, NULL, NULL},
+ {CGROUP_VIP_NAME, CGROUP_ROOT, CGROUP_DEFAULT_USE_HIERARCHY, NULL, NULL},
+ {CGROUP_HIGH_NAME, CGROUP_VIP, CGROUP_DEFAULT_USE_HIERARCHY, NULL, NULL},
+ {CGROUP_MEDIUM_NAME, CGROUP_HIGH, CGROUP_DEFAULT_USE_HIERARCHY, NULL, NULL},
+ {CGROUP_LOW_NAME, CGROUP_MEDIUM, CGROUP_DEFAULT_USE_HIERARCHY, NULL, NULL},
+};
+
+//static struct cgroup **cgroup_tree;
+
+/*static void cgroup_init(struct cgroup *cgroup)
+{
+ cgroup->use_hierarchy = MEMCG_DEFAULT_USE_HIERARCHY;
+ cgroup->memcg_info = NULL;
+ cgroup->cgroups = NULL;
+}*/
+
+struct cgroup *get_cgroup_tree(int idx)
+{
+ if(idx < CGROUP_ROOT || idx >= CGROUP_END) {
+ _E("(%d) cgroup tree is NULL", idx);
+ return NULL;
+ }
+ else
+ return &cgroup_tree[idx];
+}
+
+void set_memcg_info(int idx, struct memcg_info *mi)
+{
+ if(idx < CGROUP_ROOT || idx >= CGROUP_END) {
+ _E("(%d) index is out of scope", idx);
+ }
+ else
+ cgroup_tree[idx].memcg_info = mi;
+}
+
+struct memcg_info *get_memcg_info(int idx)
+{
+ if(idx < CGROUP_ROOT || idx >= CGROUP_END) {
+ _E("(%d) cgroup tree's memcg info is NULL", idx);
+ return NULL;
+ }
+ else
+ return cgroup_tree[idx].memcg_info;
+}
+
+GSList *get_child_cgroups(int idx)
+{
+ if(idx < CGROUP_ROOT || idx >= CGROUP_END) {
+ _E("(%d) cgroup tree's child is NULL", idx);
+ return NULL;
+ }
+ else
+ return cgroup_tree[idx].child_cgroups;
+}
+
+int get_parent_cgroup(int idx)
+{
+ if(idx < CGROUP_ROOT || idx >= CGROUP_END) {
+ _E("(%d) cgroup range is out of scope", idx);
+ return CGROUP_TOP;
+ }
+ else {
+ return cgroup_tree[idx].parent_cgroup;
+ }
+}
+
+void set_use_hierarchy(int idx, bool use_hierarchy)
+{
+ if(idx < CGROUP_ROOT || idx >= CGROUP_END) {
+ _E("(%d) cgroup range is out of scope", idx);
+ }
+ else {
+ cgroup_tree[idx].use_hierarchy = use_hierarchy;
+ }
+}
+
+bool get_use_hierarchy(int idx)
+{
+ if(idx < CGROUP_ROOT || idx >= CGROUP_END) {
+ _E("(%d) cgroup range is out of scope", idx);
+ return CGROUP_DEFAULT_USE_HIERARCHY;
+ }
+ else {
+ return cgroup_tree[idx].use_hierarchy;
+ }
+}
+
static bool cgroup_is_exists(const char *cgroup_full_path)
{
struct stat stat_buf;
return 0;
}
-static void cgroup_memory_stat_init(struct cgroup_memory_stat *mem_stat, long long val)
-{
- enum cgroup_memory_stat_id id;
-
- assert(mem_stat);
-
- for (id = 0; id < CGROUP_MEMORY_STAT_MAX; id++)
- mem_stat->value[id] = val;
-}
-
-int cgroup_get_memory_stat(const char *name, struct cgroup_memory_stat **mem_stat)
-{
- _cleanup_fclose_ FILE *f = NULL;
- struct cgroup_memory_stat *st;
- char p[PATH_MAX] = "";
- char buf[LINE_MAX];
- const char *memory_stat = "memory.stat";
- const int memory_stat_len = strlen(memory_stat);
-
- if (name) {
- int l;
- int name_len = strlen(name);
-
- if (strneq(name, MEMCG_PATH, strlen(MEMCG_PATH)))
- l = snprintf(p, PATH_MAX, "%s", name);
- else
- l = snprintf(p, PATH_MAX, "%s%s%s",
- MEMCG_PATH,
- name[0] != '/' ? "/" : "",
- name);
-
- if (name_len >= memory_stat_len &&
- memcmp(name + name_len - memory_stat_len, memory_stat, memory_stat_len))
- snprintf(p + l, PATH_MAX - l, "%s%s",
- p[l - 1] != '/' ? "/" : "",
- memory_stat);
- } else
- snprintf(p, PATH_MAX, "%s/%s", MEMCG_PATH, memory_stat);
-
- f = fopen(p, "re");
- if (!f)
- return -errno;
-
- st = (struct cgroup_memory_stat *)malloc(sizeof(struct cgroup_memory_stat));
- if (!st)
- return -ENOMEM;
-
- cgroup_memory_stat_init(st, -1);
-
- for (;;) {
- enum cgroup_memory_stat_id id;
- size_t l;
-
- if (!fgets(buf, sizeof(buf), f)) {
- if (ferror(f)) {
- free(st);
- return -errno;
- }
- break;
- }
-
- l = strcspn(buf, " ");
- if (!l)
- break;
-
- buf[l] = 0;
-
- id = cgroup_memory_stat_string_to_id(buf);
- if (id < 0 || id >= CGROUP_MEMORY_STAT_MAX)
- continue;
-
- st->value[id] = atoll(buf + l + 1);
- }
-
- *mem_stat = st;
-
- return 0;
-}
-
/*
* Usage example:
* int i;
#include <sys/types.h>
#include <stdint.h>
#include <glib.h>
+#include "const.h"
#include "macro.h"
/*
#define CGROUP_PER_PROCESS_NAME ""
#define CGROUP_GROUP_NAME ""
+#define CGROUP_DEFAULT_USE_HIERARCHY false
+/*
+ * [cgroup information]
+ * CGROUP_ROOT : root cgroup
+ * CGROUP_VIP : cgroup for vip apps(or daemons)
+ * CGROUP_HIGH : cgroup for foreground apps
+ * CGROUP_MEDIUM : cgroup for background apps
+ * CGROUP_LOW : cgroup for apps of the lowest privilege
+ *
+ * [cgroup hierarchy]
+ * (normal mode)
+ root(cpu, memory, io)
+ * ├─high─(tizendocker)
+ * │ └─medium
+ * │ └─low
+ * └─system.slice/user.slice (not controlled by resourced)
+ *
+ * (vip mode)
+ root(cpu, memory, io)
+ * │
+ * vip
+ * ├─high─(tizendocker)
+ * │ └─medium
+ * │ └─low
+ * └─system.slice/user.slice (not controlled by resourced)
+ */
enum cgroup_type {
CGROUP_TOP = -1,
CGROUP_ROOT,
CGROUP_END,
};
+struct cgroup {
+ /* hashname of memory cgroup for restoring memcg info*/
+ char hashname[MAX_NAME_LENGTH];
+ /* parent cgroup index */
+ int parent_cgroup;
+ /* set when using multiple sub cgroups */
+ bool use_hierarchy;
+ /* memory cgroup information */
+ struct memcg_info *memcg_info;
+ /* list of child cgroups when using multi groups */
+ GSList *child_cgroups;
+};
+
/**
* @desc Get one unsigned int32 value from cgroup
* @param cgroup_name - cgroup path
*/
int cgroup_get_pids(const char *name, GArray **pids);
+
+struct cgroup *get_cgroup_tree(int idx);
+void set_memcg_info(int idx, struct memcg_info *mi);
+struct memcg_info *get_memcg_info(int idx);
+GSList *get_child_cgroups(int idx);
+int get_parent_cgroup(int idx);
+void set_use_hierarchy(int idx, bool use_hierarchy);
+bool get_use_hierarchy(int idx);
+
+//void cgroup_params_exit(void);
+void cgroup_params_init(void);
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
--- /dev/null
+/*
+ * resourced
+ *
+ * Copyright (c) 2014 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 memcontrol.c
+ *
+ * @desc structure and operation for memory cgroups
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/eventfd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "resourced.h"
+#include "trace.h"
+#include "macro.h"
+#include "memory-cgroup.h"
+#include "cgroup.h"
+#include "module.h"
+#include "util.h"
+
+#include <stdlib.h>
+
+#define BUF_MAX 1023
+#define MEMCG_NO_LIMIT 0
+
+static int default_swappiness = -1;
+
+/*
+ * Special node that point's to /sys/fs/cgroup/memory - root of memcg group.
+ * This is the same as memcg_tree[CGROUP_ROOT]->info.
+ */
+static struct memcg_info *memcg_root;
+
+static struct memcg_info gmemcg_info[CGROUP_END] = {
+ {MEMCG_PATH,},
+ {MEMCG_VIP_PATH,},
+ {MEMCG_HIGH_PATH,},
+ {MEMCG_MEDIUM_PATH,},
+ {MEMCG_LOW_PATH,},
+};
+
+static int memcg_write_params_info(struct memcg_info *mi)
+{
+ unsigned int limit = mi->limit;
+ const char *name = mi->name;
+ int ret = RESOURCED_ERROR_NONE;
+ int swappiness = -1;
+ _I("write memcg param for %s", name);
+ /* enable cgroup move */
+ ret = cgroup_write_node_uint32(name,
+ MEMCG_MOVE_CHARGE, 3);
+ if (ret)
+ return ret;
+
+ /*
+ * write swapness if it has a meaningful value.
+ * if it has own swappiness value, set it to memcg at first.
+ * otherwise, check default_swappiness value and use it.
+ */
+ if (mi->swappiness >= 0)
+ swappiness = mi->swappiness;
+ else if (default_swappiness >= 0)
+ swappiness = default_swappiness;
+
+ if (swappiness >= 0) {
+ ret = cgroup_write_node_uint32(name,
+ MEMCG_SWAPPINESS, swappiness);
+ if (ret)
+ _I("failed to write %s %d to %s the",
+ MEMCG_SWAPPINESS, swappiness, name);
+ }
+
+ if (mi->limit_ratio == MEMCG_NO_LIMIT)
+ return ret;
+
+ /* write limit_in_bytes */
+ ret = cgroup_write_node_uint32(name,
+ MEMCG_LIMIT_BYTE, limit);
+ _I("set %s's limit to %u", name, limit);
+ return ret;
+}
+
+int memcg_write_params(void)
+{
+ unsigned int i;
+
+ for (i = CGROUP_ROOT; i < CGROUP_END; i++) {
+// struct memcg_info *mi = memcg_tree[i]->info;
+ struct memcg_info *mi = get_memcg_info(i);
+ memcg_write_params_info(mi);
+ }
+
+ return RESOURCED_ERROR_NONE;
+}
+
+void memcg_set_threshold(int type, int level, int value)
+{
+// cgroup_tree[type]->memcg_info->threshold[level] = value;
+ struct memcg_info *mi = get_memcg_info(type);
+ if(!mi)
+ _E("memory cgroup of %d is NULL", type);
+ else
+ mi->threshold[level] = value;
+}
+
+void memcg_set_leave_threshold(int type, int value)
+{
+ struct memcg_info *mi = get_memcg_info(type);
+ if(!mi)
+ _E("memory cgroup of %d is NULL", type);
+ else
+ mi->threshold_leave = value;
+
+// cgroup_tree[type]->memcg_info->threshold_leave = value;
+}
+
+void memcg_info_set_limit(struct memcg_info *mi, float ratio,
+ unsigned int totalram)
+{
+ if (!mi)
+ return;
+
+ 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_leave = (float)mi->limit * MEMCG_FOREGROUND_LEAVE_RATIO;
+ mi->oomleave = mi->limit - mi->threshold_leave;
+}
+
+void memcg_set_default_swappiness(int swappiness)
+{
+ default_swappiness = swappiness;
+}
+
+void memcg_info_set_swappiness(struct memcg_info *mi, int swappiness)
+{
+ if (!mi)
+ return;
+
+ mi->swappiness = swappiness;
+}
+
+static void memcg_memory_stat_init(struct cgroup_memory_stat *mem_stat, long long val)
+{
+ enum cgroup_memory_stat_id id;
+
+ assert(mem_stat);
+
+ for (id = 0; id < CGROUP_MEMORY_STAT_MAX; id++)
+ mem_stat->value[id] = val;
+}
+
+int memcg_get_memory_stat(const char *name, struct cgroup_memory_stat **mem_stat)
+{
+ _cleanup_fclose_ FILE *f = NULL;
+ struct cgroup_memory_stat *st;
+ char p[PATH_MAX] = "";
+ char buf[LINE_MAX];
+ const char *memory_stat = "memory.stat";
+ const int memory_stat_len = strlen(memory_stat);
+
+ if (name) {
+ int l;
+ int name_len = strlen(name);
+
+ if (strneq(name, MEMCG_PATH, strlen(MEMCG_PATH)))
+ l = snprintf(p, PATH_MAX, "%s", name);
+ else
+ l = snprintf(p, PATH_MAX, "%s%s%s",
+ MEMCG_PATH,
+ name[0] != '/' ? "/" : "",
+ name);
+
+ if (name_len >= memory_stat_len &&
+ memcmp(name + name_len - memory_stat_len, memory_stat, memory_stat_len))
+ snprintf(p + l, PATH_MAX - l, "%s%s",
+ p[l - 1] != '/' ? "/" : "",
+ memory_stat);
+ } else
+ snprintf(p, PATH_MAX, "%s/%s", MEMCG_PATH, memory_stat);
+
+ f = fopen(p, "re");
+ if (!f)
+ return -errno;
+
+ st = (struct cgroup_memory_stat *)malloc(sizeof(struct cgroup_memory_stat));
+ if (!st)
+ return -ENOMEM;
+
+ memcg_memory_stat_init(st, -1);
+
+ for (;;) {
+ enum cgroup_memory_stat_id id;
+ size_t l;
+
+ if (!fgets(buf, sizeof(buf), f)) {
+ if (ferror(f)) {
+ free(st);
+ return -errno;
+ }
+ break;
+ }
+
+ l = strcspn(buf, " ");
+ if (!l)
+ break;
+
+ buf[l] = 0;
+
+ id = cgroup_memory_stat_string_to_id(buf);
+ if (id < 0 || id >= CGROUP_MEMORY_STAT_MAX)
+ continue;
+
+ st->value[id] = atoll(buf + l + 1);
+ }
+
+ *mem_stat = st;
+
+ return 0;
+}
+
+/*void memcg_init(struct memcg *memcg)
+{
+ memcg->use_hierarchy = MEMCG_DEFAULT_USE_HIERARCHY;
+ memcg->info = NULL;
+ memcg->cgroups = NULL;
+}*/
+
+int memcg_get_anon_usage(char *memcg, unsigned int *anon_usage)
+{
+ int r;
+ _cleanup_free_ struct cgroup_memory_stat *mem_stat = NULL;
+
+ r = memcg_get_memory_stat(memcg, &mem_stat);
+ if (r) {
+ _D("fail to get memory status : %s", memcg);
+ return r;
+ }
+
+ *anon_usage = mem_stat->value[CGROUP_MEMORY_STAT_INACTIVE_ANON] +
+ mem_stat->value[CGROUP_MEMORY_STAT_ACTIVE_ANON];
+ return 0;
+}
+
+int memcg_get_swap_usage(char *memcg, unsigned int *usage)
+{
+ int r;
+ _cleanup_free_ struct cgroup_memory_stat *mem_stat = NULL;
+
+ r = memcg_get_memory_stat(memcg, &mem_stat);
+ if (r) {
+ _D("fail to get memory status : %s", memcg);
+ return r;
+ }
+
+ *usage = mem_stat->value[CGROUP_MEMORY_STAT_SWAP];
+ return 0;
+}
+
+/*
+ * From memory.txt kernel document,
+ * To register a event for memcg, an application must:
+ * - create an eventfd using eventfd(2);
+ * - open a node of memory cgroup
+ * - write string like "<event_fd> <opened fd> <value>" to cgroup.event_control
+ *
+ * Current memory cgroup supports eventfd about only
+ * usage_in_byte, oom_control and pressure_level.
+ */
+int memcg_set_eventfd(const char *memcg, const char *event, char *value)
+{
+ _cleanup_close_ int mcgfd = -1;
+ _cleanup_close_ int cgfd = -1;
+ int evfd, res = 0, sz, ret = -1;
+ char buf[PATH_MAX] = {0,};
+
+ /* create an eventfd using eventfd(2)*/
+ evfd = eventfd(0, 0);
+ ret = fcntl(evfd, F_SETFL, O_NONBLOCK);
+ if (ret < 0)
+ return RESOURCED_ERROR_FAIL;
+
+ /* open a node of memory cgroup */
+ snprintf(buf, PATH_MAX, "%s/%s", memcg, MEMCG_EVENTFD_CONTROL);
+ cgfd = open(buf, O_WRONLY);
+ if (cgfd < 0) {
+ const int saved_errno = errno;
+ _E("open event_control failed");
+ errno = saved_errno;
+ return RESOURCED_ERROR_FAIL;
+ }
+
+ snprintf(buf, PATH_MAX, "%s/%s", memcg, event);
+ mcgfd = open(buf, O_RDONLY);
+ if (mcgfd < 0) {
+ const int saved_errno = errno;
+ _E("open memory control failed");
+ errno = saved_errno;
+ return RESOURCED_ERROR_FAIL;
+ }
+
+ _D("%s %s %s registerd", memcg, event, value);
+ /* write string like "<event_fd> <opened fd> <value>" to cgroup.event_control */
+ sz = snprintf(buf, PATH_MAX, "%d %d %s", evfd, mcgfd, value);
+ sz += 1;
+ res = write(cgfd, buf, sz);
+ if (res != sz) {
+ int saved_errno = errno;
+ _E("write cgfd failed : %d", res);
+ errno = saved_errno;
+ return RESOURCED_ERROR_FAIL;
+ }
+ return evfd;
+}
+
+struct memcg_info *get_root_memcg_info(void)
+{
+ return memcg_root;
+}
+
+/*void memcg_params_exit(void)
+{
+ for (int i = CGROUP_ROOT; i < CGROUP_END; i++) {
+ g_slist_free_full(cgroup_tree[i].cgroups, free);
+ free(cgroup_tree[i]);
+ }
+ free(cgroup_tree);
+}*/
+
+void memcg_params_init(void)
+{
+ int idx = 0;
+ GSList *child_cgroups;
+
+/* cgroup_tree = (struct cgroup **)malloc(sizeof(struct cgroup *) * CGROUP_END);
+ assert(cgroup_tree);*/
+
+ for (idx = CGROUP_ROOT; idx < CGROUP_END; idx++) {
+ struct memcg_info *mi = &gmemcg_info[idx];
+/* cgroup_tree[idx] = (struct cgroup *)malloc(sizeof(struct cgroup));
+ assert(cgroup_tree[idx]);*/
+
+// cgroup_init(cgroup_tree[idx]);
+ set_memcg_info(idx, mi);
+ if(idx == CGROUP_ROOT)
+ memcg_root = mi;
+ else {
+ int parent_idx = get_parent_cgroup(idx);
+ child_cgroups = get_child_cgroups(parent_idx);
+ child_cgroups = g_slist_prepend(child_cgroups, get_cgroup_tree(idx));
+ set_use_hierarchy(parent_idx, true);
+ }
+
+// cgroup_tree[idx]->memcg_info = mi;
+ _I("init memory cgroup for %s", mi->name);
+/* if (mi->parent_memcg == CGROUP_TOP) {
+ memcg_root = cgroup_tree[idx]->memcg_info;
+ } else {
+ int parent_idx = mi->parent_memcg;
+ cgroups = cgroup_tree[parent_idx]->cgroups;
+ cgroups = g_slist_prepend(cgroups, mi);
+ cgroup_tree[parent_idx]->use_hierarchy = true;
+ }*/
+ }
+}
/* number of memory cgroups */
#define MEMCG_DEFAULT_EVENT_LEVEL "low"
-#define MEMCG_DEFAULT_USE_HIERARCHY 0
#define MEMCG_LOW_RATIO 0.8
#define MEMCG_MEDIUM_RATIO 0.96
#define MEMCG_FOREGROUND_LEAVE_RATIO 0.25
+#define MEMCG_PATH CGROUP_PATH "/memory"
+#define MEMCG_VIP_PATH MEMCG_PATH "/" CGROUP_VIP_NAME
+#define MEMCG_HIGH_PATH MEMCG_PATH "/" CGROUP_VIP_NAME "/" CGROUP_HIGH_NAME
+#define MEMCG_MEDIUM_PATH MEMCG_PATH "/" CGROUP_VIP_NAME "/" CGROUP_HIGH_NAME "/" CGROUP_MEDIUM_NAME
+#define MEMCG_LOW_PATH MEMCG_PATH "/" CGROUP_VIP_NAME "/" CGROUP_HIGH_NAME "/" CGROUP_MEDIUM_NAME "/" CGROUP_LOW_NAME
-#define MEMCG_PATH CGROUP_PATH"/memory"
-#define MEMCG_APPS_PATH MEMCG_PATH"/Apps"
+/*#define MEMCG_APPS_PATH MEMCG_PATH"/Apps"
#define MEMCG_BGLOCKED_PATH MEMCG_PATH"/Apps/BgLocked"
-#define MEMCG_MEMLIMIT_PATH MEMCG_PATH"/MemLimit"
-#define MEMCG_SWAP_PATH MEMCG_PATH"/Swap"
+#define MEMCG_SWAP_PATH MEMCG_PATH"/Swap"*/
+
+#define MEMCG_VIP_PP_PATH MEMCG_VIP_PATH "/" CGROUP_PER_PROCESS_NAME
+#define MEMCG_VIP_GROUP_PATH MEMCG_VIP_PATH "/" CGROUP_GROUP_NAME
+
+#define MEMCG_HIGH_PP_PATH MEMCG_HIGH_PATH "/" CGROUP_PER_PROCESS_NAME
+#define MEMCG_HIGH_GROUP_PATH MEMCG_HIGH_PATH "/" CGROUP_GROUP_NAME
+
+#define MEMCG_MEDIUM_PP_PATH MEMCG_MEDIUM_PATH "/" CGROUP_PER_PROCESS_NAME
+#define MEMCG_MEDIUM_GROUP_PATH MEMCG_MEDIUM_PATH "/" CGROUP_GROUP_NAME
+
+#define MEMCG_LOW_PP_PATH MEMCG_LOW_PATH "/" CGROUP_PER_PROCESS_NAME
+#define MEMCG_LOW_GROUP_PATH MEMCG_LOW_PATH "/" CGROUP_GROUP_NAME
+
+
/*#define LOWMEM_ROOT_CGROUP "/sys/fs/cgroup/memory"
#define LOWMEM_APPS_CGROUP LOWMEM_ROOT_CGROUP"/Apps"
#define LOWMEM_BGLOCKED_CGROUP LOWMEM_ROOT_CGROUP"/Apps/BgLocked"
#define DEFAULT_MEMLOG_PATH "/var/log"
#define DEFAULT_MEMLOG_NR_MAX 50
-/*
- * [memory cgroup information]
- * MEMCG_MEMORY : root cgroup for system daemons
- * MEMCG_APPS : cgroup for general apps
- * MEMCG_BGLOCKED : cgroup for background locked and favorite apps
- * MEMCG_LIMIT : cgroup for each app with memory limit set if configuration is enabled
- * MEMCG_SWAP : cgroup for selected victims from background apps
- *
- * [memory cgroup hierarchy]
- (root)
- ├─Apps
- │ └─BgLocked
- ├─MemLimit
- ├─Swap
- └─system.slice (not controlled by resourced)
- */
-enum memcg_type {
- MEMCG_ROOT = -1,
- MEMCG_MEMORY,
- MEMCG_APPS,
- MEMCG_BGLOCKED,
- MEMCG_LIMIT,
- MEMCG_SWAP,
- MEMCG_MAX,
-};
-
enum {
LOWMEM_NORMAL,
LOWMEM_DEDUP,
CGROUP_MEMORY_STAT_INVALID = -1,
};
+
+//separate memcg_info and cgroup_info
struct memcg_info {
/* name of memory cgroup */
char name[MAX_PATH_LENGTH];
/* hashname of memory cgroup for restoring memcg info*/
- char hashname[MAX_NAME_LENGTH];
+// char hashname[MAX_NAME_LENGTH];
/* parent id */
- int parent_memcg;
+// int parent_memcg;
/* limit ratio, if don't want to set limit, use NO_LIMIT*/
float limit_ratio;
unsigned int limit;
int swappiness;
};
-struct memcg {
- /* parent cgroup */
+/*struct memcg {
+ // parent cgroup
struct memcg_info *info;
- /* set when using multiple sub cgroups */
+ // set when using multiple sub cgroups
bool use_hierarchy;
- /* list of child cgroups when using multi groups */
+ // list of child cgroups when using multi groups
GSList *cgroups;
-};
+};*/
struct lowmem_control_data {
enum lowmem_control_type control_type;
long long value[CGROUP_MEMORY_STAT_MAX];
};
+//void memcg_init(struct memcg *memcg);
+
+
+const char *cgroup_memory_stat_id_to_string(enum cgroup_memory_stat_id id);
+enum cgroup_memory_stat_id cgroup_memory_stat_string_to_id(const char *str);
+
+int memcg_write_params(void);
+
+void memcg_set_threshold(int type, int level, int value);
+void memcg_set_leave_threshold(int type, int value);
+
void memcg_info_set_limit(struct memcg_info *memcg_info, float ratio,
unsigned int totalram);
+void memcg_set_default_swappiness(int swappiness);
void memcg_info_set_swappiness(struct memcg_info *mi, int swappiness);
-void memcg_init(struct memcg *memcg);
+int memcg_get_memory_stat(const char *name, struct cgroup_memory_stat **mem_stat);
/**
* @desc get anon memory usage of cgroup based on memory.stat
*/
int memcg_set_eventfd(const char *memcg, const char *event, char *value);
-/**
- * @desc execute /usr/bin/memps and make log file with pid and process name
- */
-void make_memps_log(enum mem_log path, pid_t pid, char *victim_name);
-
-
-const char *cgroup_memory_stat_id_to_string(enum cgroup_memory_stat_id id);
-enum cgroup_memory_stat_id cgroup_memory_stat_string_to_id(const char *str);
-int cgroup_get_memory_stat(const char *name, struct cgroup_memory_stat **mem_stat);
+struct memcg_info *get_root_memcg_info(void);
+void memcg_params_init(void);
#ifdef __cplusplus
}
};
struct swap_status_msg {
- enum memcg_type type;
- struct memcg_info *info;
+ enum cgroup_type type;
+ struct memcg_info *memcg_info;
pid_t pid;
};
{
int ret_code;
- _D("resourced_cpu_init");
+ _D("resourced cpu init start");
//ret_code = cgroup_make_subdir(CPUCG_PATH, "background", NULL);
ret_code = cgroup_make_full_subdir(CPUCG_PATH);
- ret_value_msg_if(ret_code < 0, ret_code, "cpu init failed\n");
+ ret_value_msg_if(ret_code < 0, ret_code, "cpu cgroup init failed\n");
cpu_check_cpuquota();
/* if (cpu_quota_enabled()) {
ret_code = cgroup_make_subdir(CPUCG_PATH, "quota", NULL);
ret_unless(level >= 0);
ret_unless(thres >= 0);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, level, thres);
+// lowmem_memcg_set_threshold(CGROUP_ROOT, level, thres);
+ memcg_set_threshold(CGROUP_ROOT, level, thres);
}
static void lowmem_dbus_oom_set_leave_threshold(GVariant *params)
g_variant_get(params, gtype, &thres);
ret_unless(thres >= 0);
- lowmem_memcg_set_leave_threshold(MEMCG_MEMORY, thres);
+// lowmem_memcg_set_leave_threshold(CGROUP_ROOT, thres);
+ memcg_set_leave_threshold(CGROUP_ROOT, thres);
}
static void lowmem_dbus_oom_trigger(GVariant *params)
g_variant_get(params, gtype, &pid);
ret_unless(pid > 0);
- lowmem_trigger_swap(pid, MEMCG_SWAP);
+ lowmem_trigger_swap(pid, CGROUP_LOW);
}
static void lowmem_dbus_set_memlimit(GVariant *params)
int size;
};
+/**
+ * @desc execute /usr/bin/memps and make log file with pid and process name
+ */
+void make_memps_log(enum mem_log path, pid_t pid, char *victim_name);
+
void lowmem_dbus_init(void);
int lowmem_trigger_reclaim(int flags, int victims, enum lmk_type type, int threshold);
void lowmem_trigger_swap_reclaim(enum lmk_type type, int swap_size);
void lowmem_change_memory_state(int state, int force);
-void lowmem_memcg_set_threshold(int idx, int level, int value);
-void lowmem_memcg_set_leave_threshold(int idx, int value);
+//void lowmem_memcg_set_threshold(int idx, int level, int value);
+//void lowmem_memcg_set_leave_threshold(int idx, int value);
unsigned long lowmem_get_ktotalram(void);
void lowmem_trigger_swap(pid_t pid, int memcg_idx);
void lowmem_limit_init(void);
/*
* Return memcg pointer to selected cgroup.
*/
-int lowmem_get_memcg(enum memcg_type type, struct memcg **memcg_ptr);
+//int lowmem_get_memcg(enum cgroup_type type, struct memcg **memcg_ptr);
enum oom_killer_cb_flags {
OOM_NONE = 0x0, /* for main oom killer thread */
cg_dir, usage, mle->threshold);
return true;
}
- ret = cgroup_get_memory_stat(cg_dir, &mem_stat);
+ ret = memcg_get_memory_stat(cg_dir, &mem_stat);
if (ret) {
_D("fail to get memory status : %s", cg_dir);
goto remove_mle;
if (!pai->memory.use_mem_limit)
return RESOURCED_ERROR_NO_DATA;
- ret = asprintf(&path, "%s/%s", MEMCG_MEMLIMIT_PATH, pai->appid);
+ ret = asprintf(&path, "%s/%s", MEMCG_HIGH_PP_PATH, pai->appid);
if (ret < 0) {
_E("not enough memory");
return RESOURCED_ERROR_OUT_OF_MEMORY;
cgpath = appname;
}
- ret = asprintf(&path, "%s/%s", MEMCG_MEMLIMIT_PATH, cgpath);
+ ret = asprintf(&path, "%s/%s", MEMCG_HIGH_PP_PATH, cgpath);
if (ret < 0) {
_E("not enough memory");
return;
}
- ret = cgroup_make_subdir(MEMCG_MEMLIMIT_PATH, cgpath, NULL);
+ ret = cgroup_make_subdir(MEMCG_HIGH_PP_PATH, cgpath, NULL);
if (ret < 0) {
_E("Failed to create cgroup subdir '%s/%s'",
- MEMCG_MEMLIMIT_PATH, cgpath);
+ MEMCG_HIGH_PP_PATH, cgpath);
return;
}
+++ /dev/null
-/*
- * resourced
- *
- * Copyright (c) 2014 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 memcontrol.c
- *
- * @desc structure and operation for memory cgroups
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- */
-
-#include <string.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <sys/eventfd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include "resourced.h"
-#include "trace.h"
-#include "macro.h"
-#include "memory-cgroup.h"
-#include "cgroup.h"
-#include "module.h"
-#include "util.h"
-
-#include <stdlib.h>
-
-#define BUF_MAX 1023
-
-void memcg_info_set_limit(struct memcg_info *mi, float ratio,
- unsigned int totalram)
-{
- if (!mi)
- return;
-
- 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_leave = (float)mi->limit * MEMCG_FOREGROUND_LEAVE_RATIO;
- mi->oomleave = mi->limit - mi->threshold_leave;
-}
-
-void memcg_info_set_swappiness(struct memcg_info *mi, int swappiness)
-{
- if (!mi)
- return;
-
- mi->swappiness = swappiness;
-}
-
-void memcg_init(struct memcg *memcg)
-{
- memcg->use_hierarchy = MEMCG_DEFAULT_USE_HIERARCHY;
- memcg->info = NULL;
- memcg->cgroups = NULL;
-}
-
-int memcg_get_anon_usage(char *memcg, unsigned int *anon_usage)
-{
- int r;
- _cleanup_free_ struct cgroup_memory_stat *mem_stat = NULL;
-
- r = cgroup_get_memory_stat(memcg, &mem_stat);
- if (r) {
- _D("fail to get memory status : %s", memcg);
- return r;
- }
-
- *anon_usage = mem_stat->value[CGROUP_MEMORY_STAT_INACTIVE_ANON] +
- mem_stat->value[CGROUP_MEMORY_STAT_ACTIVE_ANON];
- return 0;
-}
-
-int memcg_get_swap_usage(char *memcg, unsigned int *usage)
-{
- int r;
- _cleanup_free_ struct cgroup_memory_stat *mem_stat = NULL;
-
- r = cgroup_get_memory_stat(memcg, &mem_stat);
- if (r) {
- _D("fail to get memory status : %s", memcg);
- return r;
- }
-
- *usage = mem_stat->value[CGROUP_MEMORY_STAT_SWAP];
- return 0;
-}
-
-/*
- * From memory.txt kernel document,
- * To register a event for memcg, an application must:
- * - create an eventfd using eventfd(2);
- * - open a node of memory cgroup
- * - write string like "<event_fd> <opened fd> <value>" to cgroup.event_control
- *
- * Current memory cgroup supports eventfd about only
- * usage_in_byte, oom_control and pressure_level.
- */
-int memcg_set_eventfd(const char *memcg, const char *event, char *value)
-{
- _cleanup_close_ int mcgfd = -1;
- _cleanup_close_ int cgfd = -1;
- int evfd, res = 0, sz, ret = -1;
- char buf[PATH_MAX] = {0,};
-
- /* create an eventfd using eventfd(2)*/
- evfd = eventfd(0, 0);
- ret = fcntl(evfd, F_SETFL, O_NONBLOCK);
- if (ret < 0)
- return RESOURCED_ERROR_FAIL;
-
- /* open a node of memory cgroup */
- snprintf(buf, PATH_MAX, "%s/%s", memcg, MEMCG_EVENTFD_CONTROL);
- cgfd = open(buf, O_WRONLY);
- if (cgfd < 0) {
- const int saved_errno = errno;
- _E("open event_control failed");
- errno = saved_errno;
- return RESOURCED_ERROR_FAIL;
- }
-
- snprintf(buf, PATH_MAX, "%s/%s", memcg, event);
- mcgfd = open(buf, O_RDONLY);
- if (mcgfd < 0) {
- const int saved_errno = errno;
- _E("open memory control failed");
- errno = saved_errno;
- return RESOURCED_ERROR_FAIL;
- }
-
- _D("%s %s %s registerd", memcg, event, value);
- /* write string like "<event_fd> <opened fd> <value>" to cgroup.event_control */
- sz = snprintf(buf, PATH_MAX, "%d %d %s", evfd, mcgfd, value);
- sz += 1;
- res = write(cgfd, buf, sz);
- if (res != sz) {
- int saved_errno = errno;
- _E("write cgfd failed : %d", res);
- errno = saved_errno;
- return RESOURCED_ERROR_FAIL;
- }
- return evfd;
-}
#include "safe-kill.h"
#include "dedup-common.h"
-#define LOWMEM_NO_LIMIT 0
#define LOWMEM_THRES_INIT 0
#define MEMPS_EXEC_PATH "usr/bin/memps"
/* thresholds for 64M RAM*/
#define PROACTIVE_64_THRES 10 /* MB */
#define PROACTIVE_64_LEAVE 30 /* MB */
-#define MEMCG_MEMORY_64_THRES_DEDUP 16 /* MB */
-#define MEMCG_MEMORY_64_THRES_SWAP 15 /* MB */
-#define MEMCG_MEMORY_64_THRES_LOW 8 /* MB */
-#define MEMCG_MEMORY_64_THRES_MEDIUM 5 /* MB */
-#define MEMCG_MEMORY_64_THRES_LEAVE 8 /* MB */
+#define CGROUP_ROOT_64_THRES_DEDUP 16 /* MB */
+#define CGROUP_ROOT_64_THRES_SWAP 15 /* MB */
+#define CGROUP_ROOT_64_THRES_LOW 8 /* MB */
+#define CGROUP_ROOT_64_THRES_MEDIUM 5 /* MB */
+#define CGROUP_ROOT_64_THRES_LEAVE 8 /* MB */
/* thresholds for 256M RAM */
#define PROACTIVE_256_THRES 50 /* MB */
#define PROACTIVE_256_LEAVE 80 /* MB */
-#define MEMCG_MEMORY_256_THRES_DEDUP 60 /* MB */
-#define MEMCG_MEMORY_256_THRES_SWAP 40 /* MB */
-#define MEMCG_MEMORY_256_THRES_LOW 20 /* MB */
-#define MEMCG_MEMORY_256_THRES_MEDIUM 10 /* MB */
-#define MEMCG_MEMORY_256_THRES_LEAVE 20 /* MB */
+#define CGROUP_ROOT_256_THRES_DEDUP 60 /* MB */
+#define CGROUP_ROOT_256_THRES_SWAP 40 /* MB */
+#define CGROUP_ROOT_256_THRES_LOW 20 /* MB */
+#define CGROUP_ROOT_256_THRES_MEDIUM 10 /* MB */
+#define CGROUP_ROOT_256_THRES_LEAVE 20 /* MB */
/* threshold for 448M RAM */
#define PROACTIVE_448_THRES 120 /* MB */
#define PROACTIVE_448_LEAVE 100 /* MB */
-#define MEMCG_MEMORY_448_THRES_DEDUP 60 /* MB */
-#define MEMCG_MEMORY_448_THRES_SWAP 100 /* MB */
-#define MEMCG_MEMORY_448_THRES_LOW 50 /* MB */
-#define MEMCG_MEMORY_448_THRES_MEDIUM 40 /* MB */
-#define MEMCG_MEMORY_448_THRES_LEAVE 60 /* MB */
+#define CGROUP_ROOT_448_THRES_DEDUP 60 /* MB */
+#define CGROUP_ROOT_448_THRES_SWAP 100 /* MB */
+#define CGROUP_ROOT_448_THRES_LOW 50 /* MB */
+#define CGROUP_ROOT_448_THRES_MEDIUM 40 /* MB */
+#define CGROUP_ROOT_448_THRES_LEAVE 60 /* MB */
/* threshold for 512M RAM */
#define PROACTIVE_512_THRES 80 /* MB */
#define PROACTIVE_512_LEAVE 100 /* MB */
-#define MEMCG_MEMORY_512_THRES_DEDUP 140 /* MB */
-#define MEMCG_MEMORY_512_THRES_SWAP 100 /* MB */
-#define MEMCG_MEMORY_512_THRES_LOW 50 /* MB */
-#define MEMCG_MEMORY_512_THRES_MEDIUM 40 /* MB */
-#define MEMCG_MEMORY_512_THRES_LEAVE 60 /* MB */
+#define CGROUP_ROOT_512_THRES_DEDUP 140 /* MB */
+#define CGROUP_ROOT_512_THRES_SWAP 100 /* MB */
+#define CGROUP_ROOT_512_THRES_LOW 50 /* MB */
+#define CGROUP_ROOT_512_THRES_MEDIUM 40 /* MB */
+#define CGROUP_ROOT_512_THRES_LEAVE 60 /* MB */
/* threshold for 768 RAM */
#define PROACTIVE_768_THRES 100 /* MB */
#define PROACTIVE_768_LEAVE 120 /* MB */
-#define MEMCG_MEMORY_768_THRES_DEDUP 180 /* MB */
-#define MEMCG_MEMORY_768_THRES_SWAP 150 /* MB */
-#define MEMCG_MEMORY_768_THRES_LOW 100 /* MB */
-#define MEMCG_MEMORY_768_THRES_MEDIUM 60 /* MB */
-#define MEMCG_MEMORY_768_THRES_LEAVE 100 /* MB */
+#define CGROUP_ROOT_768_THRES_DEDUP 180 /* MB */
+#define CGROUP_ROOT_768_THRES_SWAP 150 /* MB */
+#define CGROUP_ROOT_768_THRES_LOW 100 /* MB */
+#define CGROUP_ROOT_768_THRES_MEDIUM 60 /* MB */
+#define CGROUP_ROOT_768_THRES_LEAVE 100 /* MB */
/* threshold for more than 1024M RAM */
#define PROACTIVE_1024_THRES 150 /* MB */
#define PROACTIVE_1024_LEAVE 300 /* MB */
-#define MEMCG_MEMORY_1024_THRES_DEDUP 400 /* MB */
-#define MEMCG_MEMORY_1024_THRES_SWAP 300 /* MB */
-#define MEMCG_MEMORY_1024_THRES_LOW 200 /* MB */
-#define MEMCG_MEMORY_1024_THRES_MEDIUM 100 /* MB */
-#define MEMCG_MEMORY_1024_THRES_LEAVE 150 /* MB */
+#define CGROUP_ROOT_1024_THRES_DEDUP 400 /* MB */
+#define CGROUP_ROOT_1024_THRES_SWAP 300 /* MB */
+#define CGROUP_ROOT_1024_THRES_LOW 200 /* MB */
+#define CGROUP_ROOT_1024_THRES_MEDIUM 100 /* MB */
+#define CGROUP_ROOT_1024_THRES_LEAVE 150 /* MB */
/* threshold for more than 2048M RAM */
#define PROACTIVE_2048_THRES 200 /* MB */
#define PROACTIVE_2048_LEAVE 500 /* MB */
-#define MEMCG_MEMORY_2048_THRES_DEDUP 400 /* MB */
-#define MEMCG_MEMORY_2048_THRES_SWAP 300 /* MB */
-#define MEMCG_MEMORY_2048_THRES_LOW 200 /* MB */
-#define MEMCG_MEMORY_2048_THRES_MEDIUM 160 /* MB */
-#define MEMCG_MEMORY_2048_THRES_LEAVE 300 /* MB */
+#define CGROUP_ROOT_2048_THRES_DEDUP 400 /* MB */
+#define CGROUP_ROOT_2048_THRES_SWAP 300 /* MB */
+#define CGROUP_ROOT_2048_THRES_LOW 200 /* MB */
+#define CGROUP_ROOT_2048_THRES_MEDIUM 160 /* MB */
+#define CGROUP_ROOT_2048_THRES_LEAVE 300 /* MB */
/* threshold for more than 3072M RAM */
#define PROACTIVE_3072_THRES 300 /* MB */
#define PROACTIVE_3072_LEAVE 700 /* MB */
-#define MEMCG_MEMORY_3072_THRES_DEDUP 500 /* MB */
-#define MEMCG_MEMORY_3072_THRES_SWAP 400 /* MB */
-#define MEMCG_MEMORY_3072_THRES_LOW 300 /* MB */
-#define MEMCG_MEMORY_3072_THRES_MEDIUM 250 /* MB */
-#define MEMCG_MEMORY_3072_THRES_LEAVE 400 /* MB */
+#define CGROUP_ROOT_3072_THRES_DEDUP 500 /* MB */
+#define CGROUP_ROOT_3072_THRES_SWAP 400 /* MB */
+#define CGROUP_ROOT_3072_THRES_LOW 300 /* MB */
+#define CGROUP_ROOT_3072_THRES_MEDIUM 250 /* MB */
+#define CGROUP_ROOT_3072_THRES_LEAVE 400 /* MB */
static unsigned proactive_threshold;
static unsigned proactive_leave;
static size_t cur_mem_state = LOWMEM_NORMAL;
static int num_max_victims = MAX_MEMORY_CGROUP_VICTIMS;
static int num_vict_between_check = MAX_VICTIMS_BETWEEN_CHECK;
-static int default_swappiness = -1;
+//static int default_swappiness = -1;
static unsigned long totalram;
static unsigned long ktotalram;
static bool bg_reclaim;
static int fragmentation_size;
-static struct memcg_info gmi[MEMCG_MAX] = {
- {MEMCG_PATH, "/", MEMCG_ROOT,},
- {MEMCG_APPS_PATH, "Apps", MEMCG_MEMORY,},
- {MEMCG_BGLOCKED_PATH, "Apps/BgLocked", MEMCG_APPS,},
- {MEMCG_MEMLIMIT_PATH, "MemLimit", MEMCG_MEMORY,},
- {MEMCG_SWAP_PATH, "Swap", MEMCG_MEMORY,},
-};
-
enum memory_level {
MEMORY_LEVEL_NORMAL,
MEMORY_LEVEL_LOW,
MEMORY_LEVEL_CRITICAL,
};
-/*
- * This structure has full hierarchy of memory cgroups on running system.
- * It is exported through lowmem-handler.h file.
- **/
-static struct memcg **memcg_tree;
-
-/*
- * Special node that point's to /sys/fs/cgroup/memory - root of memcg group.
- * This is the same as memcg_tree[MEMCG_MEMORY]->info.
- */
-static struct memcg_info *memcg_root;
-
static GPtrArray *vip_apps;
static const char *convert_type_to_str(int type)
retry:
/* Prepare LMK to start doing it's job. Check preconditions. */
calualate_range_of_oom(lmk_type, &start_oom, &end_oom);
- lmk_start_threshold = memcg_root->threshold[LOWMEM_MEDIUM];
+ lmk_start_threshold = get_root_memcg_info()->threshold[LOWMEM_MEDIUM];
shortfall = is_memory_recovered(&available, ctl->size);
if (!shortfall || !reclaim_size) {
_I("[LOW MEM STATE] %s ==> %s", convert_memstate_to_str(cur_mem_state),
convert_memstate_to_str(mem_state));
cur_mem_state = mem_state;
- lmk_start_threshold = memcg_root->threshold[LOWMEM_MEDIUM];
+ lmk_start_threshold = get_root_memcg_info()->threshold[LOWMEM_MEDIUM];
resourced_notify(RESOURCED_NOTIFIER_MEM_STATE_CHANGED,
(void *)&cur_mem_state);
}
-static void lowmem_swap_memory(enum memcg_type type, struct memcg_info *mi)
+static void lowmem_swap_memory(enum cgroup_type type, struct memcg_info *mi)
{
unsigned int available;
struct swap_status_msg msg;
available = proc_get_mem_available();
if (cur_mem_state != LOWMEM_SWAP &&
- available <= memcg_root->threshold[LOWMEM_SWAP])
+ available <= get_root_memcg_info()->threshold[LOWMEM_SWAP])
swap_act();
msg.type = type;
- msg.info = mi;
+ msg.memcg_info = mi;
resourced_notify(RESOURCED_NOTIFIER_SWAP_START, &msg);
memcg_swap_status = true;
}
struct memcg_info *mi;
struct swap_status_msg msg;
- mi = memcg_tree[memcg_idx]->info;
+ mi = get_memcg_info(memcg_idx);
+// mi = memcg_tree[memcg_idx]->info;
_D("name : %s, pid : %d", mi->name, pid);
cgroup_write_pid_fullpath(mi->name, pid);
//cgroup_write_node_uint32(mi->name, CGROUP_FILE_NAME, pid);
msg.type = memcg_idx;
- msg.info = mi;
+ msg.memcg_info = mi;
resourced_notify(RESOURCED_NOTIFIER_SWAP_START, &msg);
}
change_lowmem_state(LOWMEM_NORMAL);
if (swap_get_state() == SWAP_ON && memcg_swap_status) {
- msg.type = MEMCG_SWAP;
- msg.info = memcg_tree[msg.type]->info;
+ msg.type = CGROUP_LOW;
+ msg.memcg_info = get_memcg_info(msg.type);
+// msg.info = memcg_tree[msg.type]->info;
resourced_notify(RESOURCED_NOTIFIER_SWAP_UNSET_LIMIT, &msg);
memcg_swap_status = false;
}
change_lowmem_state(LOWMEM_MEDIUM);
- if (available < memcg_root->threshold_leave) {
+ if (available < get_root_memcg_info()->threshold_leave) {
struct lowmem_control *ctl = LOWMEM_NEW_REQUEST();
if (ctl) {
LOWMEM_SET_REQUEST(ctl, OOM_IN_DEPTH,
- LMK_OLDEST, memcg_root->threshold_leave,
+ LMK_OLDEST, get_root_memcg_info()->threshold_leave,
num_max_victims, medium_cb);
lowmem_queue_request(&lmw, ctl);
}
{
int mem_state;
for (mem_state = LOWMEM_MAX_LEVEL - 1; mem_state > LOWMEM_NORMAL; mem_state--) {
- if (mem_state != LOWMEM_MEDIUM && available <= memcg_root->threshold[mem_state])
+ if (mem_state != LOWMEM_MEDIUM && available <= get_root_memcg_info()->threshold[mem_state])
break;
else if (mem_state == LOWMEM_MEDIUM && available <= lmk_start_threshold)
break;
if (!strncmp(result->name, "ThresholdDedup", strlen("ThresholdDedup")+1)) {
int value = atoi(result->value);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_DEDUP, value);
+ memcg_set_threshold(CGROUP_ROOT, LOWMEM_DEDUP, value);
} else if (!strncmp(result->name, "ThresholdSwap", strlen("ThresholdSwap")+1)) {
int value = atoi(result->value);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_SWAP, value);
+ memcg_set_threshold(CGROUP_ROOT, LOWMEM_SWAP, value);
} else if (!strncmp(result->name, "ThresholdLow", strlen("ThresholdLow")+1)) {
int value = atoi(result->value);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_LOW, value);
+ memcg_set_threshold(CGROUP_ROOT, LOWMEM_LOW, value);
} else if (!strncmp(result->name, "ThresholdMedium", strlen("ThresholdMedium")+1)) {
int value = atoi(result->value);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_MEDIUM, value);
+ memcg_set_threshold(CGROUP_ROOT, LOWMEM_MEDIUM, value);
} else if (!strncmp(result->name, "ThresholdLeave", strlen("ThresholdLeave")+1)) {
int value = atoi(result->value);
- lowmem_memcg_set_leave_threshold(MEMCG_MEMORY, 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;
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_DEDUP, BYTE_TO_MBYTE(value));
+ memcg_set_threshold(CGROUP_ROOT, LOWMEM_DEDUP, 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;
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_SWAP, BYTE_TO_MBYTE(value));
+ memcg_set_threshold(CGROUP_ROOT, LOWMEM_SWAP, 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;
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_LOW, BYTE_TO_MBYTE(value));
+ memcg_set_threshold(CGROUP_ROOT, LOWMEM_LOW, 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;
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_MEDIUM, BYTE_TO_MBYTE(value));
+ memcg_set_threshold(CGROUP_ROOT, LOWMEM_MEDIUM, 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;
- lowmem_memcg_set_leave_threshold(MEMCG_MEMORY, BYTE_TO_MBYTE(value));
+ memcg_set_leave_threshold(CGROUP_ROOT, BYTE_TO_MBYTE(value));
} else if (!strncmp(result->name, "ForegroundRatio", strlen("ForegroundRatio")+1)) {
float ratio = atof(result->value);
- memcg_info_set_limit(memcg_tree[MEMCG_APPS]->info, ratio, totalram);
+ memcg_info_set_limit(get_memcg_info(CGROUP_HIGH), ratio, totalram);
+// memcg_info_set_limit(memcg_tree[CGROUP_HIGH]->info, ratio, totalram);
+ } else if (!strncmp(result->name, "BackgroundRatio", strlen("BackgroundRatio")+1)) {
+ float ratio = atof(result->value);
+ memcg_info_set_limit(get_memcg_info(CGROUP_MEDIUM), ratio, totalram);
+// memcg_info_set_limit(memcg_tree[CGROUP_MEDIUM]->info, ratio, totalram);
+ } else if (!strncmp(result->name, "LowRatio", strlen("LowRatio")+1)) {
+ float ratio = atof(result->value);
+ memcg_info_set_limit(get_memcg_info(CGROUP_LOW), ratio, totalram);
+// memcg_info_set_limit(memcg_tree[CGROUP_LOW]->info, ratio, totalram);
} else if (!strncmp(result->name, "NumMaxVictims", strlen("NumMaxVictims")+1)) {
int value = atoi(result->value);
num_max_victims = value;
return RESOURCED_ERROR_OUT_OF_MEMORY;
} else if (!strncmp(result->name, "SWAPPINESS", strlen("SWAPPINESS")+1)) {
int value = atoi(result->value);
- default_swappiness = value;
- memcg_info_set_swappiness(memcg_tree[MEMCG_MEMORY]->info, value);
- } else if (!strncmp(result->name, "APPCG_SWAPPINESS", strlen("APPCG_SWAPPINESS")+1)) {
+// default_swappiness = value;
+ memcg_set_default_swappiness(value);
+ memcg_info_set_swappiness(get_memcg_info(CGROUP_ROOT), value);
+// memcg_info_set_swappiness(memcg_tree[CGROUP_ROOT]->info, value);
+ } else if (!strncmp(result->name, "FOREGROUND_SWAPPINESS", strlen("FOREGROUND_SWAPPINESS")+1)) {
int value = atoi(result->value);
- memcg_info_set_swappiness(memcg_tree[MEMCG_APPS]->info, value);
- } else if (!strncmp(result->name, "SWAPCG_SWAPPINESS", strlen("SWAPCG_SWAPPINESS")+1)) {
+ memcg_info_set_swappiness(get_memcg_info(CGROUP_HIGH), value);
+// memcg_info_set_swappiness(memcg_tree[CGROUP_HIGH]->info, value);
+ } else if (!strncmp(result->name, "BACKGROUND_SWAPPINESS", strlen("BACKGROUND_SWAPPINESS")+1)) {
int value = atoi(result->value);
- memcg_info_set_swappiness(memcg_tree[MEMCG_SWAP]->info, value);
+ memcg_info_set_swappiness(get_memcg_info(CGROUP_MEDIUM), value);
+// memcg_info_set_swappiness(memcg_tree[CGROUP_MEDIUM]->info, value);
+ } else if (!strncmp(result->name, "LOW_SWAPPINESS", strlen("LOW_SWAPPINESS")+1)) {
+ int value = atoi(result->value);
+ memcg_info_set_swappiness(get_memcg_info(CGROUP_LOW), value);
+// memcg_info_set_swappiness(memcg_tree[CGROUP_LOW]->info, value);
} else if (!strncmp(result->name, "NumFragSize", strlen("NumFragSize")+1)) {
fragmentation_size = atoi(result->value);
}
/* set thresholds for ram size 64M */
proactive_threshold = PROACTIVE_64_THRES;
proactive_leave = PROACTIVE_64_LEAVE;
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_DEDUP, MEMCG_MEMORY_64_THRES_DEDUP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_SWAP, MEMCG_MEMORY_64_THRES_SWAP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_LOW, MEMCG_MEMORY_64_THRES_LOW);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_MEDIUM, MEMCG_MEMORY_64_THRES_MEDIUM);
- lowmem_memcg_set_leave_threshold(MEMCG_MEMORY, MEMCG_MEMORY_64_THRES_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_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_64_THRES_LEAVE);
section = "Memory64";
} else if (total_ramsize <= MEM_SIZE_256) {
/* set thresholds for ram size 256M */
proactive_threshold = PROACTIVE_256_THRES;
proactive_leave = PROACTIVE_256_LEAVE;
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_DEDUP, MEMCG_MEMORY_256_THRES_DEDUP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_SWAP, MEMCG_MEMORY_256_THRES_SWAP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_LOW, MEMCG_MEMORY_256_THRES_LOW);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_MEDIUM, MEMCG_MEMORY_256_THRES_MEDIUM);
- lowmem_memcg_set_leave_threshold(MEMCG_MEMORY, MEMCG_MEMORY_256_THRES_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_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_256_THRES_LEAVE);
section = "Memory256";
} else if (total_ramsize <= MEM_SIZE_448) {
/* set thresholds for ram size 448M */
proactive_threshold = PROACTIVE_448_THRES;
proactive_leave = PROACTIVE_448_LEAVE;
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_DEDUP, MEMCG_MEMORY_448_THRES_DEDUP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_SWAP, MEMCG_MEMORY_448_THRES_SWAP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_LOW, MEMCG_MEMORY_448_THRES_LOW);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_MEDIUM, MEMCG_MEMORY_448_THRES_MEDIUM);
- lowmem_memcg_set_leave_threshold(MEMCG_MEMORY, MEMCG_MEMORY_448_THRES_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_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_448_THRES_LEAVE);
section = "Memory448";
} else if (total_ramsize <= MEM_SIZE_512) {
/* set thresholds for ram size 512M */
proactive_threshold = PROACTIVE_512_THRES;
proactive_leave = PROACTIVE_512_LEAVE;
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_DEDUP, MEMCG_MEMORY_512_THRES_DEDUP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_SWAP, MEMCG_MEMORY_512_THRES_SWAP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_LOW, MEMCG_MEMORY_512_THRES_LOW);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_MEDIUM, MEMCG_MEMORY_512_THRES_MEDIUM);
- lowmem_memcg_set_leave_threshold(MEMCG_MEMORY, MEMCG_MEMORY_512_THRES_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_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_512_THRES_LEAVE);
section = "Memory512";
} else if (total_ramsize <= MEM_SIZE_768) {
/* set thresholds for ram size 512M */
proactive_threshold = PROACTIVE_768_THRES;
proactive_leave = PROACTIVE_768_LEAVE;
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_DEDUP, MEMCG_MEMORY_768_THRES_DEDUP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_SWAP, MEMCG_MEMORY_768_THRES_SWAP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_LOW, MEMCG_MEMORY_768_THRES_LOW);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_MEDIUM, MEMCG_MEMORY_768_THRES_MEDIUM);
- lowmem_memcg_set_leave_threshold(MEMCG_MEMORY, MEMCG_MEMORY_768_THRES_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_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_768_THRES_LEAVE);
section = "Memory768";
} 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;
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_DEDUP, MEMCG_MEMORY_1024_THRES_DEDUP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_SWAP, MEMCG_MEMORY_1024_THRES_SWAP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_LOW, MEMCG_MEMORY_1024_THRES_LOW);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_MEDIUM, MEMCG_MEMORY_1024_THRES_MEDIUM);
- lowmem_memcg_set_leave_threshold(MEMCG_MEMORY, MEMCG_MEMORY_1024_THRES_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_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_1024_THRES_LEAVE);
section = "Memory1024";
} else if (total_ramsize <= MEM_SIZE_2048) {
proactive_threshold = PROACTIVE_2048_THRES;
proactive_leave = PROACTIVE_2048_LEAVE;
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_DEDUP, MEMCG_MEMORY_2048_THRES_DEDUP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_SWAP, MEMCG_MEMORY_2048_THRES_SWAP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_LOW, MEMCG_MEMORY_2048_THRES_LOW);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_MEDIUM, MEMCG_MEMORY_2048_THRES_MEDIUM);
- lowmem_memcg_set_leave_threshold(MEMCG_MEMORY, MEMCG_MEMORY_2048_THRES_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_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_2048_THRES_LEAVE);
section = "Memory2048";
} else {
proactive_threshold = PROACTIVE_3072_THRES;
proactive_leave = PROACTIVE_3072_LEAVE;
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_DEDUP, MEMCG_MEMORY_3072_THRES_DEDUP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_SWAP, MEMCG_MEMORY_3072_THRES_SWAP);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_LOW, MEMCG_MEMORY_3072_THRES_LOW);
- lowmem_memcg_set_threshold(MEMCG_MEMORY, LOWMEM_MEDIUM, MEMCG_MEMORY_3072_THRES_MEDIUM);
- lowmem_memcg_set_leave_threshold(MEMCG_MEMORY, MEMCG_MEMORY_3072_THRES_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_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_3072_THRES_LEAVE);
section = "Memory3072";
}
config_parse(MEM_CONF_FILE, memory_load_config, (void *)section);
for (i = 0; i < LOWMEM_MAX_LEVEL; i++)
- _I("set threshold for state '%s' to %u MB", convert_memstate_to_str(i), memcg_root->threshold[i]);
+ _I("set threshold for state '%s' to %u MB", convert_memstate_to_str(i), get_root_memcg_info()->threshold[i]);
_I("set number of max victims as %d", num_max_victims);
- _I("set threshold leave to %u MB", memcg_root->threshold_leave);
+ _I("set threshold leave to %u MB", get_root_memcg_info()->threshold_leave);
_I("set proactive threshold to %u MB", proactive_threshold);
_I("set proactive low memory killer leave to %u MB", proactive_leave);
}
-static void init_memcg_params(void)
+/*static void init_memcg_params(void)
{
int idx = 0;
GSList *cgroups;
memcg_tree = (struct memcg **)malloc(sizeof(struct memcg *) *
- MEMCG_MAX);
+ CGROUP_END);
assert(memcg_tree);
- for (idx = 0; idx < MEMCG_MAX; idx++) {
- struct memcg_info *mi = &gmi[idx];
+ for (idx = CGROUP_ROOT; idx < CGROUP_END; idx++) {
+ struct memcg_info *mi = &gmemcg_info[idx];
memcg_tree[idx] = (struct memcg *)malloc(sizeof(struct memcg));
assert(memcg_tree[idx]);
memcg_tree[idx]->info = mi;
_I("init memory cgroup for %s", mi->name);
- if (mi->parent_memcg == MEMCG_ROOT) {
- memcg_root = memcg_tree[idx]->info;
+ if (mi->parent_memcg == CGROUP_TOP) {
+ get_root_memcg_info() = memcg_tree[idx]->info;
} else {
cgroups = memcg_tree[mi->parent_memcg]->cgroups;
cgroups = g_slist_prepend(cgroups, mi);
memcg_tree[mi->parent_memcg]->use_hierarchy = true;
}
}
-}
-
-static int write_params_memcg_info(struct memcg_info *mi)
-{
- unsigned int limit = mi->limit;
- const char *name = mi->name;
- int ret = RESOURCED_ERROR_NONE;
- int swappiness = -1;
- _I("write memcg param for %s", name);
- /* enable cgroup move */
- ret = cgroup_write_node_uint32(name,
- MEMCG_MOVE_CHARGE, 3);
- if (ret)
- return ret;
-
- /*
- * write swapness if it has a meaningful value.
- * if it has own swappiness value, set it to memcg at first.
- * otherwise, check default_swappiness value and use it.
- */
- if (mi->swappiness >= 0)
- swappiness = mi->swappiness;
- else if (default_swappiness >= 0)
- swappiness = default_swappiness;
-
- if (swappiness >= 0) {
- ret = cgroup_write_node_uint32(name,
- MEMCG_SWAPPINESS, swappiness);
- if (ret)
- _I("failed to write %s %d to %s the",
- MEMCG_SWAPPINESS, swappiness, name);
- }
+}*/
- if (mi->limit_ratio == LOWMEM_NO_LIMIT)
- return ret;
- /* write limit_in_bytes */
- ret = cgroup_write_node_uint32(name,
- MEMCG_LIMIT_BYTE, limit);
- _I("set %s's limit to %u", name, limit);
- return ret;
-}
-
-static int write_memcg_params(void)
-{
- unsigned int i;
-
- for (i = 0; i < MEMCG_MAX; i++) {
- struct memcg_info *mi = memcg_tree[i]->info;
- write_params_memcg_info(mi);
- }
-
- return RESOURCED_ERROR_NONE;
-}
static void lowmem_move_memcgroup(int pid, int oom_score_adj)
{
* management in userspace. A separate memcg won't affect
* the other aspects of lowmem and swap if there is no set
* action for it. */
- if (pai->memory.memcg_idx == MEMCG_BGLOCKED)
+ if (pai->memory.memcg_idx == CGROUP_MEDIUM)
return;
- memcg_idx = MEMCG_BGLOCKED;
- mi = memcg_tree[memcg_idx]->info;
+ memcg_idx = CGROUP_MEDIUM;
+// mi = memcg_tree[memcg_idx]->info;
+ mi = get_memcg_info(memcg_idx);
} else if (oom_score_adj > OOMADJ_BACKGRD_UNLOCKED + OOMADJ_APP_INCREASE) {
if (oom_score_adj != pai->memory.oom_score_adj)
proc_set_process_memory_state(pai, pai->memory.memcg_idx,
pai->memory.memcg_info, oom_score_adj);
return;
} else if (oom_score_adj >= OOMADJ_INIT) {
- memcg_idx = MEMCG_APPS;
- mi = memcg_tree[memcg_idx]->info;
+ memcg_idx = CGROUP_HIGH;
+// mi = memcg_tree[memcg_idx]->info;
+ mi = get_memcg_info(memcg_idx);
if (oom_score_adj >= OOMADJ_FAVORITE)
should_swap = 1;
* it is no necessary to control memcg any longer.
* Stop other operation and return.
*/
- if (memcg_idx == MEMCG_APPS) {
+ if (memcg_idx == CGROUP_HIGH) {
ret = lowmem_limit_move_cgroup(pai);
if (!ret) {
- memcg_idx = MEMCG_LIMIT;
- mi = memcg_tree[memcg_idx]->info;
+// memcg_idx = MEMCG_LIMIT;
+// mi = memcg_tree[memcg_idx]->info;
+ mi = get_memcg_info(memcg_idx);
proc_set_process_memory_state(pai, memcg_idx, mi, oom_score_adj);
return;
}
* cgroup.
*/
if (should_swap)
- lowmem_swap_memory(memcg_idx, memcg_tree[memcg_idx]->info);
+// lowmem_swap_memory(memcg_idx, memcg_tree[memcg_idx]->info);
+ lowmem_swap_memory(memcg_idx, mi);
}
g_async_queue_unref(lmw.queue);
}
-static int create_memcgs(void)
-{
- int i = 0;
- int ret = RESOURCED_ERROR_NONE;
- struct memcg_info *mi;
- char *name;
-
- /* skip for memory cgroup */
- for (i = 0; i < MEMCG_MAX; i++) {
- if (memcg_root == memcg_tree[i]->info)
- continue;
- mi = memcg_tree[i]->info;
- name = mi->hashname;
- ret = cgroup_make_subdir(MEMCG_PATH, name, NULL);
- _D("create memory cgroup for %s, ret = %d", name, ret);
- }
-
- return ret;
-}
-
static int lowmem_press_eventfd_read(int fd)
{
uint64_t dummy_state;
static bool lowmem_press_eventfd_handler(int fd, void *data)
{
int i;
+ struct cgroup *cgroup;
struct memcg_info *mi;
GSList *iter = NULL;
enum lmk_type lmk_type = LMK_MEMORY;
if (lowmem_press_eventfd_read(fd) < 0)
_E("Failed to read lowmem press event, %m\n");
- for (i = 0; i < MEMCG_MAX; i++) {
- if (!memcg_tree[i] || !memcg_tree[i]->info)
+ for (i = CGROUP_ROOT; i < CGROUP_END; i++) {
+ if (!get_memcg_info(i))
+// if (!memcg_tree[i] || !memcg_tree[i]->info)
+ if (!get_cgroup_tree(i) || !get_memcg_info(i))
continue;
- mi = memcg_tree[i]->info;
+ mi = get_memcg_info(i);
+// mi = memcg_tree[i]->info;
if (fd == mi->evfd) {
/* call low memory handler for this memcg */
- if (i == MEMCG_MEMORY)
+ if (i == CGROUP_ROOT)
lowmem_press_root_cgroup_handler();
else {
- if (i == MEMCG_APPS)
+ if (i == CGROUP_HIGH)
lmk_type = LMK_ACTIVE;
- else if (i == MEMCG_SWAP)
+ else if (i == CGROUP_LOW)
lmk_type = LMK_OLDEST;
lowmem_press_cgroup_handler(lmk_type, mi);
}
return true;
}
/* ToDo: iterate child memcgs */
- gslist_for_each_item(iter, memcg_tree[i]->cgroups)
+// gslist_for_each_item(iter, memcg_tree[i]->cgroups)
+ gslist_for_each_item(iter, get_child_cgroups(i))
{
- mi = (struct memcg_info *)(iter->data);
+ cgroup = (struct cgroup *)(iter->data);
+ mi = cgroup->memcg_info;
+// mi = (struct memcg_info *)(iter->data);
if (fd == mi->evfd) {
- if (i == MEMCG_APPS)
+ if (i == CGROUP_HIGH)
lmk_type = LMK_ACTIVE;
- else if (i == MEMCG_SWAP)
+ else if (i == CGROUP_LOW)
lmk_type = LMK_OLDEST;
lowmem_press_cgroup_handler(lmk_type, mi);
_D("lowmem cgroup handler is called for %s",
{
unsigned int i;
- for (i = 0; i < MEMCG_MAX; i++) {
- if (!memcg_tree[i]->use_hierarchy)
+ for (i = CGROUP_ROOT; i < CGROUP_END; i++) {
+// if (!memcg_tree[i]->use_hierarchy)
+ if (!get_use_hierarchy(i))
continue;
- lowmem_press_register_eventfd(memcg_tree[i]->info);
+// lowmem_press_register_eventfd(memcg_tree[i]->info);
+ lowmem_press_register_eventfd(get_memcg_info(i));
}
return RESOURCED_ERROR_NONE;
}
flags |= OOM_FORCE | OOM_IN_DEPTH | OOM_SINGLE_SHOT;
victims = victims > 0 ? victims : MAX_MEMORY_CGROUP_VICTIMS;
type = type > 0 ? type : LMK_OLDEST;
- threshold = threshold > 0 ? threshold : memcg_root->threshold_leave;
+ threshold = threshold > 0 ? threshold : get_root_memcg_info()->threshold_leave;
lowmem_change_memory_state(LOWMEM_LOW, 1);
LOWMEM_SET_REQUEST(ctl, flags,
victims = num_max_victims > MAX_PROACTIVE_HIGH_VICTIMS
? MAX_PROACTIVE_HIGH_VICTIMS : num_max_victims;
- size = memcg_root->threshold_leave + swap_size;
+ size = get_root_memcg_info()->threshold_leave + swap_size;
_I("reclaim from swap module, type : %d, size : %d, victims: %d", type, size, victims);
lowmem_trigger_reclaim(0, victims, type, size);
}
before = proc_get_mem_available();
/* If memory state is medium or normal, just return and kill in oom killer */
- if (before < memcg_root->threshold[LOWMEM_MEDIUM] || before > proactive_leave)
+ if (before < get_root_memcg_info()->threshold[LOWMEM_MEDIUM] || before > proactive_leave)
return;
victims = num_max_victims > MAX_PROACTIVE_HIGH_VICTIMS
* after launching app, ensure that available memory is
* above threshold_leave
*/
- if (after >= memcg_root->threshold[LOWMEM_MEDIUM])
+ if (after >= get_root_memcg_info()->threshold[LOWMEM_MEDIUM])
return;
- if (proactive_threshold - rss >= memcg_root->threshold[LOWMEM_MEDIUM])
+ if (proactive_threshold - rss >= get_root_memcg_info()->threshold[LOWMEM_MEDIUM])
size = proactive_threshold;
else
- size = rss + memcg_root->threshold[LOWMEM_MEDIUM] + THRESHOLD_MARGIN;
+ size = rss + get_root_memcg_info()->threshold[LOWMEM_MEDIUM] + THRESHOLD_MARGIN;
_D("history based proactive LMK : avg rss %u, available %u required = %u MB",
rss, before, size);
* (if swap is enabled) earlier than they used to while minimizing the
* impact on the user experience.
*/
- msg.type = MEMCG_BGLOCKED;
- msg.info = memcg_tree[msg.type]->info;
+ msg.type = CGROUP_MEDIUM;
+// msg.info = memcg_tree[msg.type]->info;
+ msg.memcg_info = get_memcg_info(msg.type);
resourced_notify(RESOURCED_NOTIFIER_SWAP_START, &msg);
return RESOURCED_ERROR_NONE;
{
int ret = RESOURCED_ERROR_NONE;
- get_total_memory();
+ _D("resourced memory init start");
+ ret = cgroup_make_full_subdir(MEMCG_PATH);
+ ret_value_msg_if(ret < 0, ret, "memory cgroup init failed\n");
+ memcg_params_init();
- init_memcg_params();
+ get_total_memory();
setup_memcg_params();
if (allocate_vip_app_list() != RESOURCED_ERROR_NONE)
_E("allocate_vip_app_list FAIL");
config_parse(MEM_CONF_FILE, load_bg_reclaim_config, NULL);
config_parse(MEM_CONF_FILE, load_mem_logconfig, NULL);
- create_memcgs();
- write_memcg_params();
+ memcg_write_params();
ret = lowmem_activate_worker();
if (ret) {
static int lowmem_exit(void)
{
- int i;
- for (i = 0; i < MEMCG_MAX; i++) {
+// cgroup_params_exit();
+// int i;
+/* for (i = CGROUP_ROOT; i < CGROUP_END; i++) {
g_slist_free_full(memcg_tree[i]->cgroups, free);
free(memcg_tree[i]);
- }
+ }*/
if (strncmp(event_level, MEMCG_DEFAULT_EVENT_LEVEL, sizeof(MEMCG_DEFAULT_EVENT_LEVEL)))
free(event_level);
lowmem_trigger_memory_state_action(mem_state);
}
-void lowmem_memcg_set_threshold(int type, int level, int value)
+/*void memcg_set_threshold(int type, int level, int value)
{
memcg_tree[type]->info->threshold[level] = value;
}
-void lowmem_memcg_set_leave_threshold(int type, int value)
+void memcg_set_leave_threshold(int type, int value)
{
memcg_tree[type]->info->threshold_leave = value;
-}
+}*/
unsigned long lowmem_get_ktotalram(void)
{
return ktotalram;
}
-int lowmem_get_memcg(enum memcg_type type, struct memcg **memcg_ptr)
+/*int lowmem_get_memcg(enum cgroup_type type, struct memcg **memcg_ptr)
{
- if (memcg_ptr == NULL || memcg_tree == NULL || type >= MEMCG_MAX)
+ if (memcg_ptr == NULL || memcg_tree == NULL || type >= CGROUP_END)
return RESOURCED_ERROR_FAIL;
*memcg_ptr = memcg_tree[type];
return RESOURCED_ERROR_NONE;
-}
+}*/
void lowmem_restore_memcg(struct proc_app_info *pai)
{
char *cgpath;
int index, ret;
- struct memcg_info *mi;
+ struct cgroup *cgroup = NULL;
+ struct memcg_info *mi = NULL;
pid_t pid = pai->main_pid;
ret = cgroup_pid_get_path("memory", pid, &cgpath);
if (ret < 0)
return;
- for (index = MEMCG_MAX-1; index >= MEMCG_MEMORY; index--) {
- mi = &gmi[index];
- if (strstr(cgpath, mi->hashname))
+ for (index = CGROUP_END-1; index >= CGROUP_ROOT; index--) {
+ cgroup = get_cgroup_tree(index);
+ if (!cgroup)
+ continue;
+
+ mi = cgroup->memcg_info;
+ if (!mi)
+ continue;
+
+ if (!strcmp(cgroup->hashname, ""))
+ continue;
+ if (strstr(cgpath, cgroup->hashname))
break;
}
pai->memory.memcg_idx = index;
pai->memory.memcg_info = mi;
- if (index == MEMCG_LIMIT)
+ if(strstr(cgpath, pai->appid))
pai->memory.use_mem_limit = true;
+/* if (index == MEMCG_LIMIT)
+ pai->memory.use_mem_limit = true;*/
free(cgpath);
}
pthread_mutex_unlock(&swap_thread_queue.lock);
}
-static int swap_move_to_cgroup_by_pid(enum memcg_type type, pid_t pid)
+static int swap_move_to_cgroup_by_pid(enum cgroup_type type, pid_t pid)
{
int ret;
- struct memcg *memcg_swap = NULL;
+ struct cgroup *cgroup_swap = NULL;
struct memcg_info *mi;
struct proc_app_info *pai = find_app_info(pid);
GSList *iter_child = NULL;
- ret = lowmem_get_memcg(type, &memcg_swap);
- if (ret != RESOURCED_ERROR_NONE)
+ cgroup_swap = get_cgroup_tree((int)type);
+ if(!cgroup_swap)
return RESOURCED_ERROR_FAIL;
+/* ret = lowmem_get_memcg(type, &memcg_swap);
+ if (ret != RESOURCED_ERROR_NONE)
+ return RESOURCED_ERROR_FAIL;*/
- mi = memcg_swap->info;
+ mi = cgroup_swap->memcg_info;
if (!pai)
return cgroup_write_pid_fullpath(mi->name, pid);
pid_t child = GPOINTER_TO_PID(iter_child->data);
ret = cgroup_write_pid_fullpath(mi->name, child);
}
- pai->memory.memcg_idx = MEMCG_SWAP;
+ pai->memory.memcg_idx = CGROUP_LOW;
pai->memory.memcg_info = mi;
return ret;
}
pid_t child = GPOINTER_TO_PID(iter_child->data);
cgroup_write_pid_fullpath(info->name, child);
}
- pai->memory.memcg_idx = MEMCG_SWAP;
+ pai->memory.memcg_idx = CGROUP_LOW;
pai->memory.memcg_info = info;
}
return RESOURCED_ERROR_NONE;
static int swap_reclaim_memcg(struct swap_status_msg msg)
{
int r;
- struct memcg_info *info = msg.info;
+ struct memcg_info *info = msg.memcg_info;
if (!info)
return -EINVAL;
int ret, max_victims;
struct swap_task victim;
GArray *candidates = NULL;
- struct memcg *memcg_swap = NULL;
+// struct memcg *memcg_swap = NULL;
+ struct cgroup *cgroup_swap = NULL;
struct proc_app_info *pai = NULL;
candidates = g_array_new(false, false, sizeof(struct swap_task));
gslist_for_each_item(iter, proc_app_list) {
pai = (struct proc_app_info *)iter->data;
if ((!pai->main_pid) ||
- (pai->memory.memcg_info != msg->info) ||
+ (pai->memory.memcg_info != msg->memcg_info) ||
(pai->memory.oom_score_adj < OOMADJ_BACKGRD_UNLOCKED) ||
(pai->lru_state <= PROC_BACKGROUND))
continue;
goto out;
}
swap_reduce_victims(candidates, max_victims);
- ret = lowmem_get_memcg(MEMCG_SWAP, &memcg_swap);
- if (ret != RESOURCED_ERROR_NONE)
+ cgroup_swap = get_cgroup_tree(CGROUP_LOW);
+ if(!cgroup_swap)
goto out;
+/* ret = lowmem_get_memcg(CGROUP_LOW, &memcg_swap);
+ if (ret != RESOURCED_ERROR_NONE)
+ goto out;*/
/*
* change swap info from inactive cgroup to swap group
* for using same structure to move and swap it
*/
- msg->info = memcg_swap->info;
- msg->type = MEMCG_SWAP;
- ret = swap_move_to_cgroup(msg->info, candidates);
+ msg->memcg_info = cgroup_swap->memcg_info;
+ msg->type = CGROUP_LOW;
+ ret = swap_move_to_cgroup(msg->memcg_info, candidates);
out:
proc_app_list_close();
g_array_free(candidates, TRUE);
bundle->op = SWAP_OP_RECLAIM;
memcpy(&(bundle->msg), data, sizeof(struct swap_status_msg));
- if (bundle->msg.type == MEMCG_APPS) {
+ if (bundle->msg.type == CGROUP_HIGH) {
/*
* Background tasks are concerned special way, we select
* tasks and move them to Swap cgroup. They are not there already.
return RESOURCED_ERROR_NONE;
limit = -1;
- ret = cgroup_write_node_int32(msg->info->name, MEMCG_LIMIT_BYTE, limit);
+ ret = cgroup_write_node_int32(msg->memcg_info->name, MEMCG_LIMIT_BYTE, limit);
if (ret != RESOURCED_ERROR_NONE)
- _E("Failed to change hard limit of %s cgroup to -1", msg->info->name);
+ _E("Failed to change hard limit of %s cgroup to -1", msg->memcg_info->name);
else
- _D("changed hard limit of %s cgroup to -1", msg->info->name);
+ _D("changed hard limit of %s cgroup to -1", msg->memcg_info->name);
return ret;
}
static void swap_start_pid_dbus_signal_handler(GVariant *params)
{
- int ret;
+// int ret;
pid_t pid;
- struct memcg *memcg_swap;
+// struct memcg *memcg_swap;
+ struct cgroup *cgroup_swap;
struct swap_status_msg ss_msg;
do_expr_unless_g_variant_get_typechecked(return, params, "(i)", &pid);
return;
}
- ret = lowmem_get_memcg(MEMCG_SWAP, &memcg_swap);
- if (ret != RESOURCED_ERROR_NONE)
+ cgroup_swap = get_cgroup_tree(CGROUP_LOW);
+ if (!cgroup_swap)
return;
- swap_move_to_cgroup_by_pid(MEMCG_SWAP, pid);
+/* ret = lowmem_get_memcg(CGROUP_LOW, &memcg_swap);
+ if (ret != RESOURCED_ERROR_NONE)
+ return;*/
+ swap_move_to_cgroup_by_pid(CGROUP_LOW, pid);
ss_msg.pid = pid;
- ss_msg.type = MEMCG_SWAP;
- ss_msg.info = memcg_swap->info;
+ ss_msg.type = CGROUP_LOW;
+ ss_msg.memcg_info = cgroup_swap->memcg_info;
swap_start_handler(&ss_msg);
_I("swap cgroup entered : pid : %d", (int)pid);
}
* This will prevent from flushing file pages from memory - causing
* slowdown when re-launching applications.
*/
-static void resourced_swap_change_memcg_settings(enum memcg_type type)
+static void resourced_swap_change_memcg_settings(enum cgroup_type type)
{
int ret;
- struct memcg *memcg_swap = NULL;
+// struct memcg *memcg_swap = NULL;
+ struct cgroup *cgroup_swap = NULL;
char buf[MAX_PATH_LENGTH];
- ret = lowmem_get_memcg(type, &memcg_swap);
- if (ret != RESOURCED_ERROR_NONE)
+ cgroup_swap = get_cgroup_tree(type);
+ if (!cgroup_swap)
return;
+/* ret = lowmem_get_memcg(type, &memcg_swap);
+ if (ret != RESOURCED_ERROR_NONE)
+ return;*/
- cgroup_write_node_uint32(memcg_swap->info->name, MEMCG_MOVE_CHARGE, 1);
+ cgroup_write_node_uint32(cgroup_swap->memcg_info->name, MEMCG_MOVE_CHARGE, 1);
snprintf(buf, sizeof(buf), "%s/%s", MEMCG_PATH, MEMCG_FORCE_RECLAIM);
ret = swap_check_node(buf);
if (ret == RESOURCED_ERROR_NONE) {
{
int ret;
- resourced_swap_change_memcg_settings(MEMCG_SWAP);
+ resourced_swap_change_memcg_settings(CGROUP_LOW);
swap_set_state(SWAP_OFF);
ret = swap_init();
if (!swap_total)
swap_total = proc_get_swap_total();
- r = memcg_get_swap_usage(MEMCG_SWAP_PATH, &swap_usage);
+ r = memcg_get_swap_usage(MEMCG_LOW_PATH, &swap_usage);
if (r)
return r;
swapcg_usage_ratio = (float)(swap_usage / (swap_total - swap_available) *100);
endfunction()
# lowmem-limit unit test
-ADD_MEMORY_TESTS(lowmem-limit-test "${GLIB2_LDFLAGS}"
- "-Wl,--wrap=kill,--wrap=read,--wrap=access"
- lowmem-limit-test.cpp lowmem-limit-mock.cpp lowmem-limit-env.cpp lowmem-env.cpp lowmem-env-mock.cpp
- ../src/common/safe-kill.c
- ../src/resource-limiter/memory/lowmem-limit.c)
+#ADD_MEMORY_TESTS(lowmem-limit-test "${GLIB2_LDFLAGS}"
+# "-Wl,--wrap=kill,--wrap=read,--wrap=access"
+# lowmem-limit-test.cpp lowmem-limit-mock.cpp lowmem-limit-env.cpp lowmem-env.cpp lowmem-env-mock.cpp
+# ../src/common/safe-kill.c
+# ../src/resource-limiter/memory/lowmem-limit.c)
# lowmem-system unit test
ADD_MEMORY_TESTS(lowmem-system-test "${GLIB2_LDFLAGS}"
"-Wl,--wrap=opendir,--wrap=readdir,--wrap=closedir,--wrap=opendir64,--wrap=readdir64,--wrap=closedir64"
global_test_lowmem_dbus_env = nullptr;
}
-void LowmemDbusEnv::lowmem_memcg_set_threshold(int type, int level, int value)
+void LowmemDbusEnv::memcg_set_threshold(int type, int level, int value)
{
check_expected(type);
check_expected(level);
check_expected(value);
}
-void LowmemDbusEnv::lowmem_memcg_set_leave_threshold(int type, int value)
+void LowmemDbusEnv::memcg_set_leave_threshold(int type, int value)
{
check_expected(type);
check_expected(value);
LowmemDbusEnv();
~LowmemDbusEnv();
- void lowmem_memcg_set_threshold(int type, int level, int value);
- void lowmem_memcg_set_leave_threshold(int type, int value);
+ void memcg_set_threshold(int type, int level, int value);
+ void memcg_set_leave_threshold(int type, int value);
int lowmem_trigger_reclaim(int flags, int victims, enum lmk_type type, int threshold);
int proc_set_oom_score_adj(int pid, int oom_score_adj);
void lowmem_trigger_swap(pid_t pid, int memcg_idx);
#define WRAP_DBUS(rettype, name, def_args, call_args) \
WRAP(global_test_lowmem_dbus_env, rettype, name, def_args, call_args)
-MOCK_DBUS(void, lowmem_memcg_set_threshold, (int type, int level, int value), (type, level, value))
-MOCK_DBUS(void, lowmem_memcg_set_leave_threshold, (int type, int value), (type, value))
+MOCK_DBUS(void, memcg_set_threshold, (int type, int level, int value), (type, level, value))
+MOCK_DBUS(void, memcg_set_leave_threshold, (int type, int value), (type, value))
MOCK_DBUS(int, lowmem_trigger_reclaim, (int flags, int victims, enum lmk_type type, int threshold),
(flags, victims, type, threshold))
MOCK_DBUS(int, proc_set_oom_score_adj, (int pid, int oom_score_adj), (pid, oom_score_adj))
#include <limits>
-void test_lowmem_memcg_set_threshold(LowmemDbusEnv &env, int level, int value)
+void test_memcg_set_threshold(LowmemDbusEnv &env, int level, int value)
{
if (level >= 0 && value >= 0)
{
- expect_value(lowmem_memcg_set_threshold, type, MEMCG_MEMORY);
- expect_value(lowmem_memcg_set_threshold, level, level);
- expect_value(lowmem_memcg_set_threshold, value, value);
+ expect_value(memcg_set_threshold, type, CGROUP_ROOT);
+ expect_value(memcg_set_threshold, level, level);
+ expect_value(memcg_set_threshold, value, value);
}
env.trigger_signal_oom_set_threshold(g_variant_new("(ii)", level, value));
}
-void test_lowmem_memcg_set_leave_threshold(LowmemDbusEnv &env, int value)
+void test_memcg_set_leave_threshold(LowmemDbusEnv &env, int value)
{
if (value >= 0)
{
- expect_value(lowmem_memcg_set_leave_threshold, type, MEMCG_MEMORY);
- expect_value(lowmem_memcg_set_leave_threshold, value, value);
+ expect_value(memcg_set_leave_threshold, type, CGROUP_ROOT);
+ expect_value(memcg_set_leave_threshold, value, value);
}
env.trigger_signal_oom_set_leave_threshold(g_variant_new("(i)", value));
{
if (pid > 0) {
expect_value(lowmem_trigger_swap, pid, pid);
- expect_value(lowmem_trigger_swap, memcg_idx, MEMCG_SWAP);
+ expect_value(lowmem_trigger_swap, memcg_idx, CGROUP_LOW);
}
env.trigger_signal_oom_set_platform(g_variant_new("(i)", pid));
std::numeric_limits<int> int_limits;
- test_lowmem_memcg_set_threshold(env, -1, 0);
- test_lowmem_memcg_set_threshold(env, 0, -1);
- test_lowmem_memcg_set_threshold(env, int_limits.min(), int_limits.min());
- test_lowmem_memcg_set_threshold(env, 0, 0);
- test_lowmem_memcg_set_threshold(env, 123, 456);
- test_lowmem_memcg_set_threshold(env, int_limits.max()-1, int_limits.max());
+ test_memcg_set_threshold(env, -1, 0);
+ test_memcg_set_threshold(env, 0, -1);
+ test_memcg_set_threshold(env, int_limits.min(), int_limits.min());
+ test_memcg_set_threshold(env, 0, 0);
+ test_memcg_set_threshold(env, 123, 456);
+ test_memcg_set_threshold(env, int_limits.max()-1, int_limits.max());
env.trigger_signal_oom_set_threshold(unsupported_gvariant());
- test_lowmem_memcg_set_leave_threshold(env, int_limits.min());
- test_lowmem_memcg_set_leave_threshold(env, -1);
- test_lowmem_memcg_set_leave_threshold(env, 0);
- test_lowmem_memcg_set_leave_threshold(env, 123);
- test_lowmem_memcg_set_leave_threshold(env, int_limits.max());
+ test_memcg_set_leave_threshold(env, int_limits.min());
+ test_memcg_set_leave_threshold(env, -1);
+ test_memcg_set_leave_threshold(env, 0);
+ test_memcg_set_leave_threshold(env, 123);
+ test_memcg_set_leave_threshold(env, int_limits.max());
env.trigger_signal_oom_set_leave_threshold(unsupported_gvariant());
test_lowmem_trigger(env);
void LowmemLimitEnv::configure_cgroup_usages(const char *cgroup, unsigned long sw_usage, unsigned long usage)
{
- auto cg_name = std::string("/sys/fs/cgroup/memory/MemLimit/") + std::string(cgroup);
+ auto cg_name = std::string(MEMCG_HIGH_PP_PATH) + std::string(cgroup);
auto &cg = cgroup_memory[cg_name];
cg.files["memory.memsw.usage_in_bytes"] = std::to_string(sw_usage);
cg.files["memory.usage_in_bytes"] = std::to_string(usage);
void LowmemLimitEnv::event_cgroup_eventfd(const std::string &cgroup_event)
{
- const auto &p = eventfds.find(std::string("/sys/fs/cgroup/memory/MemLimit/") + cgroup_event);
+ const auto &p = eventfds.find(std::string(MEMCG_HIGH_PP_PATH) + cgroup_event);
if (p != eventfds.end()) {
event_fd_handler(p->second);
} else {
std::map<pid_t, AppTestValuesHolder> apps;
std::map<int, FDReadHandler> fd_handlers;
- const std::string default_cgroup_memory{"/sys/fs/cgroup/memory"};
+ const std::string default_cgroup_memory{MEMCG_PATH};
const std::pair<std::string, std::string> default_cgroup_usage{"memory.memsw.usage_in_bytes", "33554432"};
typedef std::map<std::string, std::string> CGroupFiles;
class CgPath {
public:
- CgPath(const char *name) : app_name{name}, cg_name{std::string{"/sys/fs/cgroup/memory/MemLimit/"}+name} {}
+ CgPath(const char *name) : app_name{name}, cg_name{std::string{MEMCG_HIGH_PP_PATH}+name} {}
CgPath(CgPath &&) = delete;
const char *get_app_name() const { return app_name.c_str(); }
test_lowmem_limit_env.configure_add_app(APP_PID, app_name, std::move(usages));
- expect_string(cgroup_make_subdir, parentdir, "/sys/fs/cgroup/memory/MemLimit");
+ expect_string(cgroup_make_subdir, parentdir, MEMCG_HIGH_PP_PATH);
expect_string(cgroup_make_subdir, cgroup_name, app_name);
if (limit_type == LowmemLimitEnv::MemLimitType::OOM) {
projects / platform / core / system / resourced.git / commitdiff