+++ /dev/null
-/*
- * resourced
- *
- * Copyright (c) 2012 - 2019 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 vmpressure-lowmem-handler.c
- *
- * @desc lowmem handler using memcgroup
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved.
- *
- */
-
-#include <stdio.h>
-#include <fcntl.h>
-#include <assert.h>
-#include <limits.h>
-#include <vconf.h>
-#include <unistd.h>
-#include <time.h>
-#include <limits.h>
-#include <dirent.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/shm.h>
-#include <sys/sysinfo.h>
-#include <sys/time.h>
-#include <sys/resource.h>
-#include <ctype.h>
-#include <bundle.h>
-#include <eventsystem.h>
-#include <malloc.h>
-
-#include "trace.h"
-#include "cgroup.h"
-#include "lowmem-handler.h"
-#include "proc-common.h"
-#include "procfs.h"
-#include "freezer.h"
-#include "resourced.h"
-#include "macro.h"
-#include "notifier.h"
-#include "config-parser.h"
-#include "module.h"
-#include "swap-common.h"
-#include "cgroup.h"
-#include "memory-cgroup.h"
-#include "heart-common.h"
-#include "proc-main.h"
-#include "dbus-handler.h"
-#include "util.h"
-#include "fd-handler.h"
-#include "resourced-helper-worker.h"
-#include "safe-kill.h"
-#include "dedup-common.h"
-
-#define LOWMEM_THRES_INIT 0
-
-#define MEMPS_EXEC_PATH "usr/bin/memps"
-#define MEM_CONF_FILE RD_CONFIG_FILE(limiter)
-#define MEM_SECTION "Memory"
-#define MEM_VIP_SECTION "VIP_PROCESS"
-#define MEM_VIP_PREDEFINE "PREDEFINE"
-#define MEM_POPUP_SECTION "POPUP"
-#define MEM_POPUP_STRING "oom_popup"
-#define MEM_BG_RECLAIM_SECTION "BackgroundReclaim"
-#define MEM_BG_RECLAIM_STRING "AfterScreenDim"
-#define MEM_LOGGING_SECTION "Logging"
-
-#define BUF_MAX 1024
-#define MAX_VICTIMS_BETWEEN_CHECK 3
-#define MAX_PROACTIVE_LOW_VICTIMS 2
-#define MAX_PROACTIVE_HIGH_VICTIMS 4
-#define FOREGROUND_VICTIMS 1
-#define OOM_TIMER_INTERVAL 2
-#define OOM_KILLER_PRIORITY -20
-#define THRESHOLD_MARGIN 10 /* MB */
-
-#define MEM_SIZE_64 64 /* MB */
-#define MEM_SIZE_256 256 /* MB */
-#define MEM_SIZE_448 448 /* MB */
-#define MEM_SIZE_512 512 /* MB */
-#define MEM_SIZE_768 768 /* MB */
-#define MEM_SIZE_1024 1024 /* MB */
-#define MEM_SIZE_2048 2048 /* MB */
-
-/* thresholds for 64M RAM*/
-#define PROACTIVE_64_THRES 10 /* MB */
-#define PROACTIVE_64_LEAVE 30 /* 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 */
-#define CGROUP_ROOT_64_NUM_VICTIMS 1
-
-/* thresholds for 256M RAM */
-#define PROACTIVE_256_THRES 50 /* MB */
-#define PROACTIVE_256_LEAVE 80 /* 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 */
-#define CGROUP_ROOT_256_NUM_VICTIMS 2
-
-/* threshold for 448M RAM */
-#define PROACTIVE_448_THRES 80 /* MB */
-#define PROACTIVE_448_LEAVE 100 /* MB */
-#define CGROUP_ROOT_448_THRES_DEDUP 120 /* MB */
-#define CGROUP_ROOT_448_THRES_SWAP 100 /* MB */
-#define CGROUP_ROOT_448_THRES_LOW 60 /* MB */
-#define CGROUP_ROOT_448_THRES_MEDIUM 50 /* MB */
-#define CGROUP_ROOT_448_THRES_LEAVE 70 /* MB */
-#define CGROUP_ROOT_448_NUM_VICTIMS 5
-
-/* threshold for 512M RAM */
-#define PROACTIVE_512_THRES 100 /* MB */
-#define PROACTIVE_512_LEAVE 80 /* MB */
-#define CGROUP_ROOT_512_THRES_DEDUP 140 /* MB */
-#define CGROUP_ROOT_512_THRES_SWAP 100 /* MB */
-#define CGROUP_ROOT_512_THRES_LOW 70 /* MB */
-#define CGROUP_ROOT_512_THRES_MEDIUM 60 /* MB */
-#define CGROUP_ROOT_512_THRES_LEAVE 80 /* MB */
-#define CGROUP_ROOT_512_NUM_VICTIMS 5
-
-/* threshold for 768 RAM */
-#define PROACTIVE_768_THRES 100 /* MB */
-#define PROACTIVE_768_LEAVE 130 /* MB */
-#define CGROUP_ROOT_768_THRES_DEDUP 180 /* MB */
-#define CGROUP_ROOT_768_THRES_SWAP 150 /* MB */
-#define CGROUP_ROOT_768_THRES_LOW 90 /* MB */
-#define CGROUP_ROOT_768_THRES_MEDIUM 80 /* MB */
-#define CGROUP_ROOT_768_THRES_LEAVE 100 /* MB */
-#define CGROUP_ROOT_768_NUM_VICTIMS 5
-
-/* threshold for more than 1024M RAM */
-#define PROACTIVE_1024_THRES 230 /* MB */
-#define PROACTIVE_1024_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 120 /* MB */
-#define CGROUP_ROOT_1024_THRES_MEDIUM 100 /* MB */
-#define CGROUP_ROOT_1024_THRES_LEAVE 150 /* MB */
-#define CGROUP_ROOT_1024_NUM_VICTIMS 5
-
-/* threshold for more than 2048M RAM */
-#define PROACTIVE_2048_THRES 200 /* MB */
-#define PROACTIVE_2048_LEAVE 500 /* 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 */
-#define CGROUP_ROOT_2048_NUM_VICTIMS 10
-
-/* threshold for more than 3072M RAM */
-#define PROACTIVE_3072_THRES 300 /* MB */
-#define PROACTIVE_3072_LEAVE 700 /* MB */
-#define CGROUP_ROOT_3072_THRES_DEDUP 600 /* MB */
-#define CGROUP_ROOT_3072_THRES_SWAP 500 /* MB */
-#define CGROUP_ROOT_3072_THRES_LOW 400 /* MB */
-#define CGROUP_ROOT_3072_THRES_MEDIUM 250 /* MB */
-#define CGROUP_ROOT_3072_THRES_LEAVE 500 /* MB */
-#define CGROUP_ROOT_3072_NUM_VICTIMS 10
-
-static unsigned proactive_threshold;
-static unsigned proactive_leave;
-static unsigned lmk_start_threshold;
-
-static char *event_level = MEMCG_DEFAULT_EVENT_LEVEL;
-
-/**
- * Resourced Low Memory Killer
- * NOTE: planned to be moved to a separate file.
- */
-/*-------------------------------------------------*/
-#define OOM_TIMER_INTERVAL_SEC 2
-#define LMW_LOOP_WAIT_TIMEOUT_MSEC OOM_TIMER_INTERVAL_SEC*(G_USEC_PER_SEC)
-#define LMW_RETRY_WAIT_TIMEOUT_MSEC (G_USEC_PER_SEC)
-
-struct lowmem_control {
- /*
- * For each queued request the following properties
- * are required with two exceptions:
- * - status is being set by LMK
- * - callback is optional
- */
- /* Processing flags*/
- unsigned int flags;
- /* Indictator for OOM score of targeted processes */
- enum cgroup_type type;
-
- /* Desired size to be restored - level to be reached (MB)*/
- unsigned int size;
- /* Max number of processes to be considered */
- unsigned int count;
- /* Memory reclaim status */
- int status;
- /*
- * Optional - if set, will be triggered by LMK once the request
- * is handled.
- */
- void (*callback) (struct lowmem_control *);
-};
-
-struct lowmem_worker {
- pthread_t worker_thread;
- GAsyncQueue *queue;
- int active;
- int running;
-};
-
-static struct lowmem_worker lmw;
-
-static int memlog_enabled;
-static int memlog_nr_max = DEFAULT_MEMLOG_NR_MAX;
-/* remove logfiles to reduce to this threshold.
- * it is about five-sixths of the memlog_nr_max. */
-static int memlog_remove_batch_thres = (DEFAULT_MEMLOG_NR_MAX * 5) / 6;
-static char *memlog_path = DEFAULT_MEMLOG_PATH;
-static char *memlog_prefix[MEMLOG_MAX];
-
-#define LOWMEM_WORKER_IS_ACTIVE(_lmw) g_atomic_int_get(&(_lmw)->active)
-#define LOWMEM_WORKER_ACTIVATE(_lmw) g_atomic_int_set(&(_lmw)->active, 1)
-#define LOWMEM_WORKER_DEACTIVATE(_lmw) g_atomic_int_set(&(_lmw)->active, 0)
-
-#define LOWMEM_WORKER_IS_RUNNING(_lmw) g_atomic_int_get(&(_lmw)->running)
-#define LOWMEM_WORKER_RUN(_lmw) g_atomic_int_set(&(_lmw)->running, 1)
-#define LOWMEM_WORKER_IDLE(_lmw) g_atomic_int_set(&(_lmw)->running, 0)
-
-#define LOWMEM_NEW_REQUEST() g_slice_new0(struct lowmem_control)
-
-#define LOWMEM_DESTROY_REQUEST(_ctl) \
- g_slice_free(typeof(*(_ctl)), _ctl); \
-
-#define LOWMEM_SET_REQUEST(c, __flags, __type, __size, __count, __cb) \
-{ \
- (c)->flags = __flags; (c)->type = __type; \
- (c)->size = __size; (c)->count = __count; \
- (c)->callback = __cb; \
-}
-
-#define BUFF_MAX 255
-#define APP_ATTR_PATH "/proc/%d/attr/current"
-
-static int get_privilege(pid_t pid, char *name, size_t len)
-{
- char path[PATH_MAX];
- char attr[BUFF_MAX];
- size_t attr_len;
- FILE *fp;
-
- snprintf(path, sizeof(path), APP_ATTR_PATH, pid);
-
- fp = fopen(path, "r");
- if (!fp)
- return -errno;
-
- attr_len = fread(attr, 1, sizeof(attr) - 1, fp);
- fclose(fp);
- if (attr_len <= 0)
- return -ENOENT;
-
- attr[attr_len] = '\0';
-
- snprintf(name, len, "%s", attr);
- return 0;
-}
-
-static int is_app(pid_t pid)
-{
- char attr[BUFF_MAX];
- size_t len;
- int ret;
-
- ret = get_privilege(pid, attr, sizeof(attr));
- if (ret < 0) {
- _E("Failed to get privilege of PID(%d).", pid);
- return -1;
- }
-
- len = strlen(attr) + 1;
-
- if (!strncmp("System", attr, len))
- return 0;
-
- if (!strncmp("User", attr, len))
- return 0;
-
- if (!strncmp("System::Privileged", attr, len))
- return 0;
-
- return 1;
-}
-
-
-static void lowmem_queue_request(struct lowmem_worker *lmw,
- struct lowmem_control *ctl)
-{
- if (LOWMEM_WORKER_IS_ACTIVE(lmw))
- g_async_queue_push(lmw->queue, ctl);
-}
-
-/* internal */
-static void lowmem_drain_queue(struct lowmem_worker *lmw)
-{
- struct lowmem_control *ctl;
-
- g_async_queue_lock(lmw->queue);
- while ((ctl = g_async_queue_try_pop_unlocked(lmw->queue))) {
- if (ctl->callback)
- ctl->callback(ctl);
- LOWMEM_DESTROY_REQUEST(ctl);
- }
- g_async_queue_unlock(lmw->queue);
-}
-
-static void lowmem_request_destroy(gpointer data)
-{
- struct lowmem_control *ctl = (struct lowmem_control*) data;
-
- if (ctl->callback)
- ctl->callback(ctl);
- LOWMEM_DESTROY_REQUEST(ctl);
-}
-
-/*-------------------------------------------------*/
-
-/* low memory action function for cgroup */
-static void memory_cgroup_proactive_lmk_act(enum cgroup_type type, struct memcg_info *mi);
-/* low memory action function */
-static void high_mem_act(void);
-static void swap_activate_act(void);
-static void swap_compact_act(void);
-static void lmk_act(void);
-
-
-static size_t cur_mem_state = MEM_LEVEL_HIGH;
-static int num_max_victims = MAX_MEMORY_CGROUP_VICTIMS;
-static int num_vict_between_check = MAX_VICTIMS_BETWEEN_CHECK;
-
-static unsigned long totalram;
-static unsigned long ktotalram;
-
-static struct module_ops memory_modules_ops;
-static const struct module_ops *lowmem_ops;
-static bool oom_popup_enable;
-static bool oom_popup;
-static bool memcg_swap_status;
-static bool bg_reclaim;
-static int fragmentation_size;
-
-static const char *convert_cgroup_type_to_str(int type)
-{
- static const char *type_table[] =
- {"/", "VIP", "High", "Medium", "Lowest"};
- if (type >= CGROUP_ROOT && type <= CGROUP_LOW)
- return type_table[type];
- else
- return "Error";
-}
-
-static const char *convert_status_to_str(int status)
-{
- static const char *status_table[] =
- {"none", "done", "drop", "cont", "retry", "next_type"};
- if(status >= LOWMEM_RECLAIM_NONE && status <= LOWMEM_RECLAIM_NEXT_TYPE)
- return status_table[status];
- return "error status";
-}
-
-static const char *convert_memstate_to_str(int mem_state)
-{
- static const char *state_table[] = {"mem normal", "mem dedup", "mem swap", "mem low",
- "mem medium"};
- if (mem_state >= 0 && mem_state < MEM_LEVEL_MAX)
- return state_table[mem_state];
- return "";
-}
-
-static int lowmem_launch_oompopup(void)
-{
- GVariantBuilder *const gv_builder = g_variant_builder_new(G_VARIANT_TYPE("a{ss}"));
- g_variant_builder_add(gv_builder, "{ss}", "_SYSPOPUP_CONTENT_", "lowmemory_oom");
-
- GVariant *const params = g_variant_new("(a{ss})", gv_builder);
- g_variant_builder_unref(gv_builder);
-
- int ret = d_bus_call_method_sync_gvariant(SYSTEM_POPUP_BUS_NAME,
- SYSTEM_POPUP_PATH_SYSTEM, SYSTEM_POPUP_IFACE_SYSTEM,
- "PopupLaunch", params);
-
- g_variant_unref(params);
-
- return ret;
-}
-
-static inline void get_total_memory(void)
-{
- struct sysinfo si;
- if (totalram)
- return;
-
- if (!sysinfo(&si)) {
- totalram = si.totalram;
- ktotalram = BYTE_TO_KBYTE(totalram);
- }
-}
-
-static int lowmem_mem_usage_uss(pid_t pid, unsigned int *usage)
-{
- unsigned int uss, zram = 0;
- int ret;
-
- *usage = 0;
-
- /*
- * In lowmem we need to know memory size of processes to
- * for terminating apps. To get most real value of usage
- * we should use USS + ZRAM usage for selected process.
- *
- * Those values will contain the most approximated amount
- * of memory that will be freed after process termination.
- */
- ret = proc_get_uss(pid, &uss);
- if (ret != RESOURCED_ERROR_NONE)
- return ret;
-
- if (swap_get_state() == SWAP_ON) {
- ret = proc_get_zram_usage(pid, &zram);
- /* If we don't get zram usage, it's not a problem */
- if (ret != RESOURCED_ERROR_NONE)
- zram = 0;
- }
- *usage = uss + zram;
- return RESOURCED_ERROR_NONE;
-}
-
-unsigned int lowmem_get_task_mem_usage_rss(const struct task_info *tsk)
-{
- unsigned int size = 0, total_size = 0;
- int index, ret;
- pid_t pid;
-
- /*
- * If pids are allocated only when there are multiple processes with
- * the same pgid e.g., browser and web process. Mostly, single process
- * is used.
- */
- if (tsk->pids == NULL) {
- ret = proc_get_ram_usage(tsk->pid, &size);
-
- /* If there is no proc entry for given pid the process
- * should be abandoned during further processing
- */
- if (ret < 0)
- _D("failed to get rss memory usage of %d", tsk->pid);
-
- return size;
- }
-
- for (index = 0; index < tsk->pids->len; index++) {
- pid = g_array_index(tsk->pids, pid_t, index);
- ret = proc_get_ram_usage(pid, &size);
- if (ret != RESOURCED_ERROR_NONE)
- continue;
- total_size += size;
- }
-
- return total_size;
-}
-
-static int memps_file_select(const struct dirent *entry)
-{
- return strstr(entry->d_name, "memps") ? 1 : 0;
-}
-
-static char *strrstr(const char *str, const char *token)
-{
- int len = strlen(token);
- const char *p = str + strlen(str);
-
- while (str <= --p)
- if (p[0] == token[0] && strncmp(p, token, len) == 0)
- return (char *)p;
-
- return NULL;
-}
-
-static int timesort(const struct dirent **a, const struct dirent **b)
-{
- long long time1 = 0;
- long long time2 = 0;
- char *ptr;
-
- ptr = strrstr((*a)->d_name, "_");
- if (ptr && *++ptr)
- time1 = atoll(ptr);
-
- ptr = strrstr((*b)->d_name, "_");
- if (ptr && *++ptr)
- time2 = atoll(ptr);
-
- return (time1 - time2);
-}
-
-static int clear_logs(void *data)
-{
- struct dirent **namelist;
- int n, i, ret;
- char fpath[BUF_MAX];
- char *fname;
- char *dir = (char*)data;
- int len;
-
- if (!memlog_enabled)
- return RESOURCED_ERROR_NONE;
-
- if (!dir)
- return RESOURCED_ERROR_NONE;
-
- len = strlen(dir);
- if (len <= 0 || len >= sizeof fpath - 1) {
- _E("Invalid parameter - Directory path is too short or too long");
- return RESOURCED_ERROR_INVALID_PARAMETER;
- }
-
- n = scandir(dir, &namelist, memps_file_select, timesort);
-
- _D("num of log files %d", n);
- if (n <= memlog_nr_max) {
- while (n--)
- free(namelist[n]);
- free(namelist);
- return RESOURCED_ERROR_NONE;
- }
-
- strncpy(fpath, dir, sizeof fpath - 1);
- fpath[sizeof fpath - 1] = '\0';
- fname = fpath + len;
- *fname++ = '/';
-
- len = sizeof fpath - len - 1;
- for (i = 0; i < n; i++) {
- if (i < n - memlog_remove_batch_thres) {
- if (strlen(namelist[i]->d_name) > len - 1)
- continue;
- strncpy(fname, namelist[i]->d_name, len - 1);
- fpath[sizeof fpath - 1] = '\0';
- _D("remove log file %s", fpath);
- ret = remove(fpath);
- if (ret < 0)
- _E("%s file cannot removed", fpath);
- }
-
- free(namelist[i]);
- }
- free(namelist);
- return RESOURCED_ERROR_NONE;
-}
-
-void make_memps_log(enum mem_log memlog, pid_t pid, char *victim_name)
-{
- time_t now;
- struct tm cur_tm;
- char new_log[BUF_MAX];
- static pid_t old_pid;
- int oom_score_adj = 0, ret;
- char *prefix;
-
- if (!memlog_enabled)
- return;
-
- if (memlog < MEMLOG_MEMPS || memlog >= MEMLOG_MAX)
- return;
-
- prefix = memlog_prefix[memlog];
-
- if (old_pid == pid)
- return;
-
- old_pid = pid;
-
- now = time(NULL);
-
- if (localtime_r(&now, &cur_tm) == NULL) {
- _E("Fail to get localtime");
- return;
- }
-
- snprintf(new_log, sizeof(new_log),
- "%s/%s_%s_%d_%.4d%.2d%.2d%.2d%.2d%.2d", memlog_path, prefix, victim_name,
- pid, (1900 + cur_tm.tm_year), 1 + cur_tm.tm_mon,
- cur_tm.tm_mday, cur_tm.tm_hour, cur_tm.tm_min,
- cur_tm.tm_sec);
-
- ret = proc_get_oom_score_adj(pid, &oom_score_adj);
- if (ret || oom_score_adj > OOMADJ_BACKGRD_LOCKED) {
-
- _cleanup_fclose_ FILE *f = NULL;
-
- f = fopen(new_log, "w");
- if (!f) {
- _E("fail to create memps log %s", new_log);
- return;
- }
- proc_print_meninfo(f);
-
- } else {
-
- const char *argv[4] = {"/usr/bin/memps", "-f", NULL, NULL};
-
- argv[2] = new_log;
- exec_cmd(ARRAY_SIZE(argv), argv);
- }
-
- /* best effort to limit the number of logfiles up to memlog_nr_max */
- clear_logs(memlog_path);
-}
-
-static int lowmem_kill_victim(const struct task_info *tsk,
- int flags, int memps_log, unsigned int *victim_size)
-{
- pid_t pid;
- int ret;
- char appname[PATH_MAX];
- int sigterm = 0;
- struct proc_app_info *pai;
-
- pid = tsk->pid;
-
- if (pid <= 0 || pid == getpid())
- return RESOURCED_ERROR_FAIL;
-
- ret = proc_get_cmdline(pid, appname, sizeof appname);
- if (ret == RESOURCED_ERROR_FAIL)
- return RESOURCED_ERROR_FAIL;
-
- if (!strcmp("memps", appname) ||
- !strcmp("crash-worker", appname) ||
- !strcmp("system-syspopup", appname)) {
- _E("%s(%d) was selected, skip it", appname, pid);
- return RESOURCED_ERROR_FAIL;
- }
-
- if (!memps_log)
- make_memps_log(MEMLOG_MEMPS, pid, appname);
-
- pai = tsk->pai;
- if (pai) {
- resourced_proc_status_change(PROC_CGROUP_SET_TERMINATE_REQUEST,
- pid, NULL, NULL, PROC_TYPE_NONE);
-
- if (tsk->oom_score_lru <= OOMADJ_BACKGRD_LOCKED) {
- sigterm = 1;
- } else if (tsk->oom_score_lru > OOMADJ_BACKGRD_LOCKED && tsk->oom_score_lru < OOMADJ_BACKGRD_UNLOCKED) {
- int app_flag = pai->flags;
- sigterm = app_flag & PROC_SIGTERM;
- }
-
- if (pai->memory.oom_killed)
- sigterm = 0;
-
- pai->memory.oom_killed = true;
- }
-
- if (sigterm)
- safe_kill(pid, SIGTERM);
- else
- safe_kill(pid, SIGKILL);
-
- _D("[LMK] we killed, force(%d), %d (%s) score = %d, size: rss = %u, sigterm = %d\n",
- flags & OOM_FORCE, pid, appname, tsk->oom_score_adj,
- tsk->size, sigterm);
- *victim_size = tsk->size;
-
- if (tsk->oom_score_lru > OOMADJ_FOREGRD_UNLOCKED)
- return RESOURCED_ERROR_NONE;
-
- if (oom_popup_enable && !oom_popup) {
- lowmem_launch_oompopup();
- oom_popup = true;
- }
- if (memps_log)
- make_memps_log(MEMLOG_MEMPS, pid, appname);
-
- return RESOURCED_ERROR_NONE;
-}
-
-/* return LOWMEM_RECLAIM_CONT when killing should be continued */
-static int lowmem_check_kill_continued(struct task_info *tsk, int flags)
-{
- unsigned int available;
-
- /*
- * Processes with the priority higher than perceptible are killed
- * only when the available memory is less than dynamic oom threshold.
- */
- if (tsk->oom_score_lru > OOMADJ_BACKGRD_PERCEPTIBLE)
- return LOWMEM_RECLAIM_CONT;
-
- if (flags & (OOM_FORCE|OOM_SINGLE_SHOT)) {
- _I("[LMK] %d is dropped during force kill, flag=%d",
- tsk->pid, flags);
- return LOWMEM_RECLAIM_DROP;
- }
- available = proc_get_mem_available();
- if (available > lmk_start_threshold) {
- _I("[LMK] available=%d MB, larger than %u MB, do not kill foreground",
- available, lmk_start_threshold);
- return LOWMEM_RECLAIM_RETRY;
- }
- return LOWMEM_RECLAIM_CONT;
-}
-
-static int compare_victims(const struct task_info *ta, const struct task_info *tb)
-{
- unsigned int pa, pb;
-
- assert(ta != NULL);
- assert(tb != NULL);
- /*
- * followed by kernel badness point calculation using heuristic.
- * oom_score_adj is normalized by its unit, which varies -1000 ~ 1000.
- */
- pa = ta->oom_score_lru * (ktotalram / 2000) + ta->size;
- pb = tb->oom_score_lru * (ktotalram / 2000) + tb->size;
-
- return pb - pa;
-}
-
-static void lowmem_free_task_info_array(GArray *array)
-{
- int i;
-
- for (i = 0; i < array->len; i++) {
- struct task_info *tsk;
-
- tsk = &g_array_index(array, struct task_info, i);
- if (tsk->pids)
- g_array_free(tsk->pids, true);
- }
-
- g_array_free(array, true);
-}
-
-static inline int is_dynamic_process_killer(int flags)
-{
- return (flags & OOM_FORCE) && !(flags & OOM_NOMEMORY_CHECK);
-}
-
-static unsigned int is_memory_recovered(unsigned int *avail, unsigned int thres)
-{
- unsigned int available = proc_get_mem_available();
- unsigned int should_be_freed = 0;
-
- if (available < thres)
- should_be_freed = thres - available;
- /*
- * free THRESHOLD_MARGIN more than real should be freed,
- * because launching app is consuming up the memory.
- */
- if (should_be_freed > 0)
- should_be_freed += THRESHOLD_MARGIN;
-
- *avail = available;
-
- return should_be_freed;
-}
-
-static int lowmem_get_pids_proc(GArray *pids)
-{
- DIR *dp;
- struct dirent *dentry;
-
- dp = opendir("/proc");
- if (!dp) {
- _E("fail to open /proc");
- return RESOURCED_ERROR_FAIL;
- }
- while ((dentry = readdir(dp)) != NULL) {
- struct task_info tsk;
- pid_t pid = 0, pgid = 0;
- int oom = 0;
-
- if (!isdigit(dentry->d_name[0]))
- continue;
-
- pid = (pid_t)atoi(dentry->d_name);
- if (pid < 1)
- /* skip invalid pids or kernel processes */
- continue;
-
- pgid = getpgid(pid);
- if (pgid < 1)
- continue;
-
- if(is_app(pid) != 1)
- continue;
-
- if (proc_get_oom_score_adj(pid, &oom) < 0) {
- _D("pid(%d) was already terminated", pid);
- continue;
- }
-
- /* VIP pids should be excluded from the LMK list */
- if (cgroup_get_type(oom) == CGROUP_VIP)
- continue;
-
- /*
- * Check whether this array includes applications or not.
- * If it doesn't require to get applications
- * and pid has been already included in pai,
- * skip to append.
- */
- if (oom > OOMADJ_SU && oom <= OOMADJ_APP_MAX)
- continue;
-
- /*
- * Currently, for tasks in the memory cgroup,
- * do not consider multiple tasks with one pgid.
- */
- tsk.pid = pid;
- tsk.pgid = pgid;
- tsk.oom_score_adj = oom;
- tsk.oom_score_lru = oom;
- tsk.pids = NULL;
- tsk.size = lowmem_get_task_mem_usage_rss(&tsk);
- tsk.pai = NULL;
-
- g_array_append_val(pids, tsk);
- }
-
- closedir(dp);
- return RESOURCED_ERROR_NONE;
-}
-
-/**
- * @brief Terminate up to max_victims processes after finding them from pai.
- It depends on proc_app_info lists
- and it also reference systemservice cgroup
- because some processes in this group don't have proc_app_info.
- *
- * @max_victims: max number of processes to be terminated
- * @start_oom: find victims from start oom adj score value
- * @end_oom: find victims to end oom adj score value
- * @should_be_freed: amount of memory to be reclaimed (in MB)
- * @total_size[out]: total size of possibly reclaimed memory (required)
- * @completed: final outcome (optional)
- * @threshold: desired value of memory available
- */
-static int lowmem_kill_victims(int max_victims,
- int start_oom, int end_oom, unsigned should_be_freed, int flags,
- unsigned int *total_size, int *completed, int threshold)
-{
- int total_count = 0;
- GSList *proc_app_list = NULL;
- int i, ret, victim = 0;
- unsigned int victim_size = 0;
- unsigned int total_victim_size = 0;
- int status = LOWMEM_RECLAIM_NONE;
- GArray *candidates = NULL;
- GSList *iter, *iterchild;
- struct proc_app_info *pai = NULL;
- int oom_score_adj;
- int should_be_freed_kb = MBYTE_TO_KBYTE(should_be_freed);
-
- candidates = g_array_new(false, false, sizeof(struct task_info));
-
- proc_app_list = proc_app_list_open();
- gslist_for_each_item(iter, proc_app_list) {
- struct task_info ti;
-
- total_count++;
- pai = (struct proc_app_info *)iter->data;
- if (!pai->main_pid)
- continue;
-
- oom_score_adj = pai->memory.oom_score_adj;
- if (oom_score_adj > end_oom || oom_score_adj < start_oom)
- continue;
-
- if ((flags & OOM_REVISE) && pai->memory.oom_killed)
- continue;
-
- ti.pid = pai->main_pid;
- ti.pgid = getpgid(ti.pid);
- ti.oom_score_adj = oom_score_adj;
- ti.pai = pai;
-
- /*
- * Before oom_score_adj of favourite (oom_score = 270) applications is
- * independent of lru_state, now we consider lru_state, while
- * killing favourite process.
- */
-
- if (oom_score_adj == OOMADJ_FAVORITE && pai->lru_state >= PROC_BACKGROUND)
- ti.oom_score_lru = OOMADJ_FAVORITE + OOMADJ_FAVORITE_APP_INCREASE * pai->lru_state;
- else
- ti.oom_score_lru = oom_score_adj;
-
- if (pai->childs) {
- ti.pids = g_array_new(false, false, sizeof(pid_t));
- g_array_append_val(ti.pids, ti.pid);
- gslist_for_each_item(iterchild, pai->childs) {
- pid_t child = GPOINTER_TO_PID(iterchild->data);
- g_array_append_val(ti.pids, child);
- }
- } else
- ti.pids = NULL;
-
- g_array_append_val(candidates, ti);
- }
-
- proc_app_list_close();
-
- if (!candidates->len) {
- status = LOWMEM_RECLAIM_NEXT_TYPE;
- goto leave;
- }
- else {
- _D("[LMK] candidate ratio=%d/%d", candidates->len, total_count);
- }
-
- for (i = 0; i < candidates->len; i++) {
- struct task_info *tsk;
-
- tsk = &g_array_index(candidates, struct task_info, i);
- tsk->size = lowmem_get_task_mem_usage_rss(tsk);
- }
-
- /*
- * In case of start_oom == OOMADJ_SU,
- * we're going to try to kill some of processes in /proc
- * to handle low memory situation.
- * It can find malicious system process even though it has low oom score.
- */
- if (start_oom == OOMADJ_SU)
- lowmem_get_pids_proc(candidates);
-
- g_array_sort(candidates, (GCompareFunc)compare_victims);
-
- for (i = 0; i < candidates->len; i++) {
- struct task_info *tsk;
-
- if (i >= max_victims) {
- status = LOWMEM_RECLAIM_NEXT_TYPE;
- break;
- }
-
- /*
- * Available memory is checking only every
- * num_vict_between_check process for reducing burden.
- */
- if (!(i % num_vict_between_check)) {
- if (proc_get_mem_available() > threshold) {
- status = LOWMEM_RECLAIM_DONE;
- break;
- }
- }
-
- if (!(flags & OOM_NOMEMORY_CHECK) &&
- total_victim_size >= should_be_freed_kb) {
- _D("[LMK] victim=%d, max_victims=%d, total_size=%uKB",
- victim, max_victims, total_victim_size);
- status = LOWMEM_RECLAIM_DONE;
- break;
- }
-
- tsk = &g_array_index(candidates, struct task_info, i);
-
- status = lowmem_check_kill_continued(tsk, flags);
- if (status != LOWMEM_RECLAIM_CONT)
- break;
-
- _I("[LMK] select victims from proc_app_list pid(%d) with oom_score_adj(%d)\n", tsk->pid, tsk->oom_score_adj);
-
- ret = lowmem_kill_victim(tsk, flags, i, &victim_size);
- if (ret != RESOURCED_ERROR_NONE)
- continue;
- victim++;
- total_victim_size += victim_size;
- }
-
-leave:
- lowmem_free_task_info_array(candidates);
- *total_size = total_victim_size;
- if(*completed != LOWMEM_RECLAIM_CONT)
- *completed = status;
- else
- *completed = LOWMEM_RECLAIM_NEXT_TYPE;
- return victim;
-}
-
-static int calculate_range_of_oom(enum cgroup_type type, int *min, int *max)
-{
- if (type == CGROUP_VIP || type >= CGROUP_END || type <= CGROUP_TOP) {
- _E("cgroup type (%d) is out of scope", type);
- return RESOURCED_ERROR_FAIL;
- }
-
- *max = cgroup_get_highest_oom_score_adj(type);
- *min = cgroup_get_lowest_oom_score_adj(type);
-
- return RESOURCED_ERROR_NONE;
-}
-
-static void lowmem_handle_request(struct lowmem_control *ctl)
-{
- int start_oom, end_oom;
- int count = 0, victim_cnt = 0;
- int max_victim_cnt = ctl->count;
- int status = LOWMEM_RECLAIM_NONE;
- unsigned int available = 0;
- unsigned int total_size = 0;
- unsigned int current_size = 0;
- unsigned int reclaim_size, shortfall = 0;
- enum cgroup_type cgroup_type = ctl->type;
-
- available = proc_get_mem_available();
- reclaim_size = ctl->size > available
- ? ctl->size - available : 0;
-
- if (!reclaim_size) {
- status = LOWMEM_RECLAIM_DONE;
- goto done;
- }
-
-retry:
- /* Prepare LMK to start doing it's job. Check preconditions. */
- if (calculate_range_of_oom(cgroup_type, &start_oom, &end_oom))
- goto done;
-
- lmk_start_threshold = get_root_memcg_info()->threshold[MEM_LEVEL_OOM];
- shortfall = is_memory_recovered(&available, ctl->size);
-
- if (!shortfall || !reclaim_size) {
- status = LOWMEM_RECLAIM_DONE;
- goto done;
- }
-
- /* precaution */
- current_size = 0;
- victim_cnt = lowmem_kill_victims(max_victim_cnt, start_oom, end_oom,
- reclaim_size, ctl->flags, ¤t_size, &status, ctl->size);
-
- if (victim_cnt) {
- current_size = KBYTE_TO_MBYTE(current_size);
- reclaim_size -= reclaim_size > current_size
- ? current_size : reclaim_size;
- total_size += current_size;
- count += victim_cnt;
- _I("[LMK] current: kill %d victims, reclaim_size=%uMB from %d to %d status=%s",
- victim_cnt, current_size,
- start_oom, end_oom, convert_status_to_str(status));
- }
-
- if ((status == LOWMEM_RECLAIM_DONE) ||
- (status == LOWMEM_RECLAIM_DROP) ||
- (status == LOWMEM_RECLAIM_RETRY))
- goto done;
-
- /*
- * If it doesn't finish reclaiming memory in first operation,
- - if flags has OOM_IN_DEPTH,
- try to find victims again in the active cgroup.
- otherwise, just return because there is no more victims in the desired cgroup.
- - if flags has OOM_REVISE,
- it means that resourced can't find victims from proc_app_list.
- So, it should search victims or malicious process from /proc.
- But searching /proc leads to abnormal behaviour.
- (Make sluggish or kill same victims continuously)
- Thus, otherwise, just return in first operation and wait some period.
- */
- if (cgroup_type == CGROUP_LOW) {
- cgroup_type = CGROUP_MEDIUM;
- goto retry;
- } else if ((cgroup_type == CGROUP_MEDIUM) && (ctl->flags & OOM_IN_DEPTH)) {
- cgroup_type = CGROUP_HIGH;
- if(ctl->flags & OOM_FORCE)
- max_victim_cnt = FOREGROUND_VICTIMS;
- goto retry;
- } else if ((cgroup_type == CGROUP_HIGH) && (ctl->flags & OOM_IN_DEPTH)) {
- status = LOWMEM_RECLAIM_RETRY;
- ctl->type = CGROUP_ROOT;
- }
- else if (cgroup_type == CGROUP_ROOT) {
- status = LOWMEM_RECLAIM_RETRY;
- }
-done:
- _I("[LMK] Done: killed %d processes reclaimed=%uMB remaining=%uMB shortfall=%uMB status=%s",
- count, total_size, reclaim_size, shortfall, convert_status_to_str(status));
-
- /* After we finish reclaiming it's worth to remove oldest memps logs */
- if (count && memlog_enabled)
- request_helper_worker(CLEAR_LOGS, memlog_path, clear_logs, NULL);
- ctl->status = status;
-}
-
-static void *lowmem_reclaim_worker(void *arg)
-{
- struct lowmem_worker *lmw = (struct lowmem_worker *)arg;
-
- setpriority(PRIO_PROCESS, 0, OOM_KILLER_PRIORITY);
-
- g_async_queue_ref(lmw->queue);
-
- while (1) {
- int try_count = 0;
- struct lowmem_control *ctl;
-
- LOWMEM_WORKER_IDLE(lmw);
- /* Wait on any wake-up call */
- ctl = g_async_queue_pop(lmw->queue);
-
- if (ctl->flags & OOM_DROP)
- LOWMEM_DESTROY_REQUEST(ctl);
-
- if (!LOWMEM_WORKER_IS_ACTIVE(lmw) || !ctl)
- break;
-
- LOWMEM_WORKER_RUN(lmw);
-process_again:
- _D("[LMK] %d tries", ++try_count);
- lowmem_handle_request(ctl);
- /**
- * Case the process failed to reclaim requested amount of memory
- * or still under have memory pressure - try the timeout wait.
- * There is a chance this will get woken-up in a better reality.
- */
- if (ctl->status == LOWMEM_RECLAIM_RETRY &&
- !(ctl->flags & OOM_SINGLE_SHOT)) {
- unsigned int available = proc_get_mem_available();
-
- if (available >= ctl->size) {
- _I("[LMK] Memory restored: requested=%uMB available=%uMB\n",
- ctl->size, available);
- ctl->status = LOWMEM_RECLAIM_DONE;
- if (ctl->callback)
- ctl->callback(ctl);
- LOWMEM_DESTROY_REQUEST(ctl);
- LOWMEM_WORKER_IDLE(lmw);
- continue;
- }
-
- if (LOWMEM_WORKER_IS_ACTIVE(lmw)) {
- g_usleep(LMW_RETRY_WAIT_TIMEOUT_MSEC);
- ctl->flags |= OOM_REVISE;
- goto process_again;
- }
- }
-
- /*
- * The ctl callback would check available size again.
- * And it is last point in reclaiming worker.
- * Resourced sent SIGKILL signal to victim processes
- * so it should wait for a some seconds until each processes returns memory.
- */
- g_usleep(LMW_LOOP_WAIT_TIMEOUT_MSEC);
- if (ctl->callback)
- ctl->callback(ctl);
-
- /* The lmk becomes the owner of all queued requests .. */
- LOWMEM_DESTROY_REQUEST(ctl);
- LOWMEM_WORKER_IDLE(lmw);
- }
- g_async_queue_unref(lmw->queue);
- pthread_exit(NULL);
-}
-
-static void change_lowmem_state(unsigned int mem_state)
-{
- cur_mem_state = mem_state;
- lmk_start_threshold = get_root_memcg_info()->threshold[MEM_LEVEL_OOM];
-
- resourced_notify(RESOURCED_NOTIFIER_MEM_LEVEL_CHANGED,
- (void *)&cur_mem_state);
-}
-
-/* only app can call this function
- * that is, service cannot call the function
- */
-static void lowmem_swap_memory(char *path)
-{
- unsigned int available;
-
- 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_LEVEL_LOW &&
- available <= get_root_memcg_info()->threshold[MEM_LEVEL_LOW])
- swap_activate_act();
-
- resourced_notify(RESOURCED_NOTIFIER_SWAP_START, path);
- memcg_swap_status = true;
-}
-
-void lowmem_trigger_swap(pid_t pid, char *path, bool move)
-{
- int error;
- int oom_score_adj;
- int lowest_oom_score_adj;
-
- if (!path) {
- _E("[SWAP] Unknown memory cgroup path to swap");
- return;
- }
-
- /* In this case, corresponding process will be moved to memory CGROUP_LOW.
- */
- if (move) {
- error = proc_get_oom_score_adj(pid, &oom_score_adj);
- if (error) {
- _E("[SWAP] Cannot get oom_score_adj of pid (%d)", pid);
- return;
- }
-
- lowest_oom_score_adj = cgroup_get_lowest_oom_score_adj(CGROUP_LOW);
-
- if (oom_score_adj < lowest_oom_score_adj) {
- oom_score_adj = lowest_oom_score_adj;
- /* End of this funciton, 'lowmem_swap_memory()' funciton will be called */
- proc_set_oom_score_adj(pid, oom_score_adj, find_app_info(pid));
- return;
- }
- }
-
- /* Correponding process is already managed per app or service.
- * In addition, if some process is already located in the CGROUP_LOW, then just do swap
- */
- resourced_notify(RESOURCED_NOTIFIER_SWAP_START, path);
-}
-
-static void memory_level_send_system_event(int lv)
-{
- bundle *b;
- const char *str;
-
- switch (lv) {
- case MEM_LEVEL_HIGH:
- case MEM_LEVEL_MEDIUM:
- case MEM_LEVEL_LOW:
- str = EVT_VAL_MEMORY_NORMAL;
- break;
- case MEM_LEVEL_CRITICAL:
- str = EVT_VAL_MEMORY_SOFT_WARNING;
- break;
- case MEM_LEVEL_OOM:
- str = EVT_VAL_MEMORY_HARD_WARNING;
- break;
- default:
- _E("Invalid state");
- return;
- }
-
- b = bundle_create();
- if (!b) {
- _E("Failed to create bundle");
- return;
- }
-
- bundle_add_str(b, EVT_KEY_LOW_MEMORY, str);
- eventsystem_send_system_event(SYS_EVENT_LOW_MEMORY, b);
- bundle_free(b);
-}
-
-static void high_mem_act(void)
-{
- int ret, status;
-
- ret = vconf_get_int(VCONFKEY_SYSMAN_LOW_MEMORY, &status);
- if (ret)
- _D("vconf_get_int fail %s", VCONFKEY_SYSMAN_LOW_MEMORY);
- 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_LEVEL_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));
- memcg_swap_status = false;
- }
- if (proc_get_freezer_status() == CGROUP_FREEZER_PAUSED)
- resourced_notify(RESOURCED_NOTIFIER_FREEZER_CGROUP_STATE,
- (void *)CGROUP_FREEZER_ENABLED);
-}
-
-static void swap_activate_act(void)
-{
- int ret, status;
-
- ret = vconf_get_int(VCONFKEY_SYSMAN_LOW_MEMORY, &status);
- if (ret)
- _E("vconf get failed %s", VCONFKEY_SYSMAN_LOW_MEMORY);
-
- 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_LEVEL_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 (swap_get_state() != SWAP_ON)
- resourced_notify(RESOURCED_NOTIFIER_SWAP_ACTIVATE, NULL);
-}
-
-static void dedup_act(enum ksm_scan_mode mode)
-{
- int ret, status;
- int data;
-
- if (dedup_get_state() != DEDUP_ONE_SHOT)
- return;
-
- if (proc_get_freezer_status() == CGROUP_FREEZER_PAUSED)
- resourced_notify(RESOURCED_NOTIFIER_FREEZER_CGROUP_STATE,
- (void *)CGROUP_FREEZER_ENABLED);
-
- if (mode == KSM_SCAN_PARTIAL) {
- ret = vconf_get_int(VCONFKEY_SYSMAN_LOW_MEMORY, &status);
- if (ret)
- _E("vconf get failed %s", VCONFKEY_SYSMAN_LOW_MEMORY);
-
- 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_LEVEL_MEDIUM);
- }
- change_lowmem_state(MEM_LEVEL_MEDIUM);
-
- data = KSM_SCAN_PARTIAL;
- resourced_notify(RESOURCED_NOTIFIER_DEDUP_SCAN, &data);
- } else if (mode == KSM_SCAN_FULL) {
- data = KSM_SCAN_FULL;
- resourced_notify(RESOURCED_NOTIFIER_DEDUP_SCAN, &data);
- }
-}
-
-static void swap_compact_act(void)
-{
- 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_LEVEL_HIGH, 0);
-}
-
-static void lmk_act(void)
-{
- unsigned int available;
- int ret;
- int status = VCONFKEY_SYSMAN_LOW_MEMORY_NORMAL;
-
- /*
- * Don't trigger reclaim worker
- * if it is already running
- */
- if (LOWMEM_WORKER_IS_RUNNING(&lmw))
- return;
-
- ret = vconf_get_int(VCONFKEY_SYSMAN_LOW_MEMORY, &status);
- if (ret)
- _D("vconf_get_int fail %s", VCONFKEY_SYSMAN_LOW_MEMORY);
-
- 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,
- (void *)CGROUP_FREEZER_PAUSED);
- vconf_set_int(VCONFKEY_SYSMAN_LOW_MEMORY,
- VCONFKEY_SYSMAN_LOW_MEMORY_HARD_WARNING);
- }
- available = proc_get_mem_available();
-
- change_lowmem_state(MEM_LEVEL_OOM);
-
- if (available < get_root_memcg_info()->threshold_leave) {
- struct lowmem_control *ctl;
-
- ctl = LOWMEM_NEW_REQUEST();
- if (ctl) {
- LOWMEM_SET_REQUEST(ctl, OOM_IN_DEPTH,
- CGROUP_LOW, get_root_memcg_info()->threshold_leave,
- num_max_victims, medium_cb);
- lowmem_queue_request(&lmw, ctl);
- }
- }
-
- resourced_notify(RESOURCED_NOTIFIER_SWAP_COMPACT, (void *)SWAP_COMPACT_MEM_LEVEL_OOM);
-
- /*
- * Flush resourced memory such as other processes.
- * Resourced can use both many fast bins and sqlite3 cache memery.
- */
- malloc_trim(0);
-
- return;
-}
-
-static void lowmem_trigger_memory_state_action(int mem_state)
-{
- /*
- * Check if the state we want to set is different from current
- * But it should except this condition if mem_state is already medium.
- * Otherwise, recalim worker couldn't run any more.
- */
- if (mem_state != MEM_LEVEL_OOM && cur_mem_state == mem_state)
- return;
-
- switch (mem_state) {
- case MEM_LEVEL_HIGH:
- high_mem_act();
- break;
- case MEM_LEVEL_MEDIUM:
- dedup_act(KSM_SCAN_PARTIAL);
- break;
- case MEM_LEVEL_LOW:
- swap_activate_act();
- break;
- case MEM_LEVEL_CRITICAL:
- dedup_act(KSM_SCAN_FULL);
- swap_compact_act();
- break;
- case MEM_LEVEL_OOM:
- lmk_act();
- break;
- default:
- assert(0);
- }
-}
-
-static void lowmem_dump_cgroup_procs(struct memcg_info *mi)
-{
- int i;
- unsigned int size;
- pid_t pid;
- GArray *pids_array = NULL;
-
- cgroup_get_pids(mi->name, &pids_array);
-
- for (i = 0; i < pids_array->len; i++) {
- pid = g_array_index(pids_array, pid_t, i);
- lowmem_mem_usage_uss(pid, &size);
- _I("pid = %d, size = %u KB", pid, size);
- }
- g_array_free(pids_array, true);
-}
-
-static void memory_cgroup_proactive_lmk_act(enum cgroup_type type, struct memcg_info *mi)
-{
- struct lowmem_control *ctl;
-
- /* To Do: only start to kill fg victim when no pending fg victim */
- lowmem_dump_cgroup_procs(mi);
-
- ctl = LOWMEM_NEW_REQUEST();
- if (ctl) {
- LOWMEM_SET_REQUEST(ctl, OOM_SINGLE_SHOT | OOM_IN_DEPTH, type,
- mi->oomleave, num_max_victims, NULL);
- lowmem_queue_request(&lmw, ctl);
- }
-}
-
-static unsigned int check_mem_state(unsigned int available)
-{
- int 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_LEVEL_OOM && available <= lmk_start_threshold)
- break;
- }
-
- return mem_state;
-}
-
-/*static int load_bg_reclaim_config(struct parse_result *result, void *user_data)
-{
- if (!result)
- return RESOURCED_ERROR_INVALID_PARAMETER;
-
- if (strncmp(result->section, MEM_BG_RECLAIM_SECTION, strlen(MEM_BG_RECLAIM_SECTION)+1))
- return RESOURCED_ERROR_NONE;
-
- if (!strncmp(result->name, MEM_BG_RECLAIM_STRING, strlen(MEM_BG_RECLAIM_STRING)+1)) {
- if (!strncmp(result->value, "yes", strlen("yes")+1))
- bg_reclaim = true;
- else if (!strncmp(result->value, "no", strlen("no")+1))
- bg_reclaim = false;
- }
-
-
- return RESOURCED_ERROR_NONE;
-}
-
-static int load_popup_config(struct parse_result *result, void *user_data)
-{
- if (!result)
- return RESOURCED_ERROR_INVALID_PARAMETER;
-
- if (strncmp(result->section, MEM_POPUP_SECTION, strlen(MEM_POPUP_SECTION)+1))
- return RESOURCED_ERROR_NONE;
-
- if (!strncmp(result->name, MEM_POPUP_STRING, strlen(MEM_POPUP_STRING)+1)) {
- if (!strncmp(result->value, "yes", strlen("yes")+1))
- oom_popup_enable = true;
- else if (!strncmp(result->value, "no", strlen("no")+1))
- oom_popup_enable = false;
- }
-
-
- return RESOURCED_ERROR_NONE;
-}
-
-static int load_mem_log_config(struct parse_result *result, void *user_data)
-{
- if (!result)
- return RESOURCED_ERROR_INVALID_PARAMETER;
-
- if (strncmp(result->section, MEM_LOGGING_SECTION, strlen(MEM_LOGGING_SECTION)+1))
- return RESOURCED_ERROR_NONE;
-
- if (!strncmp(result->name, "Enable", strlen("Enable")+1)) {
- memlog_enabled = atoi(result->value);
- } else if (!strncmp(result->name, "LogPath", strlen("LogPath")+1)) {
- memlog_path = strdup(result->value);
- } else if (!strncmp(result->name, "MaxNumLogfile", strlen("MaxNumLogfile")+1)) {
- memlog_nr_max = atoi(result->value);
- memlog_remove_batch_thres = (memlog_nr_max * 5) / 6;
- } else if (!strncmp(result->name, "PrefixMemps", strlen("PrefixMemps")+1)) {
- memlog_prefix[MEMLOG_MEMPS] = strdup(result->value);
- } else if (!strncmp(result->name, "PrefixMempsMemLimit", strlen("PrefixMempsMemLimit")+1)) {
- memlog_prefix[MEMLOG_MEMPS_MEMLIMIT] = strdup(result->value);
- }
-
- return RESOURCED_ERROR_NONE;
-}
-
-static int set_memory_config(struct parse_result *result, void *user_data)
-{
- if (!result)
- return RESOURCED_ERROR_NONE;
-
- if (strncmp(result->section, MEM_SECTION, strlen(MEM_SECTION)+1))
- return RESOURCED_ERROR_NONE;
-
- if (!strncmp(result->name, "ThresholdDedup", strlen("ThresholdDedup")+1)) {
- int value = atoi(result->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_LEVEL_LOW, value);
- } else if (!strncmp(result->name, "ThresholdLow", strlen("ThresholdLow")+1)) {
- int value = atoi(result->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_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_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_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_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_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;
- 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(get_memcg_info(CGROUP_HIGH), 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);
- } 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);
- } else if (!strncmp(result->name, "NumMaxVictims", strlen("NumMaxVictims")+1)) {
- int value = atoi(result->value);
- num_max_victims = value;
- num_vict_between_check = value > MAX_MEMORY_CGROUP_VICTIMS/2
- ? 3 : value > MAX_MEMORY_CGROUP_VICTIMS/4
- ? 2 : 1;
- } else if (!strncmp(result->name, "ProactiveThreshold", strlen("ProactiveThreshold")+1)) {
- int value = atoi(result->value);
- proactive_threshold = value;
- } else if (!strncmp(result->name, "ProactiveLeave", strlen("ProactiveLeave")+1)) {
- int value = atoi(result->value);
- proactive_leave = value;
- } else if (!strncmp(result->name, "EventLevel", strlen("EventLevel")+1)) {
- if (strncmp(event_level, result->value, strlen(event_level)))
- event_level = strdup(result->value);
- if (!event_level)
- return RESOURCED_ERROR_OUT_OF_MEMORY;
- } else if (!strncmp(result->name, "SWAPPINESS", strlen("SWAPPINESS")+1)) {
- int value = atoi(result->value);
- memcg_set_default_swappiness(value);
- memcg_info_set_swappiness(get_memcg_info(CGROUP_ROOT), value);
- } else if (!strncmp(result->name, "FOREGROUND_SWAPPINESS", strlen("FOREGROUND_SWAPPINESS")+1)) {
- int value = atoi(result->value);
- memcg_info_set_swappiness(get_memcg_info(CGROUP_HIGH), value);
- } else if (!strncmp(result->name, "BACKGROUND_SWAPPINESS", strlen("BACKGROUND_SWAPPINESS")+1)) {
- int value = atoi(result->value);
- memcg_info_set_swappiness(get_memcg_info(CGROUP_MEDIUM), 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);
- } else if (!strncmp(result->name, "NumFragSize", strlen("NumFragSize")+1)) {
- fragmentation_size = atoi(result->value);
- }
-
- return RESOURCED_ERROR_NONE;
-}*/
-
-/* setup memcg parameters depending on total ram size. */
-static void setup_memcg_params(void)
-{
- unsigned long long total_ramsize;
-
- get_total_memory();
- total_ramsize = BYTE_TO_MBYTE(totalram);
-
- _D("Total: %llu MB", total_ramsize);
- if (total_ramsize <= MEM_SIZE_64) {
- /* set thresholds for ram size 64M */
- proactive_threshold = PROACTIVE_64_THRES;
- proactive_leave = PROACTIVE_64_LEAVE;
- 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_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_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_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_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_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_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_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;
- }
-
-}
-
-static void lowmem_move_memcgroup(int pid, int next_oom_score_adj, struct proc_app_info *pai)
-{
- int cur_oom_score_adj;
- int cur_memcg_idx;
- struct memcg_info *mi;
- int next_memcg_idx = cgroup_get_type(next_oom_score_adj);
-
- if(next_memcg_idx < CGROUP_VIP || next_memcg_idx > CGROUP_LOW) {
- _E("cgroup type (%d) should not be called", next_memcg_idx);
- return;
- }
- mi = get_memcg_info(next_memcg_idx);
-
- if (!mi) {
- return;
- }
-
- if (!pai) {
- cgroup_write_pid_fullpath(mi->name, pid);
- return;
- }
-
- /* parent pid */
- if (pai->main_pid == pid) {
- cur_oom_score_adj = pai->memory.oom_score_adj;
- cur_memcg_idx = cgroup_get_type(cur_oom_score_adj);
-
- /* -1 means that this pid is not yet registered at the memory cgroup
- * plz, reference proc_create_app_info function
- */
- if (cur_oom_score_adj != OOMADJ_APP_MAX + 10) {
- /* VIP processes should not be asked to move. */
- if (cur_memcg_idx <= CGROUP_VIP) {
- _I("[DEBUG] pid: %d, name: %s, cur_oom_score_adj: %d", pid, pai->appid, cur_oom_score_adj);
- _E("[DEBUG] current cgroup (%s) cannot be VIP or Root", convert_cgroup_type_to_str(cur_memcg_idx));
- return;
- }
- }
-
- _I("app (%s) memory cgroup move from %s to %s", pai->appid, convert_cgroup_type_to_str(cur_memcg_idx), convert_cgroup_type_to_str(next_memcg_idx));
-
- if (cur_oom_score_adj == next_oom_score_adj) {
- _D("next oom_score_adj (%d) is same with current one", next_oom_score_adj);
- return;
- }
-
- proc_set_process_memory_state(pai, next_memcg_idx, mi, next_oom_score_adj);
-
- if (!lowmem_limit_move_cgroup(pai))
- return;
-
- if(cur_memcg_idx == next_memcg_idx)
- return;
-
- cgroup_write_pid_fullpath(mi->name, pid);
- if (next_memcg_idx == CGROUP_LOW)
- lowmem_swap_memory(get_memcg_info(CGROUP_LOW)->name);
- }
- /* child pid */
- else {
- if (pai->memory.use_mem_limit)
- return;
-
- cgroup_write_pid_fullpath(mi->name, pid);
- }
-}
-
-static int lowmem_activate_worker(void)
-{
- int ret = RESOURCED_ERROR_NONE;
-
- if (LOWMEM_WORKER_IS_ACTIVE(&lmw)) {
- return ret;
- }
-
- lmw.queue = g_async_queue_new_full(lowmem_request_destroy);
- if (!lmw.queue) {
- _E("Failed to create request queue\n");
- return RESOURCED_ERROR_FAIL;
- }
- LOWMEM_WORKER_ACTIVATE(&lmw);
- ret = pthread_create(&lmw.worker_thread, NULL,
- (void *)lowmem_reclaim_worker, (void *)&lmw);
- if (ret) {
- LOWMEM_WORKER_DEACTIVATE(&lmw);
- _E("Failed to create LMK thread: %d\n", ret);
- } else {
- pthread_detach(lmw.worker_thread);
- ret = RESOURCED_ERROR_NONE;
- }
- return ret;
-}
-
-static void lowmem_deactivate_worker(void)
-{
- struct lowmem_control *ctl;
-
- if (!LOWMEM_WORKER_IS_ACTIVE(&lmw))
- return;
-
- LOWMEM_WORKER_DEACTIVATE(&lmw);
- lowmem_drain_queue(&lmw);
-
- ctl = LOWMEM_NEW_REQUEST();
- if (!ctl) {
- _E("Critical - g_slice alloc failed - Lowmem cannot be deactivated");
- return;
- }
- ctl->flags = OOM_DROP;
- g_async_queue_push(lmw.queue, ctl);
- g_async_queue_unref(lmw.queue);
-}
-
-static int lowmem_press_eventfd_read(int fd)
-{
- uint64_t dummy_state;
-
- return read(fd, &dummy_state, sizeof(dummy_state));
-}
-
-static void lowmem_press_root_cgroup_handler(void)
-{
- static unsigned int prev_available;
- unsigned int available;
- int mem_state;
-
- available = proc_get_mem_available();
- if (prev_available == available)
- return;
-
- mem_state = check_mem_state(available);
- lowmem_trigger_memory_state_action(mem_state);
-
- prev_available = available;
-}
-
-static void lowmem_press_cgroup_handler(enum cgroup_type type, struct memcg_info *mi)
-{
- unsigned int usage, threshold;
- int ret;
-
- ret = memcg_get_anon_usage(mi->name, &usage);
- if (ret) {
- _D("getting anonymous memory usage fails");
- return;
- }
-
- threshold = mi->threshold[MEM_LEVEL_OOM];
- if (usage >= threshold)
- memory_cgroup_proactive_lmk_act(type, mi);
- else
- _I("anon page %u MB < medium threshold %u MB", BYTE_TO_MBYTE(usage),
- BYTE_TO_MBYTE(threshold));
-}
-
-static bool lowmem_press_eventfd_handler(int fd, void *data)
-{
- struct memcg_info *mi;
- enum cgroup_type type = CGROUP_ROOT;
-
- // FIXME: probably shouldn't get ignored
- if (lowmem_press_eventfd_read(fd) < 0)
- _E("Failed to read lowmem press event, %m\n");
-
- for (type = CGROUP_ROOT; type < CGROUP_END; type++) {
- if (!get_cgroup_tree(type) || !get_memcg_info(type))
- continue;
- mi = get_memcg_info(type);
- if (fd == mi->evfd) {
- /* call low memory handler for this memcg */
- if (type == CGROUP_ROOT)
- lowmem_press_root_cgroup_handler();
- else {
- lowmem_press_cgroup_handler(type, mi);
- }
- return true;
- }
- }
-
- return true;
-}
-
-static int lowmem_press_register_eventfd(struct memcg_info *mi)
-{
- int evfd;
- const char *name = mi->name;
- static fd_handler_h handler;
-
- if (mi->threshold[MEM_LEVEL_OOM] == LOWMEM_THRES_INIT)
- return 0;
-
- evfd = memcg_set_eventfd(name, MEMCG_EVENTFD_MEMORY_PRESSURE,
- event_level);
-
- if (evfd < 0) {
- int saved_errno = errno;
- _E("fail to register event press fd %s cgroup", name);
- return -saved_errno;
- }
-
- mi->evfd = evfd;
-
- _I("register event fd success for %s cgroup", name);
- add_fd_read_handler(evfd, lowmem_press_eventfd_handler, NULL, NULL, &handler);
- return 0;
-}
-
-static int lowmem_press_setup_eventfd(void)
-{
- unsigned int i;
-
- for (i = CGROUP_ROOT; i < CGROUP_END; i++) {
- if (!get_use_hierarchy(i))
- continue;
-
- lowmem_press_register_eventfd(get_memcg_info(i));
- }
- return RESOURCED_ERROR_NONE;
-}
-
-static void lowmem_force_reclaim_cb(struct lowmem_control *ctl)
-{
- lowmem_change_memory_state(MEM_LEVEL_HIGH, 0);
-}
-
-int lowmem_trigger_reclaim(int flags, int victims, enum cgroup_type type, int threshold)
-{
- struct lowmem_control *ctl = LOWMEM_NEW_REQUEST();
-
- if (!ctl)
- return -ENOMEM;
-
- flags |= OOM_FORCE | OOM_IN_DEPTH | OOM_SINGLE_SHOT;
- victims = victims > 0 ? victims : MAX_MEMORY_CGROUP_VICTIMS;
- type = type > 0 ? type : CGROUP_LOW;
- threshold = threshold > 0 ? threshold : get_root_memcg_info()->threshold_leave;
-
- lowmem_change_memory_state(MEM_LEVEL_CRITICAL, 1);
- LOWMEM_SET_REQUEST(ctl, flags,
- type, threshold, victims,
- lowmem_force_reclaim_cb);
- lowmem_queue_request(&lmw, ctl);
-
- return 0;
-}
-
-void lowmem_trigger_swap_reclaim(enum cgroup_type type, int swap_size)
-{
- int size, victims;
-
- victims = num_max_victims > MAX_PROACTIVE_HIGH_VICTIMS
- ? MAX_PROACTIVE_HIGH_VICTIMS : num_max_victims;
-
- size = get_root_memcg_info()->threshold_leave + BYTE_TO_MBYTE(swap_size);
- _I("reclaim from swap module, type : %d, size : %d, victims: %d", type, size, victims);
- lowmem_trigger_reclaim(0, victims, type, size);
-}
-
-bool lowmem_fragmentated(void)
-{
- struct buddyinfo bi;
- int ret;
-
- ret = proc_get_buddyinfo("Normal", &bi);
- if (ret < 0)
- return false;
-
- /*
- * The fragmentation_size is the minimum count of order-2 pages in "Normal" zone.
- * If total buddy pages is smaller than fragmentation_size,
- * resourced will detect kernel memory is fragmented.
- * Default value is zero in low memory device.
- */
- if (bi.page[PAGE_32K] + (bi.page[PAGE_64K] << 1) + (bi.page[PAGE_128K] << 2) +
- (bi.page[PAGE_256K] << 3) < fragmentation_size) {
- _I("fragmentation detected, need to execute proactive oom killer");
- return true;
- }
- return false;
-}
-
-static void lowmem_proactive_oom_killer(int flags, char *appid)
-{
- unsigned int before;
- int victims;
-
- 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_LEVEL_OOM] || before > proactive_leave)
- return;
-
- victims = num_max_victims > MAX_PROACTIVE_HIGH_VICTIMS
- ? MAX_PROACTIVE_HIGH_VICTIMS : num_max_victims;
-
-#ifdef HEART_SUPPORT
- /*
- * This branch is used only when HEART module is compiled in and
- * it's MEMORY module must be enabled. Otherwise this is skipped.
- */
- struct heart_memory_data *md = heart_memory_get_memdata(appid, DATA_LATEST);
- if (md) {
- unsigned int rss, after, size;
-
- rss = KBYTE_TO_MBYTE(md->avg_rss);
-
- free(md);
-
- after = before - rss;
- /*
- * after launching app, ensure that available memory is
- * above threshold_leave
- */
- if (after >= get_root_memcg_info()->threshold[MEM_LEVEL_OOM])
- return;
-
- if (proactive_threshold - rss >= get_root_memcg_info()->threshold[MEM_LEVEL_OOM])
- size = proactive_threshold;
- else
- 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);
- lowmem_trigger_reclaim(0, victims, CGROUP_LOW, size);
-
- return;
- }
-#endif
-
- /*
- * When there is no history data for the launching app,
- * it is necessary to check current fragmentation state or application manifest file.
- * So, resourced feels proactive LMK is required, run oom killer based on dynamic
- * threshold.
- */
- if (lowmem_fragmentated())
- goto reclaim;
-
- /*
- * run proactive oom killer only when available is larger than
- * dynamic process threshold
- */
- if (!proactive_threshold || before >= proactive_threshold)
- return;
-
- if (!(flags & PROC_LARGEMEMORY))
- return;
-
-reclaim:
- /*
- * free THRESHOLD_MARGIN more than real should be freed,
- * because launching app is consuming up the memory.
- */
- _D("Run threshold based proactive LMK: memory level to reach: %u\n",
- proactive_leave + THRESHOLD_MARGIN);
- lowmem_trigger_reclaim(0, victims, CGROUP_LOW, proactive_leave + THRESHOLD_MARGIN);
-}
-
-unsigned int lowmem_get_proactive_thres(void)
-{
- return proactive_threshold;
-}
-
-static int lowmem_prelaunch_handler(void *data)
-{
- struct proc_status *ps = (struct proc_status *)data;
- struct proc_app_info *pai = ps->pai;
-
- if (!pai || CHECK_BIT(pai->flags, PROC_SERVICEAPP))
- return RESOURCED_ERROR_NONE;
-
- lowmem_proactive_oom_killer(ps->pai->flags, ps->pai->appid);
- return RESOURCED_ERROR_NONE;
-}
-
-int lowmem_control_handler(void *data)
-{
- struct lowmem_control_data *lowmem_data;
-
- lowmem_data = (struct lowmem_control_data *)data;
- switch (lowmem_data->control_type) {
- case LOWMEM_MOVE_CGROUP:
- lowmem_move_memcgroup((pid_t)lowmem_data->pid,
- lowmem_data->oom_score_adj, lowmem_data->pai);
- break;
- default:
- break;
- }
- return RESOURCED_ERROR_NONE;
-}
-
-static int lowmem_bg_reclaim_handler(void *data)
-{
- if (swap_get_state() != SWAP_ON)
- return RESOURCED_ERROR_NONE;
-
- if (!bg_reclaim)
- return RESOURCED_ERROR_NONE;
-
- /*
- * Proactively reclaiming memory used by long-lived background processes
- * (such as widget instances) may be efficient on devices with limited
- * memory constraints. The pages used by such processes could be reclaimed
- * (if swap is enabled) earlier than they used to while minimizing the
- * impact on the user experience.
- */
- resourced_notify(RESOURCED_NOTIFIER_SWAP_START, get_memcg_info(CGROUP_MEDIUM)->name);
-
- return RESOURCED_ERROR_NONE;
-}
-
-static void load_configs(const char *path)
-{
-/* if (config_parse(path, set_memory_config, NULL))
- _E("(%s-mem) parse Fail", path);
-
- if (config_parse(path, load_popup_config, NULL))
- _E("(%s-popup) parse Fail", path);
-
- if (config_parse(path, load_bg_reclaim_config, NULL))
- _E("(%s-bg-reclaim) parse Fail", path);
-
- if (config_parse(path, load_mem_log_config, NULL))
- _E("(%s-mem-log) parse Fail", path);*/
-
- free_memcg_conf();
-}
-
-static void print_mem_configs(void)
-{
- /* print info of Memory section */
- 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]);
-
- _I("set number of max victims as %d", num_max_victims);
- _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);
-
- /* print info of POPUP section */
- _I("oom popup is %s", oom_popup_enable == true ? "enabled" : "disabled");
-
- /* print info of BackgroundReclaim section */
- _I("Background reclaim is %s", bg_reclaim == true ? "enabled" : "disabled");
-
- /* print info of Logging section */
- _I("memory logging is %s", memlog_enabled == 1 ? "enabled" : "disabled");
- _I("memory logging path is %s", memlog_path);
- _I("the max number of memory logging is %d", memlog_nr_max);
- _I("the batch threshold of memory log is %d", memlog_remove_batch_thres);
- _I("prefix of memps is %s", memlog_prefix[MEMLOG_MEMPS]);
- _I("prefix of memlimit memps is %s", memlog_prefix[MEMLOG_MEMPS_MEMLIMIT]);
-}
-
-/* To Do: should we need lowmem_fd_start, lowmem_fd_stop ?? */
-static int lowmem_init(void)
-{
- int ret = RESOURCED_ERROR_NONE;
-
- _D("resourced memory init start");
-
- /* init memcg */
- ret = cgroup_make_full_subdir(MEMCG_PATH);
- ret_value_msg_if(ret < 0, ret, "memory cgroup init failed\n");
- memcg_params_init();
-
- setup_memcg_params();
-
- /* default configuration */
- load_configs(MEM_CONF_FILE);
-
- /* this function should be called after parsing configurations */
- memcg_write_params();
- print_mem_configs();
-
- /* make a worker thread called low memory killer */
- ret = lowmem_activate_worker();
- if (ret) {
- _E("oom thread create failed\n");
- return ret;
- }
-
- /* register threshold and event fd */
- ret = lowmem_press_setup_eventfd();
- if (ret) {
- _E("eventfd setup failed");
- return ret;
- }
-
- lowmem_dbus_init();
- lowmem_limit_init();
- lowmem_system_init();
-
- register_notifier(RESOURCED_NOTIFIER_APP_PRELAUNCH, lowmem_prelaunch_handler);
- register_notifier(RESOURCED_NOTIFIER_MEM_CONTROL, lowmem_control_handler);
- register_notifier(RESOURCED_NOTIFIER_LCD_OFF, lowmem_bg_reclaim_handler);
-
- return ret;
-}
-
-static int lowmem_exit(void)
-{
- if (strncmp(event_level, MEMCG_DEFAULT_EVENT_LEVEL, sizeof(MEMCG_DEFAULT_EVENT_LEVEL)))
- free(event_level);
-
- lowmem_deactivate_worker();
- lowmem_limit_exit();
- lowmem_system_exit();
-
- unregister_notifier(RESOURCED_NOTIFIER_APP_PRELAUNCH, lowmem_prelaunch_handler);
- unregister_notifier(RESOURCED_NOTIFIER_MEM_CONTROL, lowmem_control_handler);
- unregister_notifier(RESOURCED_NOTIFIER_LCD_OFF, lowmem_bg_reclaim_handler);
-
- return RESOURCED_ERROR_NONE;
-}
-
-static int resourced_memory_init(void *data)
-{
- lowmem_ops = &memory_modules_ops;
- return lowmem_init();
-}
-
-static int resourced_memory_finalize(void *data)
-{
- return lowmem_exit();
-}
-
-void lowmem_change_memory_state(int state, int force)
-{
- int mem_state;
-
- if (force) {
- mem_state = state;
- } else {
- unsigned int available = proc_get_mem_available();
- mem_state = check_mem_state(available);
- }
-
- lowmem_trigger_memory_state_action(mem_state);
-}
-
-unsigned long lowmem_get_ktotalram(void)
-{
- return ktotalram;
-}
-
-unsigned long lowmem_get_totalram(void)
-{
- return totalram;
-}
-
-void lowmem_restore_memcg(struct proc_app_info *pai)
-{
- char *cgpath;
- int index, ret;
- 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 = 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(strstr(cgpath, pai->appid))
- pai->memory.use_mem_limit = true;
-
- free(cgpath);
-}
-
-static struct module_ops memory_modules_ops = {
- .priority = MODULE_PRIORITY_HIGH,
- .name = "lowmem",
- .init = resourced_memory_init,
- .exit = resourced_memory_finalize,
-};
-
-MODULE_REGISTER(&memory_modules_ops)
projects / platform / core / system / resourced.git / commitdiff