blob: e3c4ccc99adc0db2f9d357bf32c2a9b618c092a9 [file] [log] [blame]
Todd Poynor3948f802013-07-09 19:35:14 -07001/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "lowmemorykiller"
18
19#include <errno.h>
Robert Beneac47f2992017-08-21 15:18:31 -070020#include <inttypes.h>
Suren Baghdasaryan4311d1e2018-03-20 16:03:29 -070021#include <pwd.h>
Mark Salyzyncfd5b082016-10-17 14:28:00 -070022#include <sched.h>
Todd Poynor3948f802013-07-09 19:35:14 -070023#include <signal.h>
Suren Baghdasaryan1ffa2462018-03-20 13:53:17 -070024#include <stdbool.h>
Todd Poynor3948f802013-07-09 19:35:14 -070025#include <stdlib.h>
26#include <string.h>
Mark Salyzyne6ed68b2014-04-30 13:36:35 -070027#include <sys/cdefs.h>
Todd Poynor3948f802013-07-09 19:35:14 -070028#include <sys/epoll.h>
29#include <sys/eventfd.h>
Colin Crossb28ff912014-07-11 17:15:44 -070030#include <sys/mman.h>
Todd Poynor3948f802013-07-09 19:35:14 -070031#include <sys/socket.h>
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -080032#include <sys/sysinfo.h>
Mark Salyzyn721d7c72018-03-21 12:24:58 -070033#include <sys/types.h>
Suren Baghdasaryan314a5052018-07-24 17:13:06 -070034#include <time.h>
Mark Salyzyne6ed68b2014-04-30 13:36:35 -070035#include <unistd.h>
36
Robert Benea58891d52017-07-31 17:15:20 -070037#include <cutils/properties.h>
Todd Poynor3948f802013-07-09 19:35:14 -070038#include <cutils/sockets.h>
Suren Baghdasaryan0f100512018-01-24 16:51:41 -080039#include <lmkd.h>
Mark Salyzyn30f991f2017-01-10 13:19:54 -080040#include <log/log.h>
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -070041#include <log/log_event_list.h>
Suren Baghdasaryan314a5052018-07-24 17:13:06 -070042#include <log/log_time.h>
Mark Salyzyne6ed68b2014-04-30 13:36:35 -070043
Rajeev Kumar70450032018-01-31 17:54:56 -080044#ifdef LMKD_LOG_STATS
Yao Chen389aee12018-05-02 11:19:27 -070045#include "statslog.h"
Rajeev Kumar70450032018-01-31 17:54:56 -080046#endif
47
Suren Baghdasaryanc7135592018-01-04 10:43:58 -080048/*
49 * Define LMKD_TRACE_KILLS to record lmkd kills in kernel traces
50 * to profile and correlate with OOM kills
51 */
52#ifdef LMKD_TRACE_KILLS
53
54#define ATRACE_TAG ATRACE_TAG_ALWAYS
55#include <cutils/trace.h>
56
57#define TRACE_KILL_START(pid) ATRACE_INT(__FUNCTION__, pid);
58#define TRACE_KILL_END() ATRACE_INT(__FUNCTION__, 0);
59
60#else /* LMKD_TRACE_KILLS */
61
Daniel Colascione347f6b42018-02-12 11:24:47 -080062#define TRACE_KILL_START(pid) ((void)(pid))
63#define TRACE_KILL_END() ((void)0)
Suren Baghdasaryanc7135592018-01-04 10:43:58 -080064
65#endif /* LMKD_TRACE_KILLS */
66
Mark Salyzyne6ed68b2014-04-30 13:36:35 -070067#ifndef __unused
68#define __unused __attribute__((__unused__))
69#endif
Todd Poynor3948f802013-07-09 19:35:14 -070070
71#define MEMCG_SYSFS_PATH "/dev/memcg/"
Robert Beneac47f2992017-08-21 15:18:31 -070072#define MEMCG_MEMORY_USAGE "/dev/memcg/memory.usage_in_bytes"
73#define MEMCG_MEMORYSW_USAGE "/dev/memcg/memory.memsw.usage_in_bytes"
Suren Baghdasaryan8b9deaf2018-04-13 13:11:51 -070074#define ZONEINFO_PATH "/proc/zoneinfo"
75#define MEMINFO_PATH "/proc/meminfo"
Todd Poynor3948f802013-07-09 19:35:14 -070076#define LINE_MAX 128
77
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -070078/* Android Logger event logtags (see event.logtags) */
79#define MEMINFO_LOG_TAG 10195355
80
Mark Salyzyn64d97d82018-04-09 09:50:32 -070081/* gid containing AID_SYSTEM required */
Todd Poynor3948f802013-07-09 19:35:14 -070082#define INKERNEL_MINFREE_PATH "/sys/module/lowmemorykiller/parameters/minfree"
83#define INKERNEL_ADJ_PATH "/sys/module/lowmemorykiller/parameters/adj"
84
85#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
Robert Benea673e2762017-06-01 16:32:31 -070086#define EIGHT_MEGA (1 << 23)
Todd Poynor3948f802013-07-09 19:35:14 -070087
Suren Baghdasaryan314a5052018-07-24 17:13:06 -070088#define TARGET_UPDATE_MIN_INTERVAL_MS 1000
89
90#define NS_PER_MS (NS_PER_SEC / MS_PER_SEC)
91
Suren Baghdasaryan4311d1e2018-03-20 16:03:29 -070092/* Defined as ProcessList.SYSTEM_ADJ in ProcessList.java */
93#define SYSTEM_ADJ (-900)
94
Greg Kaiserf0da9b02018-03-23 14:16:12 -070095#define STRINGIFY(x) STRINGIFY_INTERNAL(x)
96#define STRINGIFY_INTERNAL(x) #x
97
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -070098#define min(a, b) (((a) < (b)) ? (a) : (b))
99
Suren Baghdasaryan36934412018-09-05 15:46:32 -0700100#define FAIL_REPORT_RLIMIT_MS 1000
101
Todd Poynor3948f802013-07-09 19:35:14 -0700102/* default to old in-kernel interface if no memory pressure events */
Mark Salyzyn721d7c72018-03-21 12:24:58 -0700103static bool use_inkernel_interface = true;
Robert Benea164baeb2017-09-11 16:53:28 -0700104static bool has_inkernel_module;
Todd Poynor3948f802013-07-09 19:35:14 -0700105
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -0800106/* memory pressure levels */
107enum vmpressure_level {
108 VMPRESS_LEVEL_LOW = 0,
109 VMPRESS_LEVEL_MEDIUM,
110 VMPRESS_LEVEL_CRITICAL,
111 VMPRESS_LEVEL_COUNT
112};
Todd Poynor3948f802013-07-09 19:35:14 -0700113
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -0800114static const char *level_name[] = {
115 "low",
116 "medium",
117 "critical"
118};
119
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -0800120struct {
Suren Baghdasaryan9926e572018-04-13 13:41:12 -0700121 int64_t min_nr_free_pages; /* recorded but not used yet */
122 int64_t max_nr_free_pages;
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -0800123} low_pressure_mem = { -1, -1 };
124
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -0800125static int level_oomadj[VMPRESS_LEVEL_COUNT];
Suren Baghdasaryane82e15c2018-01-04 09:16:21 -0800126static int mpevfd[VMPRESS_LEVEL_COUNT] = { -1, -1, -1 };
Robert Beneac47f2992017-08-21 15:18:31 -0700127static bool debug_process_killing;
128static bool enable_pressure_upgrade;
129static int64_t upgrade_pressure;
Robert Benea6e8e7102017-09-13 15:20:30 -0700130static int64_t downgrade_pressure;
Suren Baghdasaryanff61afb2018-04-13 11:45:38 -0700131static bool low_ram_device;
Suren Baghdasaryan662492a2017-12-08 13:17:06 -0800132static bool kill_heaviest_task;
Suren Baghdasaryancaa2dc52018-01-17 17:28:01 -0800133static unsigned long kill_timeout_ms;
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -0700134static bool use_minfree_levels;
Suren Baghdasaryance13cb52018-06-19 18:38:12 -0700135static bool per_app_memcg;
Vic Yang360a1132018-08-07 10:18:22 -0700136static int swap_free_low_percentage;
Robert Benea58891d52017-07-31 17:15:20 -0700137
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -0700138static android_log_context ctx;
139
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800140/* data required to handle events */
141struct event_handler_info {
142 int data;
143 void (*handler)(int data, uint32_t events);
144};
Todd Poynor3948f802013-07-09 19:35:14 -0700145
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800146/* data required to handle socket events */
147struct sock_event_handler_info {
148 int sock;
149 struct event_handler_info handler_info;
150};
151
152/* max supported number of data connections */
153#define MAX_DATA_CONN 2
154
155/* socket event handler data */
156static struct sock_event_handler_info ctrl_sock;
157static struct sock_event_handler_info data_sock[MAX_DATA_CONN];
158
159/* vmpressure event handler data */
160static struct event_handler_info vmpressure_hinfo[VMPRESS_LEVEL_COUNT];
161
162/* 3 memory pressure levels, 1 ctrl listen socket, 2 ctrl data socket */
163#define MAX_EPOLL_EVENTS (1 + MAX_DATA_CONN + VMPRESS_LEVEL_COUNT)
Todd Poynor3948f802013-07-09 19:35:14 -0700164static int epollfd;
165static int maxevents;
166
Chong Zhang0a4acdf2015-10-14 16:19:53 -0700167/* OOM score values used by both kernel and framework */
Todd Poynor16b60992013-09-16 19:26:47 -0700168#define OOM_SCORE_ADJ_MIN (-1000)
169#define OOM_SCORE_ADJ_MAX 1000
170
Todd Poynor3948f802013-07-09 19:35:14 -0700171static int lowmem_adj[MAX_TARGETS];
172static int lowmem_minfree[MAX_TARGETS];
173static int lowmem_targets_size;
174
Suren Baghdasaryan8b9deaf2018-04-13 13:11:51 -0700175/* Fields to parse in /proc/zoneinfo */
176enum zoneinfo_field {
177 ZI_NR_FREE_PAGES = 0,
178 ZI_NR_FILE_PAGES,
179 ZI_NR_SHMEM,
180 ZI_NR_UNEVICTABLE,
181 ZI_WORKINGSET_REFAULT,
182 ZI_HIGH,
183 ZI_FIELD_COUNT
184};
185
186static const char* const zoneinfo_field_names[ZI_FIELD_COUNT] = {
187 "nr_free_pages",
188 "nr_file_pages",
189 "nr_shmem",
190 "nr_unevictable",
191 "workingset_refault",
192 "high",
193};
194
195union zoneinfo {
196 struct {
197 int64_t nr_free_pages;
198 int64_t nr_file_pages;
199 int64_t nr_shmem;
200 int64_t nr_unevictable;
201 int64_t workingset_refault;
202 int64_t high;
203 /* fields below are calculated rather than read from the file */
204 int64_t totalreserve_pages;
205 } field;
206 int64_t arr[ZI_FIELD_COUNT];
207};
208
209/* Fields to parse in /proc/meminfo */
210enum meminfo_field {
211 MI_NR_FREE_PAGES = 0,
212 MI_CACHED,
213 MI_SWAP_CACHED,
214 MI_BUFFERS,
215 MI_SHMEM,
216 MI_UNEVICTABLE,
Vic Yang360a1132018-08-07 10:18:22 -0700217 MI_TOTAL_SWAP,
Suren Baghdasaryan8b9deaf2018-04-13 13:11:51 -0700218 MI_FREE_SWAP,
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -0700219 MI_ACTIVE_ANON,
220 MI_INACTIVE_ANON,
221 MI_ACTIVE_FILE,
222 MI_INACTIVE_FILE,
223 MI_SRECLAIMABLE,
224 MI_SUNRECLAIM,
225 MI_KERNEL_STACK,
226 MI_PAGE_TABLES,
227 MI_ION_HELP,
228 MI_ION_HELP_POOL,
229 MI_CMA_FREE,
Suren Baghdasaryan8b9deaf2018-04-13 13:11:51 -0700230 MI_FIELD_COUNT
231};
232
233static const char* const meminfo_field_names[MI_FIELD_COUNT] = {
234 "MemFree:",
235 "Cached:",
236 "SwapCached:",
237 "Buffers:",
238 "Shmem:",
239 "Unevictable:",
Vic Yang360a1132018-08-07 10:18:22 -0700240 "SwapTotal:",
Suren Baghdasaryan8b9deaf2018-04-13 13:11:51 -0700241 "SwapFree:",
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -0700242 "Active(anon):",
243 "Inactive(anon):",
244 "Active(file):",
245 "Inactive(file):",
246 "SReclaimable:",
247 "SUnreclaim:",
248 "KernelStack:",
249 "PageTables:",
250 "ION_heap:",
251 "ION_heap_pool:",
252 "CmaFree:",
Suren Baghdasaryan8b9deaf2018-04-13 13:11:51 -0700253};
254
255union meminfo {
256 struct {
257 int64_t nr_free_pages;
258 int64_t cached;
259 int64_t swap_cached;
260 int64_t buffers;
261 int64_t shmem;
262 int64_t unevictable;
Vic Yang360a1132018-08-07 10:18:22 -0700263 int64_t total_swap;
Suren Baghdasaryan8b9deaf2018-04-13 13:11:51 -0700264 int64_t free_swap;
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -0700265 int64_t active_anon;
266 int64_t inactive_anon;
267 int64_t active_file;
268 int64_t inactive_file;
269 int64_t sreclaimable;
270 int64_t sunreclaimable;
271 int64_t kernel_stack;
272 int64_t page_tables;
273 int64_t ion_heap;
274 int64_t ion_heap_pool;
275 int64_t cma_free;
Suren Baghdasaryan8b9deaf2018-04-13 13:11:51 -0700276 /* fields below are calculated rather than read from the file */
277 int64_t nr_file_pages;
278 } field;
279 int64_t arr[MI_FIELD_COUNT];
280};
281
282enum field_match_result {
283 NO_MATCH,
284 PARSE_FAIL,
285 PARSE_SUCCESS
286};
287
Todd Poynor3948f802013-07-09 19:35:14 -0700288struct adjslot_list {
289 struct adjslot_list *next;
290 struct adjslot_list *prev;
291};
292
293struct proc {
294 struct adjslot_list asl;
295 int pid;
Colin Crossfbb78c62014-06-13 14:52:43 -0700296 uid_t uid;
Todd Poynor3948f802013-07-09 19:35:14 -0700297 int oomadj;
298 struct proc *pidhash_next;
299};
300
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -0700301struct reread_data {
302 const char* const filename;
303 int fd;
304};
305
Rajeev Kumar70450032018-01-31 17:54:56 -0800306#ifdef LMKD_LOG_STATS
Rajeev Kumar70450032018-01-31 17:54:56 -0800307static bool enable_stats_log;
308static android_log_context log_ctx;
309#endif
310
Todd Poynor3948f802013-07-09 19:35:14 -0700311#define PIDHASH_SZ 1024
312static struct proc *pidhash[PIDHASH_SZ];
313#define pid_hashfn(x) ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))
314
Chih-Hung Hsiehdaa13ea2016-05-19 16:02:22 -0700315#define ADJTOSLOT(adj) ((adj) + -OOM_SCORE_ADJ_MIN)
Suren Baghdasaryand4a29902018-10-12 11:07:40 -0700316#define ADJTOSLOT_COUNT (ADJTOSLOT(OOM_SCORE_ADJ_MAX) + 1)
317static struct adjslot_list procadjslot_list[ADJTOSLOT_COUNT];
318
319#define MAX_DISTINCT_OOM_ADJ 32
320#define KILLCNT_INVALID_IDX 0xFF
321/*
322 * Because killcnt array is sparse a two-level indirection is used
323 * to keep the size small. killcnt_idx stores index of the element in
324 * killcnt array. Index KILLCNT_INVALID_IDX indicates an unused slot.
325 */
326static uint8_t killcnt_idx[ADJTOSLOT_COUNT];
327static uint16_t killcnt[MAX_DISTINCT_OOM_ADJ];
328static int killcnt_free_idx = 0;
329static uint32_t killcnt_total = 0;
Todd Poynor3948f802013-07-09 19:35:14 -0700330
Todd Poynor3948f802013-07-09 19:35:14 -0700331/* PAGE_SIZE / 1024 */
332static long page_k;
333
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -0700334static bool parse_int64(const char* str, int64_t* ret) {
335 char* endptr;
336 long long val = strtoll(str, &endptr, 10);
337 if (str == endptr || val > INT64_MAX) {
338 return false;
339 }
340 *ret = (int64_t)val;
341 return true;
342}
343
Suren Baghdasaryan8b9deaf2018-04-13 13:11:51 -0700344static enum field_match_result match_field(const char* cp, const char* ap,
345 const char* const field_names[],
346 int field_count, int64_t* field,
347 int *field_idx) {
348 int64_t val;
349 int i;
350
351 for (i = 0; i < field_count; i++) {
352 if (!strcmp(cp, field_names[i])) {
353 *field_idx = i;
354 return parse_int64(ap, field) ? PARSE_SUCCESS : PARSE_FAIL;
355 }
356 }
357 return NO_MATCH;
358}
359
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -0700360/*
361 * Read file content from the beginning up to max_len bytes or EOF
362 * whichever happens first.
363 */
Colin Crossce85d952014-07-11 17:53:27 -0700364static ssize_t read_all(int fd, char *buf, size_t max_len)
365{
366 ssize_t ret = 0;
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -0700367 off_t offset = 0;
Colin Crossce85d952014-07-11 17:53:27 -0700368
369 while (max_len > 0) {
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -0700370 ssize_t r = TEMP_FAILURE_RETRY(pread(fd, buf, max_len, offset));
Colin Crossce85d952014-07-11 17:53:27 -0700371 if (r == 0) {
372 break;
373 }
374 if (r == -1) {
375 return -1;
376 }
377 ret += r;
378 buf += r;
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -0700379 offset += r;
Colin Crossce85d952014-07-11 17:53:27 -0700380 max_len -= r;
381 }
382
383 return ret;
384}
385
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -0700386/*
387 * Read a new or already opened file from the beginning.
388 * If the file has not been opened yet data->fd should be set to -1.
389 * To be used with files which are read often and possibly during high
390 * memory pressure to minimize file opening which by itself requires kernel
391 * memory allocation and might result in a stall on memory stressed system.
392 */
393static int reread_file(struct reread_data *data, char *buf, size_t buf_size) {
394 ssize_t size;
395
396 if (data->fd == -1) {
397 data->fd = open(data->filename, O_RDONLY | O_CLOEXEC);
398 if (data->fd == -1) {
399 ALOGE("%s open: %s", data->filename, strerror(errno));
400 return -1;
401 }
402 }
403
404 size = read_all(data->fd, buf, buf_size - 1);
405 if (size < 0) {
406 ALOGE("%s read: %s", data->filename, strerror(errno));
407 close(data->fd);
408 data->fd = -1;
409 return -1;
410 }
Chih-Hung Hsieh62b0ef52018-07-25 12:15:25 -0700411 ALOG_ASSERT((size_t)size < buf_size - 1, "%s too large", data->filename);
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -0700412 buf[size] = 0;
413
414 return 0;
415}
416
Todd Poynor3948f802013-07-09 19:35:14 -0700417static struct proc *pid_lookup(int pid) {
418 struct proc *procp;
419
420 for (procp = pidhash[pid_hashfn(pid)]; procp && procp->pid != pid;
421 procp = procp->pidhash_next)
422 ;
423
424 return procp;
425}
426
427static void adjslot_insert(struct adjslot_list *head, struct adjslot_list *new)
428{
429 struct adjslot_list *next = head->next;
430 new->prev = head;
431 new->next = next;
432 next->prev = new;
433 head->next = new;
434}
435
436static void adjslot_remove(struct adjslot_list *old)
437{
438 struct adjslot_list *prev = old->prev;
439 struct adjslot_list *next = old->next;
440 next->prev = prev;
441 prev->next = next;
442}
443
444static struct adjslot_list *adjslot_tail(struct adjslot_list *head) {
445 struct adjslot_list *asl = head->prev;
446
447 return asl == head ? NULL : asl;
448}
449
450static void proc_slot(struct proc *procp) {
451 int adjslot = ADJTOSLOT(procp->oomadj);
452
453 adjslot_insert(&procadjslot_list[adjslot], &procp->asl);
454}
455
456static void proc_unslot(struct proc *procp) {
457 adjslot_remove(&procp->asl);
458}
459
460static void proc_insert(struct proc *procp) {
461 int hval = pid_hashfn(procp->pid);
462
463 procp->pidhash_next = pidhash[hval];
464 pidhash[hval] = procp;
465 proc_slot(procp);
466}
467
468static int pid_remove(int pid) {
469 int hval = pid_hashfn(pid);
470 struct proc *procp;
471 struct proc *prevp;
472
473 for (procp = pidhash[hval], prevp = NULL; procp && procp->pid != pid;
474 procp = procp->pidhash_next)
475 prevp = procp;
476
477 if (!procp)
478 return -1;
479
480 if (!prevp)
481 pidhash[hval] = procp->pidhash_next;
482 else
483 prevp->pidhash_next = procp->pidhash_next;
484
485 proc_unslot(procp);
486 free(procp);
487 return 0;
488}
489
Suren Baghdasaryan1ffa2462018-03-20 13:53:17 -0700490/*
491 * Write a string to a file.
492 * Returns false if the file does not exist.
493 */
494static bool writefilestring(const char *path, const char *s,
495 bool err_if_missing) {
Nick Kralevichc68c8862015-12-18 20:52:37 -0800496 int fd = open(path, O_WRONLY | O_CLOEXEC);
Suren Baghdasaryan1ffa2462018-03-20 13:53:17 -0700497 ssize_t len = strlen(s);
498 ssize_t ret;
Todd Poynor3948f802013-07-09 19:35:14 -0700499
500 if (fd < 0) {
Suren Baghdasaryan1ffa2462018-03-20 13:53:17 -0700501 if (err_if_missing) {
502 ALOGE("Error opening %s; errno=%d", path, errno);
503 }
504 return false;
Todd Poynor3948f802013-07-09 19:35:14 -0700505 }
506
Suren Baghdasaryan1ffa2462018-03-20 13:53:17 -0700507 ret = TEMP_FAILURE_RETRY(write(fd, s, len));
Todd Poynor3948f802013-07-09 19:35:14 -0700508 if (ret < 0) {
509 ALOGE("Error writing %s; errno=%d", path, errno);
510 } else if (ret < len) {
Suren Baghdasaryan1ffa2462018-03-20 13:53:17 -0700511 ALOGE("Short write on %s; length=%zd", path, ret);
Todd Poynor3948f802013-07-09 19:35:14 -0700512 }
513
514 close(fd);
Suren Baghdasaryan1ffa2462018-03-20 13:53:17 -0700515 return true;
Todd Poynor3948f802013-07-09 19:35:14 -0700516}
517
Suren Baghdasaryan314a5052018-07-24 17:13:06 -0700518static inline long get_time_diff_ms(struct timespec *from,
519 struct timespec *to) {
520 return (to->tv_sec - from->tv_sec) * (long)MS_PER_SEC +
521 (to->tv_nsec - from->tv_nsec) / (long)NS_PER_MS;
522}
523
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800524static void cmd_procprio(LMKD_CTRL_PACKET packet) {
Todd Poynor3948f802013-07-09 19:35:14 -0700525 struct proc *procp;
526 char path[80];
527 char val[20];
Robert Benea673e2762017-06-01 16:32:31 -0700528 int soft_limit_mult;
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800529 struct lmk_procprio params;
Suren Baghdasaryan4311d1e2018-03-20 16:03:29 -0700530 bool is_system_server;
531 struct passwd *pwdrec;
Todd Poynor3948f802013-07-09 19:35:14 -0700532
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800533 lmkd_pack_get_procprio(packet, &params);
534
535 if (params.oomadj < OOM_SCORE_ADJ_MIN ||
536 params.oomadj > OOM_SCORE_ADJ_MAX) {
537 ALOGE("Invalid PROCPRIO oomadj argument %d", params.oomadj);
Todd Poynor3948f802013-07-09 19:35:14 -0700538 return;
539 }
540
Mark Salyzyn64d97d82018-04-09 09:50:32 -0700541 /* gid containing AID_READPROC required */
542 /* CAP_SYS_RESOURCE required */
543 /* CAP_DAC_OVERRIDE required */
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800544 snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", params.pid);
545 snprintf(val, sizeof(val), "%d", params.oomadj);
Suren Baghdasaryan1ffa2462018-03-20 13:53:17 -0700546 if (!writefilestring(path, val, false)) {
547 ALOGW("Failed to open %s; errno=%d: process %d might have been killed",
548 path, errno, params.pid);
549 /* If this file does not exist the process is dead. */
550 return;
551 }
Todd Poynor3948f802013-07-09 19:35:14 -0700552
Mark Salyzyn721d7c72018-03-21 12:24:58 -0700553 if (use_inkernel_interface) {
Todd Poynor3948f802013-07-09 19:35:14 -0700554 return;
Mark Salyzyn721d7c72018-03-21 12:24:58 -0700555 }
Todd Poynor3948f802013-07-09 19:35:14 -0700556
Suren Baghdasaryance13cb52018-06-19 18:38:12 -0700557 if (per_app_memcg) {
Suren Baghdasaryan20686f02018-05-18 14:42:00 -0700558 if (params.oomadj >= 900) {
559 soft_limit_mult = 0;
560 } else if (params.oomadj >= 800) {
561 soft_limit_mult = 0;
562 } else if (params.oomadj >= 700) {
563 soft_limit_mult = 0;
564 } else if (params.oomadj >= 600) {
565 // Launcher should be perceptible, don't kill it.
566 params.oomadj = 200;
567 soft_limit_mult = 1;
568 } else if (params.oomadj >= 500) {
569 soft_limit_mult = 0;
570 } else if (params.oomadj >= 400) {
571 soft_limit_mult = 0;
572 } else if (params.oomadj >= 300) {
573 soft_limit_mult = 1;
574 } else if (params.oomadj >= 200) {
Srinivas Paladugu3eb20bc2018-10-09 14:21:10 -0700575 soft_limit_mult = 8;
Suren Baghdasaryan20686f02018-05-18 14:42:00 -0700576 } else if (params.oomadj >= 100) {
577 soft_limit_mult = 10;
578 } else if (params.oomadj >= 0) {
579 soft_limit_mult = 20;
580 } else {
581 // Persistent processes will have a large
582 // soft limit 512MB.
583 soft_limit_mult = 64;
584 }
Robert Benea673e2762017-06-01 16:32:31 -0700585
Suren Baghdasaryan3862dd32018-05-21 19:48:47 -0700586 snprintf(path, sizeof(path), MEMCG_SYSFS_PATH
587 "apps/uid_%d/pid_%d/memory.soft_limit_in_bytes",
588 params.uid, params.pid);
Suren Baghdasaryan20686f02018-05-18 14:42:00 -0700589 snprintf(val, sizeof(val), "%d", soft_limit_mult * EIGHT_MEGA);
Suren Baghdasaryan3862dd32018-05-21 19:48:47 -0700590
591 /*
592 * system_server process has no memcg under /dev/memcg/apps but should be
593 * registered with lmkd. This is the best way so far to identify it.
594 */
595 is_system_server = (params.oomadj == SYSTEM_ADJ &&
596 (pwdrec = getpwnam("system")) != NULL &&
597 params.uid == pwdrec->pw_uid);
598 writefilestring(path, val, !is_system_server);
Robert Benea673e2762017-06-01 16:32:31 -0700599 }
600
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800601 procp = pid_lookup(params.pid);
Todd Poynor3948f802013-07-09 19:35:14 -0700602 if (!procp) {
603 procp = malloc(sizeof(struct proc));
604 if (!procp) {
605 // Oh, the irony. May need to rebuild our state.
606 return;
607 }
608
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800609 procp->pid = params.pid;
610 procp->uid = params.uid;
611 procp->oomadj = params.oomadj;
Todd Poynor3948f802013-07-09 19:35:14 -0700612 proc_insert(procp);
613 } else {
614 proc_unslot(procp);
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800615 procp->oomadj = params.oomadj;
Todd Poynor3948f802013-07-09 19:35:14 -0700616 proc_slot(procp);
617 }
618}
619
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800620static void cmd_procremove(LMKD_CTRL_PACKET packet) {
621 struct lmk_procremove params;
622
Mark Salyzyn721d7c72018-03-21 12:24:58 -0700623 if (use_inkernel_interface) {
Todd Poynor3948f802013-07-09 19:35:14 -0700624 return;
Mark Salyzyn721d7c72018-03-21 12:24:58 -0700625 }
Todd Poynor3948f802013-07-09 19:35:14 -0700626
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800627 lmkd_pack_get_procremove(packet, &params);
Suren Baghdasaryan01063272018-10-12 11:28:33 -0700628 /*
629 * WARNING: After pid_remove() procp is freed and can't be used!
630 * Therefore placed at the end of the function.
631 */
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800632 pid_remove(params.pid);
Todd Poynor3948f802013-07-09 19:35:14 -0700633}
634
Suren Baghdasaryane3b60472018-10-10 14:17:17 -0700635static void cmd_procpurge() {
636 int i;
637 struct proc *procp;
638 struct proc *next;
639
640 if (use_inkernel_interface) {
641 return;
642 }
643
644 for (i = 0; i <= ADJTOSLOT(OOM_SCORE_ADJ_MAX); i++) {
645 procadjslot_list[i].next = &procadjslot_list[i];
646 procadjslot_list[i].prev = &procadjslot_list[i];
647 }
648
649 for (i = 0; i < PIDHASH_SZ; i++) {
650 procp = pidhash[i];
651 while (procp) {
652 next = procp->pidhash_next;
653 free(procp);
654 procp = next;
655 }
656 }
657 memset(&pidhash[0], 0, sizeof(pidhash));
658}
659
Suren Baghdasaryand4a29902018-10-12 11:07:40 -0700660static void inc_killcnt(int oomadj) {
661 int slot = ADJTOSLOT(oomadj);
662 uint8_t idx = killcnt_idx[slot];
663
664 if (idx == KILLCNT_INVALID_IDX) {
665 /* index is not assigned for this oomadj */
666 if (killcnt_free_idx < MAX_DISTINCT_OOM_ADJ) {
667 killcnt_idx[slot] = killcnt_free_idx;
668 killcnt[killcnt_free_idx] = 1;
669 killcnt_free_idx++;
670 } else {
671 ALOGW("Number of distinct oomadj levels exceeds %d",
672 MAX_DISTINCT_OOM_ADJ);
673 }
674 } else {
675 /*
676 * wraparound is highly unlikely and is detectable using total
677 * counter because it has to be equal to the sum of all counters
678 */
679 killcnt[idx]++;
680 }
681 /* increment total kill counter */
682 killcnt_total++;
683}
684
685static int get_killcnt(int min_oomadj, int max_oomadj) {
686 int slot;
687 int count = 0;
688
689 if (min_oomadj > max_oomadj)
690 return 0;
691
692 /* special case to get total kill count */
693 if (min_oomadj > OOM_SCORE_ADJ_MAX)
694 return killcnt_total;
695
696 while (min_oomadj <= max_oomadj &&
697 (slot = ADJTOSLOT(min_oomadj)) < ADJTOSLOT_COUNT) {
698 uint8_t idx = killcnt_idx[slot];
699 if (idx != KILLCNT_INVALID_IDX) {
700 count += killcnt[idx];
701 }
702 min_oomadj++;
703 }
704
705 return count;
706}
707
708static int cmd_getkillcnt(LMKD_CTRL_PACKET packet) {
709 struct lmk_getkillcnt params;
710
711 if (use_inkernel_interface) {
712 /* kernel driver does not expose this information */
713 return 0;
714 }
715
716 lmkd_pack_get_getkillcnt(packet, &params);
717
718 return get_killcnt(params.min_oomadj, params.max_oomadj);
719}
720
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800721static void cmd_target(int ntargets, LMKD_CTRL_PACKET packet) {
Todd Poynor3948f802013-07-09 19:35:14 -0700722 int i;
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800723 struct lmk_target target;
Suren Baghdasaryan314a5052018-07-24 17:13:06 -0700724 char minfree_str[PROPERTY_VALUE_MAX];
725 char *pstr = minfree_str;
726 char *pend = minfree_str + sizeof(minfree_str);
727 static struct timespec last_req_tm;
728 struct timespec curr_tm;
Todd Poynor3948f802013-07-09 19:35:14 -0700729
Suren Baghdasaryan314a5052018-07-24 17:13:06 -0700730 if (ntargets < 1 || ntargets > (int)ARRAY_SIZE(lowmem_adj))
Todd Poynor3948f802013-07-09 19:35:14 -0700731 return;
732
Suren Baghdasaryan314a5052018-07-24 17:13:06 -0700733 /*
734 * Ratelimit minfree updates to once per TARGET_UPDATE_MIN_INTERVAL_MS
735 * to prevent DoS attacks
736 */
737 if (clock_gettime(CLOCK_MONOTONIC_COARSE, &curr_tm) != 0) {
738 ALOGE("Failed to get current time");
739 return;
740 }
741
742 if (get_time_diff_ms(&last_req_tm, &curr_tm) <
743 TARGET_UPDATE_MIN_INTERVAL_MS) {
744 ALOGE("Ignoring frequent updated to lmkd limits");
745 return;
746 }
747
748 last_req_tm = curr_tm;
749
Todd Poynor3948f802013-07-09 19:35:14 -0700750 for (i = 0; i < ntargets; i++) {
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800751 lmkd_pack_get_target(packet, i, &target);
752 lowmem_minfree[i] = target.minfree;
753 lowmem_adj[i] = target.oom_adj_score;
Suren Baghdasaryan314a5052018-07-24 17:13:06 -0700754
755 pstr += snprintf(pstr, pend - pstr, "%d:%d,", target.minfree,
756 target.oom_adj_score);
757 if (pstr >= pend) {
758 /* if no more space in the buffer then terminate the loop */
759 pstr = pend;
760 break;
761 }
Todd Poynor3948f802013-07-09 19:35:14 -0700762 }
763
764 lowmem_targets_size = ntargets;
765
Suren Baghdasaryan314a5052018-07-24 17:13:06 -0700766 /* Override the last extra comma */
767 pstr[-1] = '\0';
768 property_set("sys.lmk.minfree_levels", minfree_str);
769
Robert Benea164baeb2017-09-11 16:53:28 -0700770 if (has_inkernel_module) {
Todd Poynor3948f802013-07-09 19:35:14 -0700771 char minfreestr[128];
772 char killpriostr[128];
773
774 minfreestr[0] = '\0';
775 killpriostr[0] = '\0';
776
777 for (i = 0; i < lowmem_targets_size; i++) {
778 char val[40];
779
780 if (i) {
781 strlcat(minfreestr, ",", sizeof(minfreestr));
782 strlcat(killpriostr, ",", sizeof(killpriostr));
783 }
784
Robert Benea164baeb2017-09-11 16:53:28 -0700785 snprintf(val, sizeof(val), "%d", use_inkernel_interface ? lowmem_minfree[i] : 0);
Todd Poynor3948f802013-07-09 19:35:14 -0700786 strlcat(minfreestr, val, sizeof(minfreestr));
Robert Benea164baeb2017-09-11 16:53:28 -0700787 snprintf(val, sizeof(val), "%d", use_inkernel_interface ? lowmem_adj[i] : 0);
Todd Poynor3948f802013-07-09 19:35:14 -0700788 strlcat(killpriostr, val, sizeof(killpriostr));
789 }
790
Suren Baghdasaryan1ffa2462018-03-20 13:53:17 -0700791 writefilestring(INKERNEL_MINFREE_PATH, minfreestr, true);
792 writefilestring(INKERNEL_ADJ_PATH, killpriostr, true);
Todd Poynor3948f802013-07-09 19:35:14 -0700793 }
794}
795
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800796static void ctrl_data_close(int dsock_idx) {
797 struct epoll_event epev;
798
799 ALOGI("closing lmkd data connection");
800 if (epoll_ctl(epollfd, EPOLL_CTL_DEL, data_sock[dsock_idx].sock, &epev) == -1) {
801 // Log a warning and keep going
802 ALOGW("epoll_ctl for data connection socket failed; errno=%d", errno);
803 }
Todd Poynor3948f802013-07-09 19:35:14 -0700804 maxevents--;
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800805
806 close(data_sock[dsock_idx].sock);
807 data_sock[dsock_idx].sock = -1;
Todd Poynor3948f802013-07-09 19:35:14 -0700808}
809
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800810static int ctrl_data_read(int dsock_idx, char *buf, size_t bufsz) {
Todd Poynor3948f802013-07-09 19:35:14 -0700811 int ret = 0;
812
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -0700813 ret = TEMP_FAILURE_RETRY(read(data_sock[dsock_idx].sock, buf, bufsz));
Todd Poynor3948f802013-07-09 19:35:14 -0700814
815 if (ret == -1) {
816 ALOGE("control data socket read failed; errno=%d", errno);
817 } else if (ret == 0) {
818 ALOGE("Got EOF on control data socket");
819 ret = -1;
820 }
821
822 return ret;
823}
824
Suren Baghdasaryand4a29902018-10-12 11:07:40 -0700825static int ctrl_data_write(int dsock_idx, char *buf, size_t bufsz) {
826 int ret = 0;
827
828 ret = TEMP_FAILURE_RETRY(write(data_sock[dsock_idx].sock, buf, bufsz));
829
830 if (ret == -1) {
831 ALOGE("control data socket write failed; errno=%d", errno);
832 } else if (ret == 0) {
833 ALOGE("Got EOF on control data socket");
834 ret = -1;
835 }
836
837 return ret;
838}
839
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800840static void ctrl_command_handler(int dsock_idx) {
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800841 LMKD_CTRL_PACKET packet;
Todd Poynor3948f802013-07-09 19:35:14 -0700842 int len;
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800843 enum lmk_cmd cmd;
Todd Poynor3948f802013-07-09 19:35:14 -0700844 int nargs;
845 int targets;
Suren Baghdasaryand4a29902018-10-12 11:07:40 -0700846 int kill_cnt;
Todd Poynor3948f802013-07-09 19:35:14 -0700847
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800848 len = ctrl_data_read(dsock_idx, (char *)packet, CTRL_PACKET_MAX_SIZE);
Todd Poynor3948f802013-07-09 19:35:14 -0700849 if (len <= 0)
850 return;
851
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800852 if (len < (int)sizeof(int)) {
853 ALOGE("Wrong control socket read length len=%d", len);
854 return;
855 }
856
857 cmd = lmkd_pack_get_cmd(packet);
Todd Poynor3948f802013-07-09 19:35:14 -0700858 nargs = len / sizeof(int) - 1;
859 if (nargs < 0)
860 goto wronglen;
861
Todd Poynor3948f802013-07-09 19:35:14 -0700862 switch(cmd) {
863 case LMK_TARGET:
864 targets = nargs / 2;
865 if (nargs & 0x1 || targets > (int)ARRAY_SIZE(lowmem_adj))
866 goto wronglen;
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800867 cmd_target(targets, packet);
Todd Poynor3948f802013-07-09 19:35:14 -0700868 break;
869 case LMK_PROCPRIO:
Colin Crossfbb78c62014-06-13 14:52:43 -0700870 if (nargs != 3)
Todd Poynor3948f802013-07-09 19:35:14 -0700871 goto wronglen;
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800872 cmd_procprio(packet);
Todd Poynor3948f802013-07-09 19:35:14 -0700873 break;
874 case LMK_PROCREMOVE:
875 if (nargs != 1)
876 goto wronglen;
Suren Baghdasaryan0f100512018-01-24 16:51:41 -0800877 cmd_procremove(packet);
Todd Poynor3948f802013-07-09 19:35:14 -0700878 break;
Suren Baghdasaryane3b60472018-10-10 14:17:17 -0700879 case LMK_PROCPURGE:
880 if (nargs != 0)
881 goto wronglen;
882 cmd_procpurge();
883 break;
Suren Baghdasaryand4a29902018-10-12 11:07:40 -0700884 case LMK_GETKILLCNT:
885 if (nargs != 2)
886 goto wronglen;
887 kill_cnt = cmd_getkillcnt(packet);
888 len = lmkd_pack_set_getkillcnt_repl(packet, kill_cnt);
889 if (ctrl_data_write(dsock_idx, (char *)packet, len) != len)
890 return;
891 break;
Todd Poynor3948f802013-07-09 19:35:14 -0700892 default:
893 ALOGE("Received unknown command code %d", cmd);
894 return;
895 }
896
897 return;
898
899wronglen:
900 ALOGE("Wrong control socket read length cmd=%d len=%d", cmd, len);
901}
902
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800903static void ctrl_data_handler(int data, uint32_t events) {
904 if (events & EPOLLIN) {
905 ctrl_command_handler(data);
Todd Poynor3948f802013-07-09 19:35:14 -0700906 }
907}
908
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800909static int get_free_dsock() {
910 for (int i = 0; i < MAX_DATA_CONN; i++) {
911 if (data_sock[i].sock < 0) {
912 return i;
913 }
914 }
915 return -1;
916}
Todd Poynor3948f802013-07-09 19:35:14 -0700917
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800918static void ctrl_connect_handler(int data __unused, uint32_t events __unused) {
919 struct epoll_event epev;
920 int free_dscock_idx = get_free_dsock();
921
922 if (free_dscock_idx < 0) {
923 /*
924 * Number of data connections exceeded max supported. This should not
925 * happen but if it does we drop all existing connections and accept
926 * the new one. This prevents inactive connections from monopolizing
927 * data socket and if we drop ActivityManager connection it will
928 * immediately reconnect.
929 */
930 for (int i = 0; i < MAX_DATA_CONN; i++) {
931 ctrl_data_close(i);
932 }
933 free_dscock_idx = 0;
Todd Poynor3948f802013-07-09 19:35:14 -0700934 }
935
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800936 data_sock[free_dscock_idx].sock = accept(ctrl_sock.sock, NULL, NULL);
937 if (data_sock[free_dscock_idx].sock < 0) {
Todd Poynor3948f802013-07-09 19:35:14 -0700938 ALOGE("lmkd control socket accept failed; errno=%d", errno);
939 return;
940 }
941
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800942 ALOGI("lmkd data connection established");
943 /* use data to store data connection idx */
944 data_sock[free_dscock_idx].handler_info.data = free_dscock_idx;
945 data_sock[free_dscock_idx].handler_info.handler = ctrl_data_handler;
Todd Poynor3948f802013-07-09 19:35:14 -0700946 epev.events = EPOLLIN;
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800947 epev.data.ptr = (void *)&(data_sock[free_dscock_idx].handler_info);
948 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, data_sock[free_dscock_idx].sock, &epev) == -1) {
Todd Poynor3948f802013-07-09 19:35:14 -0700949 ALOGE("epoll_ctl for data connection socket failed; errno=%d", errno);
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800950 ctrl_data_close(free_dscock_idx);
Todd Poynor3948f802013-07-09 19:35:14 -0700951 return;
952 }
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -0800953 maxevents++;
Todd Poynor3948f802013-07-09 19:35:14 -0700954}
955
Rajeev Kumar70450032018-01-31 17:54:56 -0800956#ifdef LMKD_LOG_STATS
Rajeev Kumar4dbc24d2018-10-05 12:34:59 -0700957static void memory_stat_parse_line(char* line, struct memory_stat* mem_st) {
Greg Kaiserf0da9b02018-03-23 14:16:12 -0700958 char key[LINE_MAX + 1];
Rajeev Kumar70450032018-01-31 17:54:56 -0800959 int64_t value;
960
Greg Kaiserf0da9b02018-03-23 14:16:12 -0700961 sscanf(line, "%" STRINGIFY(LINE_MAX) "s %" SCNd64 "", key, &value);
Rajeev Kumar70450032018-01-31 17:54:56 -0800962
963 if (strcmp(key, "total_") < 0) {
964 return;
965 }
966
967 if (!strcmp(key, "total_pgfault"))
968 mem_st->pgfault = value;
969 else if (!strcmp(key, "total_pgmajfault"))
970 mem_st->pgmajfault = value;
971 else if (!strcmp(key, "total_rss"))
972 mem_st->rss_in_bytes = value;
973 else if (!strcmp(key, "total_cache"))
974 mem_st->cache_in_bytes = value;
975 else if (!strcmp(key, "total_swap"))
976 mem_st->swap_in_bytes = value;
977}
978
Rajeev Kumar4dbc24d2018-10-05 12:34:59 -0700979static int memory_stat_from_cgroup(struct memory_stat* mem_st, int pid, uid_t uid) {
Suren Baghdasaryan1d1c0022018-06-19 18:38:12 -0700980 FILE *fp;
981 char buf[PATH_MAX];
Rajeev Kumar70450032018-01-31 17:54:56 -0800982
Suren Baghdasaryan1d1c0022018-06-19 18:38:12 -0700983 snprintf(buf, sizeof(buf), MEMCG_PROCESS_MEMORY_STAT_PATH, uid, pid);
Rajeev Kumar70450032018-01-31 17:54:56 -0800984
Suren Baghdasaryan1d1c0022018-06-19 18:38:12 -0700985 fp = fopen(buf, "r");
Rajeev Kumar70450032018-01-31 17:54:56 -0800986
Suren Baghdasaryan1d1c0022018-06-19 18:38:12 -0700987 if (fp == NULL) {
988 ALOGE("%s open failed: %s", buf, strerror(errno));
989 return -1;
990 }
Rajeev Kumar70450032018-01-31 17:54:56 -0800991
Rajeev Kumar4dbc24d2018-10-05 12:34:59 -0700992 while (fgets(buf, PAGE_SIZE, fp) != NULL) {
Suren Baghdasaryan1d1c0022018-06-19 18:38:12 -0700993 memory_stat_parse_line(buf, mem_st);
994 }
995 fclose(fp);
996
997 return 0;
Rajeev Kumar70450032018-01-31 17:54:56 -0800998}
Rajeev Kumar4dbc24d2018-10-05 12:34:59 -0700999
1000static int memory_stat_from_procfs(struct memory_stat* mem_st, int pid) {
1001 char path[PATH_MAX];
1002 char buffer[PROC_STAT_BUFFER_SIZE];
1003 int fd, ret;
1004
1005 snprintf(path, sizeof(path), PROC_STAT_FILE_PATH, pid);
1006 if ((fd = open(path, O_RDONLY | O_CLOEXEC)) < 0) {
1007 ALOGE("%s open failed: %s", path, strerror(errno));
1008 return -1;
1009 }
1010
1011 ret = read(fd, buffer, sizeof(buffer));
1012 if (ret < 0) {
1013 ALOGE("%s read failed: %s", path, strerror(errno));
1014 close(fd);
1015 return -1;
1016 }
1017 close(fd);
1018
1019 // field 10 is pgfault
1020 // field 12 is pgmajfault
1021 // field 24 is rss_in_pages
1022 int64_t pgfault = 0, pgmajfault = 0, rss_in_pages = 0;
1023 if (sscanf(buffer,
1024 "%*u %*s %*s %*d %*d %*d %*d %*d %*d %" SCNd64 " %*d "
1025 "%" SCNd64 " %*d %*u %*u %*d %*d %*d %*d %*d %*d "
1026 "%*d %*d %" SCNd64 "",
1027 &pgfault, &pgmajfault, &rss_in_pages) != 3) {
1028 return -1;
1029 }
1030 mem_st->pgfault = pgfault;
1031 mem_st->pgmajfault = pgmajfault;
1032 mem_st->rss_in_bytes = (rss_in_pages * PAGE_SIZE);
1033
1034 return 0;
1035}
Rajeev Kumar70450032018-01-31 17:54:56 -08001036#endif
1037
Suren Baghdasaryan8b9deaf2018-04-13 13:11:51 -07001038/* /prop/zoneinfo parsing routines */
1039static int64_t zoneinfo_parse_protection(char *cp) {
1040 int64_t max = 0;
1041 long long zoneval;
1042 char *save_ptr;
1043
1044 for (cp = strtok_r(cp, "(), ", &save_ptr); cp;
1045 cp = strtok_r(NULL, "), ", &save_ptr)) {
1046 zoneval = strtoll(cp, &cp, 0);
1047 if (zoneval > max) {
1048 max = (zoneval > INT64_MAX) ? INT64_MAX : zoneval;
1049 }
1050 }
1051
1052 return max;
1053}
1054
1055static bool zoneinfo_parse_line(char *line, union zoneinfo *zi) {
1056 char *cp = line;
1057 char *ap;
1058 char *save_ptr;
1059 int64_t val;
1060 int field_idx;
1061
1062 cp = strtok_r(line, " ", &save_ptr);
1063 if (!cp) {
1064 return true;
1065 }
1066
1067 if (!strcmp(cp, "protection:")) {
1068 ap = strtok_r(NULL, ")", &save_ptr);
1069 } else {
1070 ap = strtok_r(NULL, " ", &save_ptr);
1071 }
1072
1073 if (!ap) {
1074 return true;
1075 }
1076
1077 switch (match_field(cp, ap, zoneinfo_field_names,
1078 ZI_FIELD_COUNT, &val, &field_idx)) {
1079 case (PARSE_SUCCESS):
1080 zi->arr[field_idx] += val;
1081 break;
1082 case (NO_MATCH):
1083 if (!strcmp(cp, "protection:")) {
1084 zi->field.totalreserve_pages +=
1085 zoneinfo_parse_protection(ap);
1086 }
1087 break;
1088 case (PARSE_FAIL):
1089 default:
1090 return false;
1091 }
1092 return true;
1093}
1094
1095static int zoneinfo_parse(union zoneinfo *zi) {
1096 static struct reread_data file_data = {
1097 .filename = ZONEINFO_PATH,
1098 .fd = -1,
1099 };
1100 char buf[PAGE_SIZE];
1101 char *save_ptr;
1102 char *line;
1103
1104 memset(zi, 0, sizeof(union zoneinfo));
1105
1106 if (reread_file(&file_data, buf, sizeof(buf)) < 0) {
1107 return -1;
1108 }
1109
1110 for (line = strtok_r(buf, "\n", &save_ptr); line;
1111 line = strtok_r(NULL, "\n", &save_ptr)) {
1112 if (!zoneinfo_parse_line(line, zi)) {
1113 ALOGE("%s parse error", file_data.filename);
1114 return -1;
1115 }
1116 }
1117 zi->field.totalreserve_pages += zi->field.high;
1118
1119 return 0;
1120}
1121
1122/* /prop/meminfo parsing routines */
1123static bool meminfo_parse_line(char *line, union meminfo *mi) {
1124 char *cp = line;
1125 char *ap;
1126 char *save_ptr;
1127 int64_t val;
1128 int field_idx;
1129 enum field_match_result match_res;
1130
1131 cp = strtok_r(line, " ", &save_ptr);
1132 if (!cp) {
1133 return false;
1134 }
1135
1136 ap = strtok_r(NULL, " ", &save_ptr);
1137 if (!ap) {
1138 return false;
1139 }
1140
1141 match_res = match_field(cp, ap, meminfo_field_names, MI_FIELD_COUNT,
1142 &val, &field_idx);
1143 if (match_res == PARSE_SUCCESS) {
1144 mi->arr[field_idx] = val / page_k;
1145 }
1146 return (match_res != PARSE_FAIL);
1147}
1148
1149static int meminfo_parse(union meminfo *mi) {
1150 static struct reread_data file_data = {
1151 .filename = MEMINFO_PATH,
1152 .fd = -1,
1153 };
1154 char buf[PAGE_SIZE];
1155 char *save_ptr;
1156 char *line;
1157
1158 memset(mi, 0, sizeof(union meminfo));
1159
1160 if (reread_file(&file_data, buf, sizeof(buf)) < 0) {
1161 return -1;
1162 }
1163
1164 for (line = strtok_r(buf, "\n", &save_ptr); line;
1165 line = strtok_r(NULL, "\n", &save_ptr)) {
1166 if (!meminfo_parse_line(line, mi)) {
1167 ALOGE("%s parse error", file_data.filename);
1168 return -1;
1169 }
1170 }
1171 mi->field.nr_file_pages = mi->field.cached + mi->field.swap_cached +
1172 mi->field.buffers;
1173
1174 return 0;
1175}
1176
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -07001177static void meminfo_log(union meminfo *mi) {
1178 for (int field_idx = 0; field_idx < MI_FIELD_COUNT; field_idx++) {
1179 android_log_write_int32(ctx, (int32_t)min(mi->arr[field_idx] * page_k, INT32_MAX));
1180 }
1181
1182 android_log_write_list(ctx, LOG_ID_EVENTS);
1183 android_log_reset(ctx);
1184}
1185
Todd Poynor3948f802013-07-09 19:35:14 -07001186static int proc_get_size(int pid) {
1187 char path[PATH_MAX];
1188 char line[LINE_MAX];
Colin Crossce85d952014-07-11 17:53:27 -07001189 int fd;
Todd Poynor3948f802013-07-09 19:35:14 -07001190 int rss = 0;
1191 int total;
Colin Crossce85d952014-07-11 17:53:27 -07001192 ssize_t ret;
Todd Poynor3948f802013-07-09 19:35:14 -07001193
Mark Salyzyn64d97d82018-04-09 09:50:32 -07001194 /* gid containing AID_READPROC required */
Todd Poynor3948f802013-07-09 19:35:14 -07001195 snprintf(path, PATH_MAX, "/proc/%d/statm", pid);
Nick Kralevichc68c8862015-12-18 20:52:37 -08001196 fd = open(path, O_RDONLY | O_CLOEXEC);
Colin Crossce85d952014-07-11 17:53:27 -07001197 if (fd == -1)
Todd Poynor3948f802013-07-09 19:35:14 -07001198 return -1;
Colin Crossce85d952014-07-11 17:53:27 -07001199
1200 ret = read_all(fd, line, sizeof(line) - 1);
1201 if (ret < 0) {
1202 close(fd);
Todd Poynor3948f802013-07-09 19:35:14 -07001203 return -1;
1204 }
1205
1206 sscanf(line, "%d %d ", &total, &rss);
Colin Crossce85d952014-07-11 17:53:27 -07001207 close(fd);
Todd Poynor3948f802013-07-09 19:35:14 -07001208 return rss;
1209}
1210
1211static char *proc_get_name(int pid) {
1212 char path[PATH_MAX];
1213 static char line[LINE_MAX];
Colin Crossce85d952014-07-11 17:53:27 -07001214 int fd;
Todd Poynor3948f802013-07-09 19:35:14 -07001215 char *cp;
Colin Crossce85d952014-07-11 17:53:27 -07001216 ssize_t ret;
Todd Poynor3948f802013-07-09 19:35:14 -07001217
Mark Salyzyn64d97d82018-04-09 09:50:32 -07001218 /* gid containing AID_READPROC required */
Todd Poynor3948f802013-07-09 19:35:14 -07001219 snprintf(path, PATH_MAX, "/proc/%d/cmdline", pid);
Nick Kralevichc68c8862015-12-18 20:52:37 -08001220 fd = open(path, O_RDONLY | O_CLOEXEC);
Colin Crossce85d952014-07-11 17:53:27 -07001221 if (fd == -1)
Todd Poynor3948f802013-07-09 19:35:14 -07001222 return NULL;
Colin Crossce85d952014-07-11 17:53:27 -07001223 ret = read_all(fd, line, sizeof(line) - 1);
1224 close(fd);
1225 if (ret < 0) {
Todd Poynor3948f802013-07-09 19:35:14 -07001226 return NULL;
1227 }
1228
1229 cp = strchr(line, ' ');
1230 if (cp)
1231 *cp = '\0';
1232
1233 return line;
1234}
1235
1236static struct proc *proc_adj_lru(int oomadj) {
1237 return (struct proc *)adjslot_tail(&procadjslot_list[ADJTOSLOT(oomadj)]);
1238}
1239
Suren Baghdasaryan662492a2017-12-08 13:17:06 -08001240static struct proc *proc_get_heaviest(int oomadj) {
1241 struct adjslot_list *head = &procadjslot_list[ADJTOSLOT(oomadj)];
1242 struct adjslot_list *curr = head->next;
1243 struct proc *maxprocp = NULL;
1244 int maxsize = 0;
1245 while (curr != head) {
1246 int pid = ((struct proc *)curr)->pid;
1247 int tasksize = proc_get_size(pid);
1248 if (tasksize <= 0) {
1249 struct adjslot_list *next = curr->next;
1250 pid_remove(pid);
1251 curr = next;
1252 } else {
1253 if (tasksize > maxsize) {
1254 maxsize = tasksize;
1255 maxprocp = (struct proc *)curr;
1256 }
1257 curr = curr->next;
1258 }
1259 }
1260 return maxprocp;
1261}
1262
Colin Cross16b09462014-07-14 12:39:56 -07001263/* Kill one process specified by procp. Returns the size of the process killed */
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001264static int kill_one_process(struct proc* procp) {
Colin Cross16b09462014-07-14 12:39:56 -07001265 int pid = procp->pid;
1266 uid_t uid = procp->uid;
1267 char *taskname;
1268 int tasksize;
1269 int r;
Suren Baghdasaryan01063272018-10-12 11:28:33 -07001270 int result = -1;
Colin Cross16b09462014-07-14 12:39:56 -07001271
Rajeev Kumar70450032018-01-31 17:54:56 -08001272#ifdef LMKD_LOG_STATS
Rajeev Kumar92b659b2018-02-21 19:08:15 -08001273 struct memory_stat mem_st = {};
Rajeev Kumar70450032018-01-31 17:54:56 -08001274 int memory_stat_parse_result = -1;
1275#endif
1276
Colin Cross16b09462014-07-14 12:39:56 -07001277 taskname = proc_get_name(pid);
1278 if (!taskname) {
Suren Baghdasaryan01063272018-10-12 11:28:33 -07001279 goto out;
Colin Cross16b09462014-07-14 12:39:56 -07001280 }
1281
1282 tasksize = proc_get_size(pid);
1283 if (tasksize <= 0) {
Suren Baghdasaryan01063272018-10-12 11:28:33 -07001284 goto out;
Colin Cross16b09462014-07-14 12:39:56 -07001285 }
1286
Rajeev Kumar70450032018-01-31 17:54:56 -08001287#ifdef LMKD_LOG_STATS
1288 if (enable_stats_log) {
Rajeev Kumar4dbc24d2018-10-05 12:34:59 -07001289 if (per_app_memcg) {
1290 memory_stat_parse_result = memory_stat_from_cgroup(&mem_st, pid, uid);
1291 } else {
1292 memory_stat_parse_result = memory_stat_from_procfs(&mem_st, pid);
1293 }
Rajeev Kumar70450032018-01-31 17:54:56 -08001294 }
1295#endif
1296
Suren Baghdasaryanc7135592018-01-04 10:43:58 -08001297 TRACE_KILL_START(pid);
1298
Mark Salyzyn64d97d82018-04-09 09:50:32 -07001299 /* CAP_KILL required */
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001300 r = kill(pid, SIGKILL);
Suren Baghdasaryand4a29902018-10-12 11:07:40 -07001301 inc_killcnt(procp->oomadj);
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001302 ALOGI("Kill '%s' (%d), uid %d, oom_adj %d to free %ldkB",
1303 taskname, pid, uid, procp->oomadj, tasksize * page_k);
Colin Cross16b09462014-07-14 12:39:56 -07001304
Suren Baghdasaryanc7135592018-01-04 10:43:58 -08001305 TRACE_KILL_END();
1306
Colin Cross16b09462014-07-14 12:39:56 -07001307 if (r) {
Mark Salyzyn919f5382018-02-04 15:27:23 -08001308 ALOGE("kill(%d): errno=%d", pid, errno);
Suren Baghdasaryan01063272018-10-12 11:28:33 -07001309 goto out;
Rajeev Kumar70450032018-01-31 17:54:56 -08001310 } else {
1311#ifdef LMKD_LOG_STATS
1312 if (memory_stat_parse_result == 0) {
1313 stats_write_lmk_kill_occurred(log_ctx, LMK_KILL_OCCURRED, uid, taskname,
1314 procp->oomadj, mem_st.pgfault, mem_st.pgmajfault, mem_st.rss_in_bytes,
1315 mem_st.cache_in_bytes, mem_st.swap_in_bytes);
Rajeev Kumar4dbc24d2018-10-05 12:34:59 -07001316 } else if (enable_stats_log) {
1317 stats_write_lmk_kill_occurred(log_ctx, LMK_KILL_OCCURRED, uid, taskname, procp->oomadj,
1318 -1, -1, tasksize * BYTES_IN_KILOBYTE, -1, -1);
Rajeev Kumar70450032018-01-31 17:54:56 -08001319 }
1320#endif
Suren Baghdasaryan01063272018-10-12 11:28:33 -07001321 result = tasksize;
Colin Cross16b09462014-07-14 12:39:56 -07001322 }
Mark Salyzyn919f5382018-02-04 15:27:23 -08001323
Suren Baghdasaryan01063272018-10-12 11:28:33 -07001324out:
1325 /*
1326 * WARNING: After pid_remove() procp is freed and can't be used!
1327 * Therefore placed at the end of the function.
1328 */
1329 pid_remove(pid);
1330 return result;
Colin Cross16b09462014-07-14 12:39:56 -07001331}
1332
1333/*
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001334 * Find processes to kill to free required number of pages.
1335 * If pages_to_free is set to 0 only one process will be killed.
1336 * Returns the size of the killed processes.
Colin Cross16b09462014-07-14 12:39:56 -07001337 */
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001338static int find_and_kill_processes(int min_score_adj, int pages_to_free) {
Colin Cross16b09462014-07-14 12:39:56 -07001339 int i;
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001340 int killed_size;
1341 int pages_freed = 0;
Colin Cross16b09462014-07-14 12:39:56 -07001342
Rajeev Kumar70450032018-01-31 17:54:56 -08001343#ifdef LMKD_LOG_STATS
Yang Lu5564f4e2018-05-15 04:59:44 +00001344 bool lmk_state_change_start = false;
Rajeev Kumar70450032018-01-31 17:54:56 -08001345#endif
1346
Chong Zhang0a4acdf2015-10-14 16:19:53 -07001347 for (i = OOM_SCORE_ADJ_MAX; i >= min_score_adj; i--) {
Colin Cross16b09462014-07-14 12:39:56 -07001348 struct proc *procp;
1349
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001350 while (true) {
Suren Baghdasaryan818b59b2018-04-13 11:49:54 -07001351 procp = kill_heaviest_task ?
1352 proc_get_heaviest(i) : proc_adj_lru(i);
Colin Cross16b09462014-07-14 12:39:56 -07001353
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001354 if (!procp)
1355 break;
1356
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001357 killed_size = kill_one_process(procp);
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001358 if (killed_size >= 0) {
Yang Lu5564f4e2018-05-15 04:59:44 +00001359#ifdef LMKD_LOG_STATS
1360 if (enable_stats_log && !lmk_state_change_start) {
1361 lmk_state_change_start = true;
1362 stats_write_lmk_state_changed(log_ctx, LMK_STATE_CHANGED,
1363 LMK_STATE_CHANGE_START);
1364 }
1365#endif
1366
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001367 pages_freed += killed_size;
1368 if (pages_freed >= pages_to_free) {
Rajeev Kumar70450032018-01-31 17:54:56 -08001369
1370#ifdef LMKD_LOG_STATS
Yang Lu5564f4e2018-05-15 04:59:44 +00001371 if (enable_stats_log && lmk_state_change_start) {
Rajeev Kumar70450032018-01-31 17:54:56 -08001372 stats_write_lmk_state_changed(log_ctx, LMK_STATE_CHANGED,
1373 LMK_STATE_CHANGE_STOP);
1374 }
1375#endif
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001376 return pages_freed;
1377 }
Colin Cross16b09462014-07-14 12:39:56 -07001378 }
1379 }
1380 }
1381
Rajeev Kumar70450032018-01-31 17:54:56 -08001382#ifdef LMKD_LOG_STATS
Yang Lu5564f4e2018-05-15 04:59:44 +00001383 if (enable_stats_log && lmk_state_change_start) {
Rajeev Kumar70450032018-01-31 17:54:56 -08001384 stats_write_lmk_state_changed(log_ctx, LMK_STATE_CHANGED, LMK_STATE_CHANGE_STOP);
1385 }
1386#endif
1387
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001388 return pages_freed;
Colin Cross16b09462014-07-14 12:39:56 -07001389}
1390
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -07001391static int64_t get_memory_usage(struct reread_data *file_data) {
Robert Beneac47f2992017-08-21 15:18:31 -07001392 int ret;
1393 int64_t mem_usage;
1394 char buf[32];
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -07001395
1396 if (reread_file(file_data, buf, sizeof(buf)) < 0) {
Robert Beneac47f2992017-08-21 15:18:31 -07001397 return -1;
1398 }
1399
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -07001400 if (!parse_int64(buf, &mem_usage)) {
1401 ALOGE("%s parse error", file_data->filename);
Robert Beneac47f2992017-08-21 15:18:31 -07001402 return -1;
1403 }
Robert Beneac47f2992017-08-21 15:18:31 -07001404 if (mem_usage == 0) {
1405 ALOGE("No memory!");
1406 return -1;
1407 }
1408 return mem_usage;
1409}
1410
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001411void record_low_pressure_levels(union meminfo *mi) {
1412 if (low_pressure_mem.min_nr_free_pages == -1 ||
1413 low_pressure_mem.min_nr_free_pages > mi->field.nr_free_pages) {
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001414 if (debug_process_killing) {
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001415 ALOGI("Low pressure min memory update from %" PRId64 " to %" PRId64,
1416 low_pressure_mem.min_nr_free_pages, mi->field.nr_free_pages);
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001417 }
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001418 low_pressure_mem.min_nr_free_pages = mi->field.nr_free_pages;
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001419 }
1420 /*
1421 * Free memory at low vmpressure events occasionally gets spikes,
1422 * possibly a stale low vmpressure event with memory already
1423 * freed up (no memory pressure should have been reported).
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001424 * Ignore large jumps in max_nr_free_pages that would mess up our stats.
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001425 */
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001426 if (low_pressure_mem.max_nr_free_pages == -1 ||
1427 (low_pressure_mem.max_nr_free_pages < mi->field.nr_free_pages &&
1428 mi->field.nr_free_pages - low_pressure_mem.max_nr_free_pages <
1429 low_pressure_mem.max_nr_free_pages * 0.1)) {
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001430 if (debug_process_killing) {
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001431 ALOGI("Low pressure max memory update from %" PRId64 " to %" PRId64,
1432 low_pressure_mem.max_nr_free_pages, mi->field.nr_free_pages);
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001433 }
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001434 low_pressure_mem.max_nr_free_pages = mi->field.nr_free_pages;
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001435 }
1436}
1437
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001438enum vmpressure_level upgrade_level(enum vmpressure_level level) {
1439 return (enum vmpressure_level)((level < VMPRESS_LEVEL_CRITICAL) ?
1440 level + 1 : level);
1441}
1442
1443enum vmpressure_level downgrade_level(enum vmpressure_level level) {
1444 return (enum vmpressure_level)((level > VMPRESS_LEVEL_LOW) ?
1445 level - 1 : level);
1446}
1447
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001448static void mp_event_common(int data, uint32_t events __unused) {
Todd Poynor3948f802013-07-09 19:35:14 -07001449 int ret;
1450 unsigned long long evcount;
Robert Beneac47f2992017-08-21 15:18:31 -07001451 int64_t mem_usage, memsw_usage;
Robert Benea6e8e7102017-09-13 15:20:30 -07001452 int64_t mem_pressure;
Suren Baghdasaryane82e15c2018-01-04 09:16:21 -08001453 enum vmpressure_level lvl;
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001454 union meminfo mi;
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001455 union zoneinfo zi;
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001456 struct timespec curr_tm;
Suren Baghdasaryan314a5052018-07-24 17:13:06 -07001457 static struct timespec last_kill_tm;
1458 static unsigned long kill_skip_count = 0;
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001459 enum vmpressure_level level = (enum vmpressure_level)data;
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001460 long other_free = 0, other_file = 0;
1461 int min_score_adj;
1462 int pages_to_free = 0;
1463 int minfree = 0;
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -07001464 static struct reread_data mem_usage_file_data = {
1465 .filename = MEMCG_MEMORY_USAGE,
1466 .fd = -1,
1467 };
1468 static struct reread_data memsw_usage_file_data = {
1469 .filename = MEMCG_MEMORYSW_USAGE,
1470 .fd = -1,
1471 };
Todd Poynor3948f802013-07-09 19:35:14 -07001472
Suren Baghdasaryane82e15c2018-01-04 09:16:21 -08001473 /*
1474 * Check all event counters from low to critical
1475 * and upgrade to the highest priority one. By reading
1476 * eventfd we also reset the event counters.
1477 */
1478 for (lvl = VMPRESS_LEVEL_LOW; lvl < VMPRESS_LEVEL_COUNT; lvl++) {
1479 if (mpevfd[lvl] != -1 &&
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -07001480 TEMP_FAILURE_RETRY(read(mpevfd[lvl],
1481 &evcount, sizeof(evcount))) > 0 &&
Suren Baghdasaryane82e15c2018-01-04 09:16:21 -08001482 evcount > 0 && lvl > level) {
1483 level = lvl;
1484 }
1485 }
Todd Poynor3948f802013-07-09 19:35:14 -07001486
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001487 if (clock_gettime(CLOCK_MONOTONIC_COARSE, &curr_tm) != 0) {
1488 ALOGE("Failed to get current time");
1489 return;
1490 }
1491
Suren Baghdasaryancaa2dc52018-01-17 17:28:01 -08001492 if (kill_timeout_ms) {
Suren Baghdasaryan314a5052018-07-24 17:13:06 -07001493 if (get_time_diff_ms(&last_kill_tm, &curr_tm) < kill_timeout_ms) {
1494 kill_skip_count++;
Suren Baghdasaryancaa2dc52018-01-17 17:28:01 -08001495 return;
1496 }
1497 }
1498
Suren Baghdasaryan314a5052018-07-24 17:13:06 -07001499 if (kill_skip_count > 0) {
Suren Baghdasaryanda88b242018-05-10 16:10:56 -07001500 ALOGI("%lu memory pressure events were skipped after a kill!",
Suren Baghdasaryan314a5052018-07-24 17:13:06 -07001501 kill_skip_count);
1502 kill_skip_count = 0;
Suren Baghdasaryancaa2dc52018-01-17 17:28:01 -08001503 }
1504
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001505 if (meminfo_parse(&mi) < 0 || zoneinfo_parse(&zi) < 0) {
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001506 ALOGE("Failed to get free memory!");
1507 return;
1508 }
1509
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001510 if (use_minfree_levels) {
1511 int i;
1512
1513 other_free = mi.field.nr_free_pages - zi.field.totalreserve_pages;
1514 if (mi.field.nr_file_pages > (mi.field.shmem + mi.field.unevictable + mi.field.swap_cached)) {
1515 other_file = (mi.field.nr_file_pages - mi.field.shmem -
1516 mi.field.unevictable - mi.field.swap_cached);
1517 } else {
1518 other_file = 0;
1519 }
1520
1521 min_score_adj = OOM_SCORE_ADJ_MAX + 1;
1522 for (i = 0; i < lowmem_targets_size; i++) {
1523 minfree = lowmem_minfree[i];
1524 if (other_free < minfree && other_file < minfree) {
1525 min_score_adj = lowmem_adj[i];
1526 break;
1527 }
1528 }
1529
Suren Baghdasaryan20686f02018-05-18 14:42:00 -07001530 if (min_score_adj == OOM_SCORE_ADJ_MAX + 1) {
1531 if (debug_process_killing) {
1532 ALOGI("Ignore %s memory pressure event "
1533 "(free memory=%ldkB, cache=%ldkB, limit=%ldkB)",
1534 level_name[level], other_free * page_k, other_file * page_k,
1535 (long)lowmem_minfree[lowmem_targets_size - 1] * page_k);
1536 }
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001537 return;
Suren Baghdasaryan20686f02018-05-18 14:42:00 -07001538 }
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001539
1540 /* Free up enough pages to push over the highest minfree level */
1541 pages_to_free = lowmem_minfree[lowmem_targets_size - 1] -
1542 ((other_free < other_file) ? other_free : other_file);
1543 goto do_kill;
1544 }
1545
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001546 if (level == VMPRESS_LEVEL_LOW) {
1547 record_low_pressure_levels(&mi);
1548 }
1549
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001550 if (level_oomadj[level] > OOM_SCORE_ADJ_MAX) {
1551 /* Do not monitor this pressure level */
1552 return;
1553 }
1554
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -07001555 if ((mem_usage = get_memory_usage(&mem_usage_file_data)) < 0) {
1556 goto do_kill;
1557 }
1558 if ((memsw_usage = get_memory_usage(&memsw_usage_file_data)) < 0) {
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001559 goto do_kill;
Robert Benea6e8e7102017-09-13 15:20:30 -07001560 }
Robert Beneac47f2992017-08-21 15:18:31 -07001561
Robert Benea6e8e7102017-09-13 15:20:30 -07001562 // Calculate percent for swappinness.
1563 mem_pressure = (mem_usage * 100) / memsw_usage;
1564
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001565 if (enable_pressure_upgrade && level != VMPRESS_LEVEL_CRITICAL) {
Robert Benea6e8e7102017-09-13 15:20:30 -07001566 // We are swapping too much.
1567 if (mem_pressure < upgrade_pressure) {
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001568 level = upgrade_level(level);
1569 if (debug_process_killing) {
1570 ALOGI("Event upgraded to %s", level_name[level]);
1571 }
Robert Beneac47f2992017-08-21 15:18:31 -07001572 }
1573 }
1574
Vic Yang360a1132018-08-07 10:18:22 -07001575 // If we still have enough swap space available, check if we want to
1576 // ignore/downgrade pressure events.
1577 if (mi.field.free_swap >=
1578 mi.field.total_swap * swap_free_low_percentage / 100) {
1579 // If the pressure is larger than downgrade_pressure lmk will not
1580 // kill any process, since enough memory is available.
1581 if (mem_pressure > downgrade_pressure) {
1582 if (debug_process_killing) {
1583 ALOGI("Ignore %s memory pressure", level_name[level]);
1584 }
1585 return;
1586 } else if (level == VMPRESS_LEVEL_CRITICAL && mem_pressure > upgrade_pressure) {
1587 if (debug_process_killing) {
1588 ALOGI("Downgrade critical memory pressure");
1589 }
1590 // Downgrade event, since enough memory available.
1591 level = downgrade_level(level);
Robert Benea6e8e7102017-09-13 15:20:30 -07001592 }
Robert Benea6e8e7102017-09-13 15:20:30 -07001593 }
1594
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001595do_kill:
Suren Baghdasaryanff61afb2018-04-13 11:45:38 -07001596 if (low_ram_device) {
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001597 /* For Go devices kill only one task */
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001598 if (find_and_kill_processes(level_oomadj[level], 0) == 0) {
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001599 if (debug_process_killing) {
1600 ALOGI("Nothing to kill");
1601 }
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -07001602 } else {
1603 meminfo_log(&mi);
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001604 }
1605 } else {
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001606 int pages_freed;
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001607 static struct timespec last_report_tm;
1608 static unsigned long report_skip_count = 0;
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001609
1610 if (!use_minfree_levels) {
1611 /* If pressure level is less than critical and enough free swap then ignore */
1612 if (level < VMPRESS_LEVEL_CRITICAL &&
1613 mi.field.free_swap > low_pressure_mem.max_nr_free_pages) {
1614 if (debug_process_killing) {
1615 ALOGI("Ignoring pressure since %" PRId64
1616 " swap pages are available ",
1617 mi.field.free_swap);
1618 }
1619 return;
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001620 }
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001621 /* Free up enough memory to downgrate the memory pressure to low level */
1622 if (mi.field.nr_free_pages < low_pressure_mem.max_nr_free_pages) {
1623 pages_to_free = low_pressure_mem.max_nr_free_pages -
1624 mi.field.nr_free_pages;
1625 } else {
1626 if (debug_process_killing) {
1627 ALOGI("Ignoring pressure since more memory is "
1628 "available (%" PRId64 ") than watermark (%" PRId64 ")",
1629 mi.field.nr_free_pages, low_pressure_mem.max_nr_free_pages);
1630 }
1631 return;
1632 }
1633 min_score_adj = level_oomadj[level];
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001634 }
1635
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001636 pages_freed = find_and_kill_processes(min_score_adj, pages_to_free);
Suren Baghdasaryanda88b242018-05-10 16:10:56 -07001637
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001638 if (pages_freed == 0) {
1639 /* Rate limit kill reports when nothing was reclaimed */
1640 if (get_time_diff_ms(&last_report_tm, &curr_tm) < FAIL_REPORT_RLIMIT_MS) {
1641 report_skip_count++;
Suren Baghdasaryan314a5052018-07-24 17:13:06 -07001642 return;
1643 }
Robert Beneacaeaa652017-08-11 16:03:20 -07001644 }
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001645
1646 /* Log meminfo whenever we kill or when report rate limit allows */
1647 meminfo_log(&mi);
1648 if (pages_freed >= pages_to_free) {
1649 /* Reset kill time only if reclaimed enough memory */
1650 last_kill_tm = curr_tm;
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -07001651 }
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001652
1653 if (use_minfree_levels) {
1654 ALOGI("Killing to reclaim %ldkB, reclaimed %ldkB, cache(%ldkB) and "
1655 "free(%" PRId64 "kB)-reserved(%" PRId64 "kB) below min(%ldkB) for oom_adj %d",
1656 pages_to_free * page_k, pages_freed * page_k,
1657 other_file * page_k, mi.field.nr_free_pages * page_k,
1658 zi.field.totalreserve_pages * page_k,
1659 minfree * page_k, min_score_adj);
1660 } else {
1661 ALOGI("Killing to reclaim %ldkB, reclaimed %ldkB at oom_adj %d",
1662 pages_to_free * page_k, pages_freed * page_k, min_score_adj);
1663 }
1664
1665 if (report_skip_count > 0) {
1666 ALOGI("Suppressed %lu failed kill reports", report_skip_count);
1667 report_skip_count = 0;
1668 }
1669
1670 last_report_tm = curr_tm;
Colin Crossf8857cc2014-07-11 17:16:56 -07001671 }
Todd Poynor3948f802013-07-09 19:35:14 -07001672}
1673
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001674static bool init_mp_common(enum vmpressure_level level) {
Todd Poynor3948f802013-07-09 19:35:14 -07001675 int mpfd;
1676 int evfd;
1677 int evctlfd;
1678 char buf[256];
1679 struct epoll_event epev;
1680 int ret;
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001681 int level_idx = (int)level;
1682 const char *levelstr = level_name[level_idx];
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001683
Mark Salyzyn64d97d82018-04-09 09:50:32 -07001684 /* gid containing AID_SYSTEM required */
Nick Kralevichc68c8862015-12-18 20:52:37 -08001685 mpfd = open(MEMCG_SYSFS_PATH "memory.pressure_level", O_RDONLY | O_CLOEXEC);
Todd Poynor3948f802013-07-09 19:35:14 -07001686 if (mpfd < 0) {
1687 ALOGI("No kernel memory.pressure_level support (errno=%d)", errno);
1688 goto err_open_mpfd;
1689 }
1690
Nick Kralevichc68c8862015-12-18 20:52:37 -08001691 evctlfd = open(MEMCG_SYSFS_PATH "cgroup.event_control", O_WRONLY | O_CLOEXEC);
Todd Poynor3948f802013-07-09 19:35:14 -07001692 if (evctlfd < 0) {
1693 ALOGI("No kernel memory cgroup event control (errno=%d)", errno);
1694 goto err_open_evctlfd;
1695 }
1696
Nick Kralevichc68c8862015-12-18 20:52:37 -08001697 evfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
Todd Poynor3948f802013-07-09 19:35:14 -07001698 if (evfd < 0) {
1699 ALOGE("eventfd failed for level %s; errno=%d", levelstr, errno);
1700 goto err_eventfd;
1701 }
1702
1703 ret = snprintf(buf, sizeof(buf), "%d %d %s", evfd, mpfd, levelstr);
1704 if (ret >= (ssize_t)sizeof(buf)) {
1705 ALOGE("cgroup.event_control line overflow for level %s", levelstr);
1706 goto err;
1707 }
1708
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001709 ret = TEMP_FAILURE_RETRY(write(evctlfd, buf, strlen(buf) + 1));
Todd Poynor3948f802013-07-09 19:35:14 -07001710 if (ret == -1) {
1711 ALOGE("cgroup.event_control write failed for level %s; errno=%d",
1712 levelstr, errno);
1713 goto err;
1714 }
1715
1716 epev.events = EPOLLIN;
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001717 /* use data to store event level */
1718 vmpressure_hinfo[level_idx].data = level_idx;
1719 vmpressure_hinfo[level_idx].handler = mp_event_common;
1720 epev.data.ptr = (void *)&vmpressure_hinfo[level_idx];
Todd Poynor3948f802013-07-09 19:35:14 -07001721 ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, evfd, &epev);
1722 if (ret == -1) {
1723 ALOGE("epoll_ctl for level %s failed; errno=%d", levelstr, errno);
1724 goto err;
1725 }
1726 maxevents++;
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001727 mpevfd[level] = evfd;
Suren Baghdasaryan1bd2fc42018-01-04 08:54:53 -08001728 close(evctlfd);
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001729 return true;
Todd Poynor3948f802013-07-09 19:35:14 -07001730
1731err:
1732 close(evfd);
1733err_eventfd:
1734 close(evctlfd);
1735err_open_evctlfd:
1736 close(mpfd);
1737err_open_mpfd:
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001738 return false;
Robert Benea673e2762017-06-01 16:32:31 -07001739}
1740
Todd Poynor3948f802013-07-09 19:35:14 -07001741static int init(void) {
1742 struct epoll_event epev;
1743 int i;
1744 int ret;
1745
1746 page_k = sysconf(_SC_PAGESIZE);
1747 if (page_k == -1)
1748 page_k = PAGE_SIZE;
1749 page_k /= 1024;
1750
1751 epollfd = epoll_create(MAX_EPOLL_EVENTS);
1752 if (epollfd == -1) {
1753 ALOGE("epoll_create failed (errno=%d)", errno);
1754 return -1;
1755 }
1756
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001757 // mark data connections as not connected
1758 for (int i = 0; i < MAX_DATA_CONN; i++) {
1759 data_sock[i].sock = -1;
1760 }
1761
1762 ctrl_sock.sock = android_get_control_socket("lmkd");
1763 if (ctrl_sock.sock < 0) {
Todd Poynor3948f802013-07-09 19:35:14 -07001764 ALOGE("get lmkd control socket failed");
1765 return -1;
1766 }
1767
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001768 ret = listen(ctrl_sock.sock, MAX_DATA_CONN);
Todd Poynor3948f802013-07-09 19:35:14 -07001769 if (ret < 0) {
1770 ALOGE("lmkd control socket listen failed (errno=%d)", errno);
1771 return -1;
1772 }
1773
1774 epev.events = EPOLLIN;
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001775 ctrl_sock.handler_info.handler = ctrl_connect_handler;
1776 epev.data.ptr = (void *)&(ctrl_sock.handler_info);
1777 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_sock.sock, &epev) == -1) {
Todd Poynor3948f802013-07-09 19:35:14 -07001778 ALOGE("epoll_ctl for lmkd control socket failed (errno=%d)", errno);
1779 return -1;
1780 }
1781 maxevents++;
1782
Robert Benea164baeb2017-09-11 16:53:28 -07001783 has_inkernel_module = !access(INKERNEL_MINFREE_PATH, W_OK);
Suren Baghdasaryan979591b2018-01-18 17:27:30 -08001784 use_inkernel_interface = has_inkernel_module;
Todd Poynor3948f802013-07-09 19:35:14 -07001785
1786 if (use_inkernel_interface) {
1787 ALOGI("Using in-kernel low memory killer interface");
1788 } else {
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001789 if (!init_mp_common(VMPRESS_LEVEL_LOW) ||
1790 !init_mp_common(VMPRESS_LEVEL_MEDIUM) ||
1791 !init_mp_common(VMPRESS_LEVEL_CRITICAL)) {
Todd Poynor3948f802013-07-09 19:35:14 -07001792 ALOGE("Kernel does not support memory pressure events or in-kernel low memory killer");
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001793 return -1;
1794 }
Todd Poynor3948f802013-07-09 19:35:14 -07001795 }
1796
Chong Zhang0a4acdf2015-10-14 16:19:53 -07001797 for (i = 0; i <= ADJTOSLOT(OOM_SCORE_ADJ_MAX); i++) {
Todd Poynor3948f802013-07-09 19:35:14 -07001798 procadjslot_list[i].next = &procadjslot_list[i];
1799 procadjslot_list[i].prev = &procadjslot_list[i];
1800 }
1801
Suren Baghdasaryand4a29902018-10-12 11:07:40 -07001802 memset(killcnt_idx, KILLCNT_INVALID_IDX, sizeof(killcnt_idx));
1803
Todd Poynor3948f802013-07-09 19:35:14 -07001804 return 0;
1805}
1806
1807static void mainloop(void) {
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001808 struct event_handler_info* handler_info;
1809 struct epoll_event *evt;
1810
Todd Poynor3948f802013-07-09 19:35:14 -07001811 while (1) {
1812 struct epoll_event events[maxevents];
1813 int nevents;
1814 int i;
1815
Todd Poynor3948f802013-07-09 19:35:14 -07001816 nevents = epoll_wait(epollfd, events, maxevents, -1);
1817
1818 if (nevents == -1) {
1819 if (errno == EINTR)
1820 continue;
1821 ALOGE("epoll_wait failed (errno=%d)", errno);
1822 continue;
1823 }
1824
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001825 /*
1826 * First pass to see if any data socket connections were dropped.
1827 * Dropped connection should be handled before any other events
1828 * to deallocate data connection and correctly handle cases when
1829 * connection gets dropped and reestablished in the same epoll cycle.
1830 * In such cases it's essential to handle connection closures first.
1831 */
1832 for (i = 0, evt = &events[0]; i < nevents; ++i, evt++) {
1833 if ((evt->events & EPOLLHUP) && evt->data.ptr) {
1834 ALOGI("lmkd data connection dropped");
1835 handler_info = (struct event_handler_info*)evt->data.ptr;
1836 ctrl_data_close(handler_info->data);
1837 }
1838 }
1839
1840 /* Second pass to handle all other events */
1841 for (i = 0, evt = &events[0]; i < nevents; ++i, evt++) {
1842 if (evt->events & EPOLLERR)
Todd Poynor3948f802013-07-09 19:35:14 -07001843 ALOGD("EPOLLERR on event #%d", i);
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001844 if (evt->events & EPOLLHUP) {
1845 /* This case was handled in the first pass */
1846 continue;
1847 }
1848 if (evt->data.ptr) {
1849 handler_info = (struct event_handler_info*)evt->data.ptr;
1850 handler_info->handler(handler_info->data, evt->events);
1851 }
Todd Poynor3948f802013-07-09 19:35:14 -07001852 }
1853 }
1854}
1855
Mark Salyzyne6ed68b2014-04-30 13:36:35 -07001856int main(int argc __unused, char **argv __unused) {
Colin Cross1a0d9be2014-07-14 14:31:15 -07001857 struct sched_param param = {
1858 .sched_priority = 1,
1859 };
1860
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001861 /* By default disable low level vmpressure events */
1862 level_oomadj[VMPRESS_LEVEL_LOW] =
1863 property_get_int32("ro.lmk.low", OOM_SCORE_ADJ_MAX + 1);
1864 level_oomadj[VMPRESS_LEVEL_MEDIUM] =
1865 property_get_int32("ro.lmk.medium", 800);
1866 level_oomadj[VMPRESS_LEVEL_CRITICAL] =
1867 property_get_int32("ro.lmk.critical", 0);
Robert Beneacaeaa652017-08-11 16:03:20 -07001868 debug_process_killing = property_get_bool("ro.lmk.debug", false);
Suren Baghdasaryanad2fd912017-12-08 13:08:41 -08001869
1870 /* By default disable upgrade/downgrade logic */
1871 enable_pressure_upgrade =
1872 property_get_bool("ro.lmk.critical_upgrade", false);
1873 upgrade_pressure =
1874 (int64_t)property_get_int32("ro.lmk.upgrade_pressure", 100);
1875 downgrade_pressure =
1876 (int64_t)property_get_int32("ro.lmk.downgrade_pressure", 100);
Suren Baghdasaryan662492a2017-12-08 13:17:06 -08001877 kill_heaviest_task =
Suren Baghdasaryan818b59b2018-04-13 11:49:54 -07001878 property_get_bool("ro.lmk.kill_heaviest_task", false);
Suren Baghdasaryanff61afb2018-04-13 11:45:38 -07001879 low_ram_device = property_get_bool("ro.config.low_ram", false);
Suren Baghdasaryancaa2dc52018-01-17 17:28:01 -08001880 kill_timeout_ms =
1881 (unsigned long)property_get_int32("ro.lmk.kill_timeout_ms", 0);
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001882 use_minfree_levels =
1883 property_get_bool("ro.lmk.use_minfree_levels", false);
Suren Baghdasaryance13cb52018-06-19 18:38:12 -07001884 per_app_memcg =
1885 property_get_bool("ro.config.per_app_memcg", low_ram_device);
Vic Yang360a1132018-08-07 10:18:22 -07001886 swap_free_low_percentage =
1887 property_get_int32("ro.lmk.swap_free_low_percentage", 10);
Robert Benea58891d52017-07-31 17:15:20 -07001888
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -07001889 ctx = create_android_logger(MEMINFO_LOG_TAG);
1890
Rajeev Kumar70450032018-01-31 17:54:56 -08001891#ifdef LMKD_LOG_STATS
Rajeev Kumar1c669f72018-03-09 15:20:56 -08001892 statslog_init(&log_ctx, &enable_stats_log);
Rajeev Kumar70450032018-01-31 17:54:56 -08001893#endif
1894
Mark Salyzyn721d7c72018-03-21 12:24:58 -07001895 if (!init()) {
1896 if (!use_inkernel_interface) {
1897 /*
1898 * MCL_ONFAULT pins pages as they fault instead of loading
1899 * everything immediately all at once. (Which would be bad,
1900 * because as of this writing, we have a lot of mapped pages we
1901 * never use.) Old kernels will see MCL_ONFAULT and fail with
1902 * EINVAL; we ignore this failure.
1903 *
1904 * N.B. read the man page for mlockall. MCL_CURRENT | MCL_ONFAULT
1905 * pins ⊆ MCL_CURRENT, converging to just MCL_CURRENT as we fault
1906 * in pages.
1907 */
Mark Salyzyn64d97d82018-04-09 09:50:32 -07001908 /* CAP_IPC_LOCK required */
Mark Salyzyn721d7c72018-03-21 12:24:58 -07001909 if (mlockall(MCL_CURRENT | MCL_FUTURE | MCL_ONFAULT) && (errno != EINVAL)) {
1910 ALOGW("mlockall failed %s", strerror(errno));
1911 }
Daniel Colascione4dd5d002018-01-03 12:01:02 -08001912
Mark Salyzyn64d97d82018-04-09 09:50:32 -07001913 /* CAP_NICE required */
1914 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
1915 ALOGW("set SCHED_FIFO failed %s", strerror(errno));
1916 }
Mark Salyzyn721d7c72018-03-21 12:24:58 -07001917 }
1918
Todd Poynor3948f802013-07-09 19:35:14 -07001919 mainloop();
Mark Salyzyn721d7c72018-03-21 12:24:58 -07001920 }
Todd Poynor3948f802013-07-09 19:35:14 -07001921
Rajeev Kumar70450032018-01-31 17:54:56 -08001922#ifdef LMKD_LOG_STATS
Rajeev Kumar1c669f72018-03-09 15:20:56 -08001923 statslog_destroy(&log_ctx);
Rajeev Kumar70450032018-01-31 17:54:56 -08001924#endif
1925
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -07001926 android_log_destroy(&ctx);
1927
Todd Poynor3948f802013-07-09 19:35:14 -07001928 ALOGI("exiting");
1929 return 0;
1930}