+#include <assert.h>
+
#include "cpu-cgroup.h"
#include "trace.h"
+static struct cpucg_conf *cpucg_conf;
+
+char *get_cpucg_conf_name(void)
+{
+ assert(cpucg_conf != NULL);
+
+ return cpucg_conf->name;
+}
+
+char *get_cpucg_conf_value(void)
+{
+ assert(cpucg_conf != NULL);
+
+ return cpucg_conf->value;
+}
+
+int set_cpucg_conf(const char *name, const char *value)
+{
+ cpucg_conf = (struct cpucg_conf *)calloc(1, sizeof (struct cpucg_conf));
+ if (!cpucg_conf) {
+ _E("Failed to alloc memory for cpu configuration");
+ return RESOURCED_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (strlen(name) + 1 > sizeof(cpucg_conf->name)) {
+ _E("Size of cpu configuration for name is not enough");
+ return RESOURCED_ERROR_OUT_OF_MEMORY;
+ }
+ strncpy(cpucg_conf->name, name, sizeof(cpucg_conf->name) - 1);
+
+ if (strlen(value) + 1 > sizeof(cpucg_conf->value)) {
+ _E("Size of cpu configuration for value is not enough");
+ return RESOURCED_ERROR_OUT_OF_MEMORY;
+ }
+ strncpy(cpucg_conf->value, value, sizeof(cpucg_conf->value) - 1);
+
+ return RESOURCED_ERROR_NONE;
+}
+
+void free_cpucg_conf(void)
+{
+ assert(cpucg_conf != NULL);
+
+ free(cpucg_conf);
+}
+
static int cpu_move_cgroup(pid_t pid, char *path)
{
return cgroup_write_pid_fullpath(path, pid);
#define CPUCG_LOW_PP_PATH CPUCG_LOW_PATH"/"CGROUP_PER_PROCESS_NAME
#define CPUCG_LOW_GROUP_PATH CPUCG_LOW_PATH"/"CGROUP_GROUP_NAME
+struct cpucg_conf {
+ char name[64];
+ char value[64];
+};
+
+char *get_cpucg_conf_name(void);
+char *get_cpucg_conf_value(void);
+int set_cpucg_conf(const char *name, const char *value);
+void free_cpucg_conf(void);
int cpu_move_cgroup_foreach(pid_t pid, struct proc_app_info *pai, char *path);
#ifdef __cplusplus
*
*/
+#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
+#include <stdlib.h>
#include <sys/eventfd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "module.h"
#include "util.h"
#include "file-helper.h"
-
-#include <stdlib.h>
+#include "config-parser.h"
+#include "proc-common.h"
#define BUF_MAX 1023
#define MEMCG_NO_LIMIT 0
*/
static struct memcg_info *memcg_root;
+static struct memcg_conf *memcg_conf = NULL;
+
static struct memcg_info gmemcg_info[CGROUP_END] = {
{MEMCG_PATH,},
{MEMCG_VIP_PATH,},
{MEMCG_LOW_PATH,},
};
+int set_mem_action_conf(struct mem_action *mem_action, const char *value)
+{
+ char *ptr = strchr(value, ',');
+ char *second_value = ptr + 1;
+ char temp;
+
+ if (ptr == NULL) {
+ _E("Cannot find ',' in the string (%s)", value);
+ return RESOURCED_ERROR_FAIL;
+ }
+
+ if (value > (ptr - 2)) {
+ _E("Size of string should be larger than 2");
+ return RESOURCED_ERROR_FAIL;
+ }
+
+ if (*(ptr - 1) == 'B') {
+ temp = *(ptr - 2);
+ *(ptr - 2) = '\0';
+
+ if (temp == 'G') {
+ mem_action->memory = GBYTE_TO_BYTE(atoi(value));
+ }
+ else if (temp == 'M') {
+ mem_action->memory = MBYTE_TO_BYTE(atoi(value));
+ }
+ else if (temp == 'K') {
+ mem_action->memory = KBYTE_TO_BYTE(atoi(value));
+ }
+ else if (temp == ' ') {
+ mem_action->memory = atoi(value);
+ }
+ else {
+ _E("Memory size unit should be GB or MB or KB or B");
+ return RESOURCED_ERROR_FAIL;
+ }
+
+ if (!strncmp(second_value, ACTION_BROADCAST_VALUE_CONF,
+ strlen(ACTION_BROADCAST_VALUE_CONF)+1))
+ mem_action->action = PROC_ACTION_BROADCAST;
+ else if (!strncmp(second_value, ACTION_RECLAIM_VALUE_CONF,
+ strlen(ACTION_RECLAIM_VALUE_CONF)+1))
+ mem_action->action = PROC_ACTION_RECLAIM;
+ else if (!strncmp(second_value, ACTION_KILL_VALUE_CONF,
+ strlen(ACTION_KILL_VALUE_CONF)+1))
+ mem_action->action = PROC_ACTION_KILL;
+ else {
+ _E("action (%s) is not supported", second_value);
+ return RESOURCED_ERROR_FAIL;
+ }
+ }
+ else {
+ _E("Memory size unit should be XB");
+ return RESOURCED_ERROR_FAIL;
+ }
+
+ return RESOURCED_ERROR_NONE;
+}
+
+int set_memcg_conf_threshold(bool percent, char size, int lvl, const char *value)
+{
+ if (!percent) {
+ if (size == 'G') {
+ memcg_conf->threshold[lvl].threshold =
+ GBYTE_TO_BYTE(atoi(value));
+ }
+ else if (size == 'M') {
+ memcg_conf->threshold[lvl].threshold =
+ MBYTE_TO_BYTE(atoi(value));
+ }
+ else if (size == 'K') {
+ memcg_conf->threshold[lvl].threshold =
+ KBYTE_TO_BYTE(atoi(value));
+ }
+ else if (size == ' ') {
+ memcg_conf->threshold[lvl].threshold =
+ atoi(value);
+ }
+ else {
+ _E("Memory size unit should be GB or MB or KB or B");
+ return RESOURCED_ERROR_FAIL;
+ }
+ }
+ else {
+ memcg_conf->threshold[lvl].threshold = atoi(value);
+ }
+
+ memcg_conf->threshold[lvl].percent = percent;
+ return RESOURCED_ERROR_NONE;
+}
+
+struct memcg_conf *get_memcg_conf(void)
+{
+ if (!memcg_conf) {
+ memcg_conf = (struct memcg_conf *)calloc(1, sizeof (struct memcg_conf));
+ if (!memcg_conf) {
+ _E("Failed to alloc memory for cpu configuration");
+ return NULL;
+ }
+ }
+
+ return memcg_conf;
+}
+
+void free_memcg_conf(void)
+{
+ assert(memcg_conf != NULL);
+
+ free(memcg_conf);
+}
+
static void set_limit_in_bytes(const char *dir, unsigned int limit)
{
int error;
set_limit_in_bytes(dir, limit);
}
else {
- _I("[DEBUG] panic_on_oom = %u on %s", poo, dir);
set_limit_in_bytes(dir, limit);
}
mi->limit = (float)totalram * ratio;
mi->limit_ratio = ratio;
- mi->threshold[MEM_STATE_CRITICAL] = (unsigned int)(mi->limit * MEMCG_LOW_RATIO);
- mi->threshold[MEM_STATE_OOM] = (unsigned int)(mi->limit * MEMCG_MEDIUM_RATIO);
+ mi->threshold[MEM_LEVEL_CRITICAL] = (unsigned int)(mi->limit * MEMCG_LOW_RATIO);
+ mi->threshold[MEM_LEVEL_OOM] = (unsigned int)(mi->limit * MEMCG_MEDIUM_RATIO);
mi->threshold_leave = (float)mi->limit * MEMCG_FOREGROUND_LEAVE_RATIO;
mi->oomleave = mi->limit - mi->threshold_leave;
}
#define DEFAULT_MEMLOG_NR_MAX 50
enum {
- MEM_STATE_HIGH,
- MEM_STATE_MEDIUM,
- MEM_STATE_LOW,
- MEM_STATE_CRITICAL,
- MEM_STATE_OOM,
- MEM_STATE_MAX,
+ MEM_LEVEL_HIGH,
+ MEM_LEVEL_MEDIUM,
+ MEM_LEVEL_LOW,
+ MEM_LEVEL_CRITICAL,
+ MEM_LEVEL_OOM,
+ MEM_LEVEL_MAX,
};
enum lowmem_control_type {
MEMLOG_MAX,
};
-
enum cgroup_memory_stat_id {
CGROUP_MEMORY_STAT_CACHE = 0,
CGROUP_MEMORY_STAT_RSS,
CGROUP_MEMORY_STAT_INVALID = -1,
};
+struct mem_threshold {
+ bool percent;
+ unsigned int threshold;
+};
+
+struct mem_action {
+ unsigned int memory; /* Byte */
+ int action;
+};
+
+struct memcg_conf {
+ struct mem_threshold threshold[MEM_LEVEL_MAX]; /* % or byte */
+ struct mem_action service;
+ struct mem_action widget;
+ struct mem_action guiapp;
+ struct mem_action background;
+ unsigned int cgroup_limit[CGROUP_END]; /* % */
+ bool oom_popup;
+};
struct memcg_info {
/* name of memory cgroup */
/* leave memory usage */
unsigned int oomleave;
/* thresholds, normal, swap, low, medium, and leave */
- unsigned int threshold[MEM_STATE_MAX];
+ unsigned int threshold[MEM_LEVEL_MAX];
unsigned int threshold_leave;
int evfd;
int swappiness;
long long value[CGROUP_MEMORY_STAT_MAX];
};
+int set_mem_action_conf(struct mem_action *mem_action, const char *value);
+int set_memcg_conf_threshold(bool percent, char size, int lvl, const char *value);
+struct memcg_conf *get_memcg_conf(void);
+void free_memcg_conf(void);
+
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);
#include "trace.h"
#include "config-parser.h"
#include "proc-common.h"
+#include "cpu-cgroup.h"
#define MAX_SECTION 64
#define CPU_INIT_PRIO 100
+static int limiter_config(struct parse_result *result, void *user_data)
+{
+ if (!result)
+ return RESOURCED_ERROR_INVALID_PARAMETER;
+
+ struct memcg_conf *memcg_conf = get_memcg_conf();
+ if (memcg_conf == NULL) {
+ _E("[DEBUG] memory cgroup configuration is NULL");
+ return RESOURCED_ERROR_FAIL;
+ }
+
+ if (!strncmp(result->section, MEMORY_GROUP_LIMIT_SECTION,
+ strlen(MEMORY_GROUP_LIMIT_SECTION)+1)) {
+ char *ptr = strchr(result->value, '%');
+ if (ptr == NULL) {
+ _E("[DEBUG] Cannot find '%%' in the string (%s)", result->value);
+ return RESOURCED_ERROR_FAIL;
+ }
+ else
+ *ptr = '\0';
+
+ if (!strncmp(result->name, VIP_GROUP_LIMIT_CONF,
+ strlen(VIP_GROUP_LIMIT_CONF) + 1)) {
+ memcg_conf->cgroup_limit[CGROUP_VIP] = atoi(result->value);
+ }
+ else if (!strncmp(result->name, HIGH_GROUP_LIMIT_CONF,
+ strlen(HIGH_GROUP_LIMIT_CONF) + 1)) {
+ memcg_conf->cgroup_limit[CGROUP_HIGH] = atoi(result->value);
+ }
+ else if (!strncmp(result->name, MEDIUM_GROUP_LIMIT_CONF,
+ strlen(MEDIUM_GROUP_LIMIT_CONF) + 1)) {
+ memcg_conf->cgroup_limit[CGROUP_MEDIUM] = atoi(result->value);
+ }
+ else if (!strncmp(result->name, LOWEST_GROUP_LIMIT_CONF,
+ strlen(LOWEST_GROUP_LIMIT_CONF) + 1)) {
+ memcg_conf->cgroup_limit[CGROUP_LOW] = atoi(result->value);
+ }
+ else {
+ _E("[DEBUG] Unknown configuration name (%s) and value (%s) on section (%s)",
+ result->name, result->value, result->section);
+ }
+ }
+ else if (!strncmp(result->section, MEMORY_LEVEL_THRESHOLD_SECTION,
+ strlen(MEMORY_LEVEL_THRESHOLD_SECTION)+1)) {
+ char temp = '\0';
+ int error = RESOURCED_ERROR_NONE;
+ bool percent;
+ char *ptr = strchr(result->value, '%');
+ if (ptr == NULL) {
+ ptr = strchr(result->value, 'B');
+ if (ptr == NULL) {
+ _E("[DEBUG] Cannot find 'B' in the string (%s)", result->value);
+ return RESOURCED_ERROR_FAIL;
+ }
+
+ if (result->value > (ptr - 1)) {
+ _E("[DEBUG] Size of string should be larger than 1");
+ return RESOURCED_ERROR_FAIL;
+ }
+
+ temp = *(ptr - 1);
+ *(ptr - 1) = '\0';
+ percent = false;
+ }
+ else {
+ *ptr = '\0';
+ percent = true;
+ }
+
+ if (!strncmp(result->name, MEDIUM_LEVEL_CONF,
+ strlen(MEDIUM_LEVEL_CONF) + 1)) {
+ error = set_memcg_conf_threshold(percent, temp, MEM_LEVEL_MEDIUM, result->value);
+ }
+ else if (!strncmp(result->name, LOW_LEVEL_CONF,
+ strlen(LOW_LEVEL_CONF) + 1)) {
+ error = set_memcg_conf_threshold(percent, temp, MEM_LEVEL_LOW, result->value);
+ }
+ else if (!strncmp(result->name, CRITICAL_LEVEL_CONF,
+ strlen(CRITICAL_LEVEL_CONF) + 1)) {
+ error = set_memcg_conf_threshold(percent, temp, MEM_LEVEL_CRITICAL, result->value);
+ }
+ else if (!strncmp(result->name, OOM_LEVEL_CONF,
+ strlen(OOM_LEVEL_CONF) + 1)) {
+ error = set_memcg_conf_threshold(percent, temp, MEM_LEVEL_OOM, result->value);
+ }
+ else if (!strncmp(result->name, OOM_POPUP_CONF,
+ strlen(OOM_POPUP_CONF) + 1)) {
+ if (!strncmp(result->value, "yes", 4) ||
+ !strncmp(result->value, "1", 2) ||
+ !strncmp(result->value, "ok", 3))
+ memcg_conf->oom_popup = true;
+ else if (!strncmp(result->value, "no", 3) ||
+ !strncmp(result->value, "0", 2))
+ memcg_conf->oom_popup = false;
+ else {
+ _E("[DEBUG] Unknown value for %s", result->name);
+ return RESOURCED_ERROR_FAIL;
+ }
+ }
+ else {
+ _E("[DEBUG] Unknown configuration name (%s) and value (%s) on section (%s)",
+ result->name, result->value, result->section);
+ }
+
+ return error;
+ }
+ else if (!strncmp(result->section, MEMORY_APP_TYPE_LIMIT_SECTION,
+ strlen(MEMORY_APP_TYPE_LIMIT_SECTION)+1)) {
+ int error = RESOURCED_ERROR_NONE;
+
+ if (!strncmp(result->name, SERVICE_PER_APP_LIMIT_ACTION,
+ strlen(SERVICE_PER_APP_LIMIT_ACTION) + 1)) {
+ error = set_mem_action_conf(&memcg_conf->service, result->value);
+ }
+ else if (!strncmp(result->name, WIDGET_PER_APP_LIMIT_ACTION,
+ strlen(WIDGET_PER_APP_LIMIT_ACTION) + 1)) {
+ error = set_mem_action_conf(&memcg_conf->widget, result->value);
+ }
+ else if (!strncmp(result->name, GUI_PER_APP_LIMIT_ACTION,
+ strlen(GUI_PER_APP_LIMIT_ACTION) + 1)) {
+ error = set_mem_action_conf(&memcg_conf->guiapp, result->value);
+ }
+ else {
+ _E("[DEBUG] Unknown configuration name (%s) and value (%s) on section (%s)",
+ result->name, result->value, result->section);
+ }
+
+ return error;
+ }
+ else if (!strncmp(result->section, MEMORY_APP_STATUS_LIMIT_SECTION,
+ strlen(MEMORY_APP_STATUS_LIMIT_SECTION)+1)) {
+ int error = RESOURCED_ERROR_NONE;
+
+ if (!strncmp(result->name, BACKGROUND_PER_APP_LIMIT_ACTION,
+ strlen(BACKGROUND_PER_APP_LIMIT_ACTION) + 1)) {
+ error = set_mem_action_conf(&memcg_conf->background, result->value);
+ }
+ else {
+ _E("[DEBUG] Unknown configuration name (%s) and value (%s) on section (%s)",
+ result->name, result->value, result->section);
+ }
+
+ return error;
+ }
+ else if (!strncmp(result->section, CPU_AFFINITY_SECTION,
+ strlen(CPU_AFFINITY_SECTION)+1)) {
+ int error = RESOURCED_ERROR_NONE;
+
+ if (!strncmp(result->name, FOREGROUND_APPS,
+ strlen(FOREGROUND_APPS) + 1)) {
+ error = set_cpucg_conf(result->name, result->value);
+ }
+ else {
+ _E("[DEBUG] Unknown configuration name (%s) and value (%s) on section (%s)",
+ result->name, result->value, result->section);
+ }
+
+ return error;
+ }
+ else {
+ _E("[DEBUG] Unknown section name (%s) and value (%s) on section (%s)",
+ result->name, result->value, result->section);
+ }
+
+ return RESOURCED_ERROR_NONE;
+}
+
static int vendor_config(struct parse_result *result, void *user_data)
{
int *config_type = (int *)user_data;
if (!result || !user_data)
return RESOURCED_ERROR_INVALID_PARAMETER;
- if (strncmp(result->section, PER_PROCESS_SECTION_CONF, strlen(PER_PROCESS_SECTION_CONF)+1))
+ if (strncmp(result->section, PER_PROCESS_SECTION, strlen(PER_PROCESS_SECTION)+1))
return RESOURCED_ERROR_NONE;
if (!strncmp(result->name, SERVICE_NAME_CONF, strlen(SERVICE_NAME_CONF)+1) ||
}
else if (!strncmp(result->name, MEM_LIMIT_ACTION_NAME_CONF,
strlen(MEM_LIMIT_ACTION_NAME_CONF)+1) && *config_type == LIMITER_CONFIG) {
+ int error;
+
if (!pci) {
_E("process configuration information pointer should not be NULL");
return RESOURCED_ERROR_FAIL;
}
-
- char *ptr = strchr(result->value, ',');
- if (ptr == NULL) {
- _E("Cannot find ',' in the string (%s)", result->value);
- return RESOURCED_ERROR_FAIL;
- }
-
- char *second_value = ptr + 1;
- char temp;
-
- if (result->value > (ptr - 2)) {
- _E("Size of string should be larger than 2");
- return RESOURCED_ERROR_FAIL;
- }
-
- if (*(ptr - 1) == 'B') {
- temp = *(ptr - 2);
- *(ptr - 2) = '\0';
-
- if (temp == 'G') {
- pci->mem_action.memory = GBYTE_TO_BYTE(atoi(result->value));
- }
- else if (temp == 'M') {
- pci->mem_action.memory = MBYTE_TO_BYTE(atoi(result->value));
- }
- else if (temp == 'K') {
- pci->mem_action.memory = KBYTE_TO_BYTE(atoi(result->value));
- }
- else if (temp == ' ') {
- pci->mem_action.memory = atoi(result->value);
- }
- else {
- _E("Memory size unit should be GB or MB or KB or B");
- return RESOURCED_ERROR_FAIL;
- }
-
- if (!strncmp(second_value, ACTION_BROADCAST_VALUE_CONF,
- strlen(ACTION_BROADCAST_VALUE_CONF)+1))
- pci->mem_action.action = PROC_ACTION_BROADCAST;
- else if (!strncmp(second_value, ACTION_RECLAIM_VALUE_CONF,
- strlen(ACTION_RECLAIM_VALUE_CONF)+1))
- pci->mem_action.action = PROC_ACTION_RECLAIM;
- else if (!strncmp(second_value, ACTION_KILL_VALUE_CONF,
- strlen(ACTION_KILL_VALUE_CONF)+1))
- pci->mem_action.action = PROC_ACTION_KILL;
- else {
- _E("action (%s) is not supported", second_value);
- return RESOURCED_ERROR_FAIL;
- }
- }
- else {
- _E("Memory size unit should be XB");
- return RESOURCED_ERROR_FAIL;
- }
+
+ error = set_mem_action_conf(&pci->mem_action, result->value);
+ return error;
}
else if (!strncmp(result->name, CPU_PRIORITY_NAME_CONF, strlen(CPU_PRIORITY_NAME_CONF)+1) &&
*config_type == LIMITER_CONFIG) {
fixed_app_and_service_list_init();
+ /* Load configurations in limiter.conf and limiter.conf.d/ */
+ config_parse(LIMITER_CONF_FILE, limiter_config, NULL);
config_type = LIMITER_CONFIG;
- load_per_vendor_configs(CGROUP_VIP_LIST_DIR, vendor_config, &config_type);
+ load_per_vendor_configs(LIMITER_CONF_DIR, vendor_config, &config_type);
config_type = PROCESS_CONFIG;
load_per_vendor_configs(PROC_CONF_DIR, vendor_config, &config_type);
#define CONF_FILE_SUFFIX ".conf"
-#define CGROUP_VIP_LIST_DIR RD_CONFIG_PATH"/limiter.conf.d"
-#define PROC_CONF_DIR "/etc/resourced/process.conf.d"
-
-#define PER_PROCESS_SECTION_CONF "PerProcess"
+#define LIMITER_CONF_FILE RD_CONFIG_FILE(limiter)
+#define LIMITER_CONF_DIR RD_CONFIG_PATH"/limiter.conf.d"
+#define PROC_CONF_DIR RD_CONFIG_PATH"/process.conf.d"
+
+/* section name */
+#define PER_PROCESS_SECTION "PerProcess"
+#define MEMORY_GROUP_LIMIT_SECTION "MemoryGroupLimit"
+#define MEMORY_LEVEL_THRESHOLD_SECTION "MemoryLevelThreshold"
+#define MEMORY_APP_TYPE_LIMIT_SECTION "MemoryAppTypeLimit"
+#define MEMORY_APP_STATUS_LIMIT_SECTION "MemoryAppStatusLimit"
+#define CPU_AFFINITY_SECTION "CpuAffinity"
/* configuration name */
#define SERVICE_NAME_CONF "Service"
#define ACTION_ON_FAILURE_NAME_CONF "ActionOnFailure"
#define WATCHDOG_ACTION_NAME_CONF "WatchdogAction"
+#define VIP_GROUP_LIMIT_CONF "VipGroupLimit"
+#define HIGH_GROUP_LIMIT_CONF "HighGroupLimit"
+#define MEDIUM_GROUP_LIMIT_CONF "MediumGroupLimit"
+#define LOWEST_GROUP_LIMIT_CONF "LowestGroupLimit"
+
+#define MEDIUM_LEVEL_CONF "MediumLevel"
+#define LOW_LEVEL_CONF "LowLevel"
+#define CRITICAL_LEVEL_CONF "CriticalLevel"
+#define OOM_LEVEL_CONF "OomLevel"
+#define OOM_POPUP_CONF "OomPopup"
+
+#define SERVICE_PER_APP_LIMIT_ACTION "ServicePerAppLimitAction"
+#define WIDGET_PER_APP_LIMIT_ACTION "WidgetPerAppLimitAction"
+#define GUI_PER_APP_LIMIT_ACTION "GUIPerAppLimitAction"
+#define BACKGROUND_PER_APP_LIMIT_ACTION "BackgroundPerAppLimitAction"
+
+#define FOREGROUND_APPS "ForegroundApps"
+
/* configuration value */
#define CGROUP_VIP_VALUE_CONF "vip"
#define CGROUP_HIGH_VALUE_CONF "high"
RESOURCED_NOTIFIER_DATA_UPDATE,
RESOURCED_NOTIFIER_DATA_RESET,
RESOURCED_NOTIFIER_CONTROL_EXCLUDE,
- RESOURCED_NOTIFIER_MEM_STATE_CHANGED,
+ RESOURCED_NOTIFIER_MEM_LEVEL_CHANGED,
RESOURCED_NOTIFIER_MEM_CONTROL,
RESOURCED_NOTIFIER_LIMIT_APP,
SERVICE_TYPE,
};
-struct mem_action {
- unsigned int memory; /* Byte */
- enum proc_action action;
-};
struct proc_conf_info {
char name[MAX_NAME_LENGTH];
};
enum swap_compact_reason {
- SWAP_COMPACT_MEM_STATE_CRITICAL,
- SWAP_COMPACT_MEM_STATE_OOM,
+ SWAP_COMPACT_MEM_LEVEL_CRITICAL,
+ SWAP_COMPACT_MEM_LEVEL_OOM,
SWAP_COMPACT_SWAP_FULL,
SWAP_COMPACT_RESASON_MAX,
};
}
if (kill(mle->pid, 0) == 0) {
- _D("pid (%d) is still alive, so kill directly using SIGKILL", mle->pid);
+ _D("[DEBUG] pid (%d) is still alive, so kill directly using SIGKILL", mle->pid);
safe_kill(mle->pid, SIGKILL);
}
static void lmk_act(void);
-static size_t cur_mem_state = MEM_STATE_HIGH;
+static size_t cur_mem_state = MEM_LEVEL_HIGH;
static int num_max_victims = MAX_MEMORY_CGROUP_VICTIMS;
static int num_vict_between_check = MAX_VICTIMS_BETWEEN_CHECK;
{
static const char *state_table[] = {"mem normal", "mem dedup", "mem swap", "mem low",
"mem medium"};
- if (mem_state >= 0 && mem_state < MEM_STATE_MAX)
+ if (mem_state >= 0 && mem_state < MEM_LEVEL_MAX)
return state_table[mem_state];
return "";
}
if (calculate_range_of_oom(cgroup_type, &start_oom, &end_oom))
goto done;
- lmk_start_threshold = get_root_memcg_info()->threshold[MEM_STATE_OOM];
+ lmk_start_threshold = get_root_memcg_info()->threshold[MEM_LEVEL_OOM];
shortfall = is_memory_recovered(&available, ctl->size);
if (!shortfall || !reclaim_size) {
static void change_lowmem_state(unsigned int mem_state)
{
cur_mem_state = mem_state;
- lmk_start_threshold = get_root_memcg_info()->threshold[MEM_STATE_OOM];
+ lmk_start_threshold = get_root_memcg_info()->threshold[MEM_LEVEL_OOM];
- resourced_notify(RESOURCED_NOTIFIER_MEM_STATE_CHANGED,
+ resourced_notify(RESOURCED_NOTIFIER_MEM_LEVEL_CHANGED,
(void *)&cur_mem_state);
}
{
unsigned int available;
- if (cur_mem_state == MEM_STATE_HIGH)
+ if (cur_mem_state == MEM_LEVEL_HIGH)
return;
if (swap_get_state() != SWAP_ON)
return;
available = proc_get_mem_available();
- if (cur_mem_state != MEM_STATE_LOW &&
- available <= get_root_memcg_info()->threshold[MEM_STATE_LOW])
+ if (cur_mem_state != MEM_LEVEL_LOW &&
+ available <= get_root_memcg_info()->threshold[MEM_LEVEL_LOW])
swap_activate_act();
resourced_notify(RESOURCED_NOTIFIER_SWAP_START, path);
const char *str;
switch (lv) {
- case MEM_STATE_HIGH:
- case MEM_STATE_MEDIUM:
- case MEM_STATE_LOW:
+ case MEM_LEVEL_HIGH:
+ case MEM_LEVEL_MEDIUM:
+ case MEM_LEVEL_LOW:
str = EVT_VAL_MEMORY_NORMAL;
break;
- case MEM_STATE_CRITICAL:
+ case MEM_LEVEL_CRITICAL:
str = EVT_VAL_MEMORY_SOFT_WARNING;
break;
- case MEM_STATE_OOM:
+ case MEM_LEVEL_OOM:
str = EVT_VAL_MEMORY_HARD_WARNING;
break;
default:
if (status != VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL) {
vconf_set_int(VCONFKEY_SYSMAN_LOW_MEMORY,
VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL);
- memory_level_send_system_event(MEM_STATE_HIGH);
+ memory_level_send_system_event(MEM_LEVEL_HIGH);
}
- change_lowmem_state(MEM_STATE_HIGH);
+ change_lowmem_state(MEM_LEVEL_HIGH);
if (swap_get_state() == SWAP_ON && memcg_swap_status) {
resourced_notify(RESOURCED_NOTIFIER_SWAP_UNSET_LIMIT, get_memcg_info(CGROUP_LOW));
if (status != VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL) {
vconf_set_int(VCONFKEY_SYSMAN_LOW_MEMORY,
VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL);
- memory_level_send_system_event(MEM_STATE_LOW);
+ memory_level_send_system_event(MEM_LEVEL_LOW);
}
- change_lowmem_state(MEM_STATE_LOW);
+ change_lowmem_state(MEM_LEVEL_LOW);
if (proc_get_freezer_status() == CGROUP_FREEZER_PAUSED)
resourced_notify(RESOURCED_NOTIFIER_FREEZER_CGROUP_STATE,
(void *)CGROUP_FREEZER_ENABLED);
if (status != VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL) {
vconf_set_int(VCONFKEY_SYSMAN_LOW_MEMORY,
VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL);
- memory_level_send_system_event(MEM_STATE_MEDIUM);
+ memory_level_send_system_event(MEM_LEVEL_MEDIUM);
}
- change_lowmem_state(MEM_STATE_MEDIUM);
+ change_lowmem_state(MEM_LEVEL_MEDIUM);
data = KSM_SCAN_PARTIAL;
resourced_notify(RESOURCED_NOTIFIER_DEDUP_SCAN, &data);
static void swap_compact_act(void)
{
- change_lowmem_state(MEM_STATE_CRITICAL);
- resourced_notify(RESOURCED_NOTIFIER_SWAP_COMPACT, (void *)SWAP_COMPACT_MEM_STATE_CRITICAL);
- memory_level_send_system_event(MEM_STATE_CRITICAL);
+ change_lowmem_state(MEM_LEVEL_CRITICAL);
+ resourced_notify(RESOURCED_NOTIFIER_SWAP_COMPACT, (void *)SWAP_COMPACT_MEM_LEVEL_CRITICAL);
+ memory_level_send_system_event(MEM_LEVEL_CRITICAL);
}
static void medium_cb(struct lowmem_control *ctl)
{
if (ctl->status == LOWMEM_RECLAIM_DONE)
oom_popup = false;
- lowmem_change_memory_state(MEM_STATE_HIGH, 0);
+ lowmem_change_memory_state(MEM_LEVEL_HIGH, 0);
}
static void lmk_act(void)
if (ret)
_D("vconf_get_int fail %s", VCONFKEY_SYSMAN_LOW_MEMORY);
- memory_level_send_system_event(MEM_STATE_OOM);
+ memory_level_send_system_event(MEM_LEVEL_OOM);
if (status != VCONFKEY_SYSMAN_LOW_MEMORY_HARD_WARNING) {
if (proc_get_freezer_status() == CGROUP_FREEZER_ENABLED)
resourced_notify(RESOURCED_NOTIFIER_FREEZER_CGROUP_STATE,
}
available = proc_get_mem_available();
- change_lowmem_state(MEM_STATE_OOM);
+ change_lowmem_state(MEM_LEVEL_OOM);
if (available < get_root_memcg_info()->threshold_leave) {
struct lowmem_control *ctl;
}
}
- resourced_notify(RESOURCED_NOTIFIER_SWAP_COMPACT, (void *)SWAP_COMPACT_MEM_STATE_OOM);
+ resourced_notify(RESOURCED_NOTIFIER_SWAP_COMPACT, (void *)SWAP_COMPACT_MEM_LEVEL_OOM);
/*
* Flush resourced memory such as other processes.
* But it should except this condition if mem_state is already medium.
* Otherwise, recalim worker couldn't run any more.
*/
- if (mem_state != MEM_STATE_OOM && cur_mem_state == mem_state)
+ if (mem_state != MEM_LEVEL_OOM && cur_mem_state == mem_state)
return;
switch (mem_state) {
- case MEM_STATE_HIGH:
+ case MEM_LEVEL_HIGH:
high_mem_act();
break;
- case MEM_STATE_MEDIUM:
+ case MEM_LEVEL_MEDIUM:
dedup_act(KSM_SCAN_PARTIAL);
break;
- case MEM_STATE_LOW:
+ case MEM_LEVEL_LOW:
swap_activate_act();
break;
- case MEM_STATE_CRITICAL:
+ case MEM_LEVEL_CRITICAL:
dedup_act(KSM_SCAN_FULL);
swap_compact_act();
break;
- case MEM_STATE_OOM:
+ case MEM_LEVEL_OOM:
lmk_act();
break;
default:
static unsigned int check_mem_state(unsigned int available)
{
int mem_state;
- for (mem_state = MEM_STATE_MAX - 1; mem_state > MEM_STATE_HIGH; mem_state--) {
- if (mem_state != MEM_STATE_OOM && available <= get_root_memcg_info()->threshold[mem_state])
+ for (mem_state = MEM_LEVEL_MAX - 1; mem_state > MEM_LEVEL_HIGH; mem_state--) {
+ if (mem_state != MEM_LEVEL_OOM && available <= get_root_memcg_info()->threshold[mem_state])
break;
- else if (mem_state == MEM_STATE_OOM && available <= lmk_start_threshold)
+ else if (mem_state == MEM_LEVEL_OOM && available <= lmk_start_threshold)
break;
}
if (!strncmp(result->name, "ThresholdDedup", strlen("ThresholdDedup")+1)) {
int value = atoi(result->value);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, value);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_MEDIUM, value);
} else if (!strncmp(result->name, "ThresholdSwap", strlen("ThresholdSwap")+1)) {
int value = atoi(result->value);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, value);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_LOW, value);
} else if (!strncmp(result->name, "ThresholdLow", strlen("ThresholdLow")+1)) {
int value = atoi(result->value);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, value);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_CRITICAL, value);
} else if (!strncmp(result->name, "ThresholdMedium", strlen("ThresholdMedium")+1)) {
int value = atoi(result->value);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, value);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_OOM, value);
} else if (!strncmp(result->name, "ThresholdLeave", strlen("ThresholdLeave")+1)) {
int value = atoi(result->value);
memcg_set_leave_threshold(CGROUP_ROOT, value);
} else if (!strncmp(result->name, "ThresholdRatioDedup", strlen("ThresholdRatioDedup")+1)) {
double ratio = atoi(result->value);
int value = (double)totalram * ratio / 100.0;
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, BYTE_TO_MBYTE(value));
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_MEDIUM, BYTE_TO_MBYTE(value));
} else if (!strncmp(result->name, "ThresholdRatioSwap", strlen("ThresholdRatioSwap")+1)) {
double ratio = atoi(result->value);
int value = (double)totalram * ratio / 100.0;
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, BYTE_TO_MBYTE(value));
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_LOW, BYTE_TO_MBYTE(value));
} else if (!strncmp(result->name, "ThresholdRatioLow", strlen("ThresholdRatioLow")+1)) {
double ratio = atoi(result->value);
int value = (double)totalram * ratio / 100.0;
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, BYTE_TO_MBYTE(value));
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_CRITICAL, BYTE_TO_MBYTE(value));
} else if (!strncmp(result->name, "ThresholdRatioMedium", strlen("ThresholdRatioMedium")+1)) {
double ratio = atoi(result->value);
int value = (double)totalram * ratio / 100.0;
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, BYTE_TO_MBYTE(value));
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_OOM, BYTE_TO_MBYTE(value));
} else if (!strncmp(result->name, "ThresholdRatioLeave", strlen("ThresholdRatioLeave")+1)) {
double ratio = atoi(result->value);
int value = (double)totalram * ratio / 100.0;
/* set thresholds for ram size 64M */
proactive_threshold = PROACTIVE_64_THRES;
proactive_leave = PROACTIVE_64_LEAVE;
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_64_THRES_DEDUP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_64_THRES_SWAP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_64_THRES_LOW);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_64_THRES_MEDIUM);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_MEDIUM, CGROUP_ROOT_64_THRES_DEDUP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_LOW, CGROUP_ROOT_64_THRES_SWAP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_CRITICAL, CGROUP_ROOT_64_THRES_LOW);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_OOM, CGROUP_ROOT_64_THRES_MEDIUM);
memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_64_THRES_LEAVE);
num_max_victims = CGROUP_ROOT_64_NUM_VICTIMS;
} else if (total_ramsize <= MEM_SIZE_256) {
/* set thresholds for ram size 256M */
proactive_threshold = PROACTIVE_256_THRES;
proactive_leave = PROACTIVE_256_LEAVE;
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_256_THRES_DEDUP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_256_THRES_SWAP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_256_THRES_LOW);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_256_THRES_MEDIUM);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_MEDIUM, CGROUP_ROOT_256_THRES_DEDUP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_LOW, CGROUP_ROOT_256_THRES_SWAP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_CRITICAL, CGROUP_ROOT_256_THRES_LOW);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_OOM, CGROUP_ROOT_256_THRES_MEDIUM);
memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_256_THRES_LEAVE);
num_max_victims = CGROUP_ROOT_256_NUM_VICTIMS;
} else if (total_ramsize <= MEM_SIZE_448) {
/* set thresholds for ram size 448M */
proactive_threshold = PROACTIVE_448_THRES;
proactive_leave = PROACTIVE_448_LEAVE;
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_448_THRES_DEDUP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_448_THRES_SWAP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_448_THRES_LOW);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_448_THRES_MEDIUM);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_MEDIUM, CGROUP_ROOT_448_THRES_DEDUP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_LOW, CGROUP_ROOT_448_THRES_SWAP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_CRITICAL, CGROUP_ROOT_448_THRES_LOW);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_OOM, CGROUP_ROOT_448_THRES_MEDIUM);
memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_448_THRES_LEAVE);
num_max_victims = CGROUP_ROOT_448_NUM_VICTIMS;
} else if (total_ramsize <= MEM_SIZE_512) {
/* set thresholds for ram size 512M */
proactive_threshold = PROACTIVE_512_THRES;
proactive_leave = PROACTIVE_512_LEAVE;
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_512_THRES_DEDUP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_512_THRES_SWAP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_512_THRES_LOW);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_512_THRES_MEDIUM);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_MEDIUM, CGROUP_ROOT_512_THRES_DEDUP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_LOW, CGROUP_ROOT_512_THRES_SWAP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_CRITICAL, CGROUP_ROOT_512_THRES_LOW);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_OOM, CGROUP_ROOT_512_THRES_MEDIUM);
memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_512_THRES_LEAVE);
num_max_victims = CGROUP_ROOT_512_NUM_VICTIMS;
} else if (total_ramsize <= MEM_SIZE_768) {
/* set thresholds for ram size 512M */
proactive_threshold = PROACTIVE_768_THRES;
proactive_leave = PROACTIVE_768_LEAVE;
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_768_THRES_DEDUP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_768_THRES_SWAP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_768_THRES_LOW);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_768_THRES_MEDIUM);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_MEDIUM, CGROUP_ROOT_768_THRES_DEDUP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_LOW, CGROUP_ROOT_768_THRES_SWAP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_CRITICAL, CGROUP_ROOT_768_THRES_LOW);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_OOM, CGROUP_ROOT_768_THRES_MEDIUM);
memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_768_THRES_LEAVE);
num_max_victims = CGROUP_ROOT_768_NUM_VICTIMS;
} else if (total_ramsize <= MEM_SIZE_1024) {
/* set thresholds for ram size more than 1G */
proactive_threshold = PROACTIVE_1024_THRES;
proactive_leave = PROACTIVE_1024_LEAVE;
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_1024_THRES_DEDUP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_1024_THRES_SWAP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_1024_THRES_LOW);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_1024_THRES_MEDIUM);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_MEDIUM, CGROUP_ROOT_1024_THRES_DEDUP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_LOW, CGROUP_ROOT_1024_THRES_SWAP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_CRITICAL, CGROUP_ROOT_1024_THRES_LOW);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_OOM, CGROUP_ROOT_1024_THRES_MEDIUM);
memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_1024_THRES_LEAVE);
num_max_victims = CGROUP_ROOT_1024_NUM_VICTIMS;
} else if (total_ramsize <= MEM_SIZE_2048) {
proactive_threshold = PROACTIVE_2048_THRES;
proactive_leave = PROACTIVE_2048_LEAVE;
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_2048_THRES_DEDUP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_2048_THRES_SWAP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_2048_THRES_LOW);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_2048_THRES_MEDIUM);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_MEDIUM, CGROUP_ROOT_2048_THRES_DEDUP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_LOW, CGROUP_ROOT_2048_THRES_SWAP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_CRITICAL, CGROUP_ROOT_2048_THRES_LOW);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_OOM, CGROUP_ROOT_2048_THRES_MEDIUM);
memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_2048_THRES_LEAVE);
num_max_victims = CGROUP_ROOT_2048_NUM_VICTIMS;
} else {
proactive_threshold = PROACTIVE_3072_THRES;
proactive_leave = PROACTIVE_3072_LEAVE;
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_MEDIUM, CGROUP_ROOT_3072_THRES_DEDUP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_LOW, CGROUP_ROOT_3072_THRES_SWAP);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_CRITICAL, CGROUP_ROOT_3072_THRES_LOW);
- memcg_set_threshold(CGROUP_ROOT, MEM_STATE_OOM, CGROUP_ROOT_3072_THRES_MEDIUM);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_MEDIUM, CGROUP_ROOT_3072_THRES_DEDUP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_LOW, CGROUP_ROOT_3072_THRES_SWAP);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_CRITICAL, CGROUP_ROOT_3072_THRES_LOW);
+ memcg_set_threshold(CGROUP_ROOT, MEM_LEVEL_OOM, CGROUP_ROOT_3072_THRES_MEDIUM);
memcg_set_leave_threshold(CGROUP_ROOT, CGROUP_ROOT_3072_THRES_LEAVE);
num_max_victims = CGROUP_ROOT_3072_NUM_VICTIMS;
}
return;
}
- threshold = mi->threshold[MEM_STATE_OOM];
+ threshold = mi->threshold[MEM_LEVEL_OOM];
if (usage >= threshold)
memory_cgroup_proactive_lmk_act(type, mi);
else
const char *name = mi->name;
static fd_handler_h handler;
- if (mi->threshold[MEM_STATE_OOM] == LOWMEM_THRES_INIT)
+ if (mi->threshold[MEM_LEVEL_OOM] == LOWMEM_THRES_INIT)
return 0;
evfd = memcg_set_eventfd(name, MEMCG_EVENTFD_MEMORY_PRESSURE,
static void lowmem_force_reclaim_cb(struct lowmem_control *ctl)
{
- lowmem_change_memory_state(MEM_STATE_HIGH, 0);
+ lowmem_change_memory_state(MEM_LEVEL_HIGH, 0);
}
int lowmem_trigger_reclaim(int flags, int victims, enum cgroup_type type, int threshold)
type = type > 0 ? type : CGROUP_LOW;
threshold = threshold > 0 ? threshold : get_root_memcg_info()->threshold_leave;
- lowmem_change_memory_state(MEM_STATE_CRITICAL, 1);
+ lowmem_change_memory_state(MEM_LEVEL_CRITICAL, 1);
LOWMEM_SET_REQUEST(ctl, flags,
type, threshold, victims,
lowmem_force_reclaim_cb);
before = proc_get_mem_available();
/* If memory state is medium or normal, just return and kill in oom killer */
- if (before < get_root_memcg_info()->threshold[MEM_STATE_OOM] || before > proactive_leave)
+ if (before < get_root_memcg_info()->threshold[MEM_LEVEL_OOM] || 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 >= get_root_memcg_info()->threshold[MEM_STATE_OOM])
+ if (after >= get_root_memcg_info()->threshold[MEM_LEVEL_OOM])
return;
- if (proactive_threshold - rss >= get_root_memcg_info()->threshold[MEM_STATE_OOM])
+ if (proactive_threshold - rss >= get_root_memcg_info()->threshold[MEM_LEVEL_OOM])
size = proactive_threshold;
else
- size = rss + get_root_memcg_info()->threshold[MEM_STATE_OOM] + THRESHOLD_MARGIN;
+ size = rss + get_root_memcg_info()->threshold[MEM_LEVEL_OOM] + THRESHOLD_MARGIN;
_D("history based proactive LMK : avg rss %u, available %u required = %u MB",
rss, before, size);
static void print_mem_configs(void)
{
/* print info of Memory section */
- for (int mem_lvl = 0; mem_lvl < MEM_STATE_MAX; mem_lvl++)
+ for (int mem_lvl = 0; mem_lvl < MEM_LEVEL_MAX; mem_lvl++)
_I("set threshold for state '%s' to %u MB",
convert_memstate_to_str(mem_lvl), get_root_memcg_info()->threshold[mem_lvl]);
if (mem_info) {
int new_state = *((int *)data);
- if (new_state < MEM_STATE_HIGH || new_state >= MEM_STATE_MAX) {
+ if (new_state < MEM_LEVEL_HIGH || new_state >= MEM_LEVEL_MAX) {
result = RESOURCED_ERROR_FAIL;
goto leave;
}
if (!(compact->status & COMPACT_SKIP))
_E("Invalid compact thread state [%d]\n", compact->status);
- unregister_notifier(RESOURCED_NOTIFIER_MEM_STATE_CHANGED,
+ unregister_notifier(RESOURCED_NOTIFIER_MEM_LEVEL_CHANGED,
compact_mem_state_changed);
(void) pthread_mutex_destroy(&compact->lock);
pthread_detach(compact->compact_thread);
pthread_mutex_unlock(&compact_data.drained_lock);
- register_notifier(RESOURCED_NOTIFIER_MEM_STATE_CHANGED,
+ register_notifier(RESOURCED_NOTIFIER_MEM_LEVEL_CHANGED,
compact_mem_state_changed);
return RESOURCED_ERROR_NONE;
{
static const char *reasons_table[] = {"lowmem: critical", "lowmem: oom",
"swap: zram full"};
- if (reason >= SWAP_COMPACT_MEM_STATE_CRITICAL && reason < SWAP_COMPACT_RESASON_MAX)
+ if (reason >= SWAP_COMPACT_MEM_LEVEL_CRITICAL && reason < SWAP_COMPACT_RESASON_MAX)
return reasons_table[reason];
return "";
}
projects / platform / core / system / resourced.git / commitdiff