blob: 7794f81fab463bf640c7ae4f7e0f601618fed298 [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
Jim Blackler1417cdb2018-11-21 16:22:36 +00001021 // field 22 is starttime
Rajeev Kumar4dbc24d2018-10-05 12:34:59 -07001022 // field 24 is rss_in_pages
Jim Blackler1417cdb2018-11-21 16:22:36 +00001023 int64_t pgfault = 0, pgmajfault = 0, starttime = 0, rss_in_pages = 0;
Rajeev Kumar4dbc24d2018-10-05 12:34:59 -07001024 if (sscanf(buffer,
1025 "%*u %*s %*s %*d %*d %*d %*d %*d %*d %" SCNd64 " %*d "
1026 "%" SCNd64 " %*d %*u %*u %*d %*d %*d %*d %*d %*d "
Jim Blackler1417cdb2018-11-21 16:22:36 +00001027 "%" SCNd64 " %*d %" SCNd64 "",
1028 &pgfault, &pgmajfault, &starttime, &rss_in_pages) != 4) {
Rajeev Kumar4dbc24d2018-10-05 12:34:59 -07001029 return -1;
1030 }
1031 mem_st->pgfault = pgfault;
1032 mem_st->pgmajfault = pgmajfault;
1033 mem_st->rss_in_bytes = (rss_in_pages * PAGE_SIZE);
Jim Blackler1417cdb2018-11-21 16:22:36 +00001034 mem_st->process_start_time_ns = starttime * (NS_PER_SEC / sysconf(_SC_CLK_TCK));
Rajeev Kumar4dbc24d2018-10-05 12:34:59 -07001035 return 0;
1036}
Rajeev Kumar70450032018-01-31 17:54:56 -08001037#endif
1038
Suren Baghdasaryan8b9deaf2018-04-13 13:11:51 -07001039/* /prop/zoneinfo parsing routines */
1040static int64_t zoneinfo_parse_protection(char *cp) {
1041 int64_t max = 0;
1042 long long zoneval;
1043 char *save_ptr;
1044
1045 for (cp = strtok_r(cp, "(), ", &save_ptr); cp;
1046 cp = strtok_r(NULL, "), ", &save_ptr)) {
1047 zoneval = strtoll(cp, &cp, 0);
1048 if (zoneval > max) {
1049 max = (zoneval > INT64_MAX) ? INT64_MAX : zoneval;
1050 }
1051 }
1052
1053 return max;
1054}
1055
1056static bool zoneinfo_parse_line(char *line, union zoneinfo *zi) {
1057 char *cp = line;
1058 char *ap;
1059 char *save_ptr;
1060 int64_t val;
1061 int field_idx;
1062
1063 cp = strtok_r(line, " ", &save_ptr);
1064 if (!cp) {
1065 return true;
1066 }
1067
1068 if (!strcmp(cp, "protection:")) {
1069 ap = strtok_r(NULL, ")", &save_ptr);
1070 } else {
1071 ap = strtok_r(NULL, " ", &save_ptr);
1072 }
1073
1074 if (!ap) {
1075 return true;
1076 }
1077
1078 switch (match_field(cp, ap, zoneinfo_field_names,
1079 ZI_FIELD_COUNT, &val, &field_idx)) {
1080 case (PARSE_SUCCESS):
1081 zi->arr[field_idx] += val;
1082 break;
1083 case (NO_MATCH):
1084 if (!strcmp(cp, "protection:")) {
1085 zi->field.totalreserve_pages +=
1086 zoneinfo_parse_protection(ap);
1087 }
1088 break;
1089 case (PARSE_FAIL):
1090 default:
1091 return false;
1092 }
1093 return true;
1094}
1095
1096static int zoneinfo_parse(union zoneinfo *zi) {
1097 static struct reread_data file_data = {
1098 .filename = ZONEINFO_PATH,
1099 .fd = -1,
1100 };
1101 char buf[PAGE_SIZE];
1102 char *save_ptr;
1103 char *line;
1104
1105 memset(zi, 0, sizeof(union zoneinfo));
1106
1107 if (reread_file(&file_data, buf, sizeof(buf)) < 0) {
1108 return -1;
1109 }
1110
1111 for (line = strtok_r(buf, "\n", &save_ptr); line;
1112 line = strtok_r(NULL, "\n", &save_ptr)) {
1113 if (!zoneinfo_parse_line(line, zi)) {
1114 ALOGE("%s parse error", file_data.filename);
1115 return -1;
1116 }
1117 }
1118 zi->field.totalreserve_pages += zi->field.high;
1119
1120 return 0;
1121}
1122
1123/* /prop/meminfo parsing routines */
1124static bool meminfo_parse_line(char *line, union meminfo *mi) {
1125 char *cp = line;
1126 char *ap;
1127 char *save_ptr;
1128 int64_t val;
1129 int field_idx;
1130 enum field_match_result match_res;
1131
1132 cp = strtok_r(line, " ", &save_ptr);
1133 if (!cp) {
1134 return false;
1135 }
1136
1137 ap = strtok_r(NULL, " ", &save_ptr);
1138 if (!ap) {
1139 return false;
1140 }
1141
1142 match_res = match_field(cp, ap, meminfo_field_names, MI_FIELD_COUNT,
1143 &val, &field_idx);
1144 if (match_res == PARSE_SUCCESS) {
1145 mi->arr[field_idx] = val / page_k;
1146 }
1147 return (match_res != PARSE_FAIL);
1148}
1149
1150static int meminfo_parse(union meminfo *mi) {
1151 static struct reread_data file_data = {
1152 .filename = MEMINFO_PATH,
1153 .fd = -1,
1154 };
1155 char buf[PAGE_SIZE];
1156 char *save_ptr;
1157 char *line;
1158
1159 memset(mi, 0, sizeof(union meminfo));
1160
1161 if (reread_file(&file_data, buf, sizeof(buf)) < 0) {
1162 return -1;
1163 }
1164
1165 for (line = strtok_r(buf, "\n", &save_ptr); line;
1166 line = strtok_r(NULL, "\n", &save_ptr)) {
1167 if (!meminfo_parse_line(line, mi)) {
1168 ALOGE("%s parse error", file_data.filename);
1169 return -1;
1170 }
1171 }
1172 mi->field.nr_file_pages = mi->field.cached + mi->field.swap_cached +
1173 mi->field.buffers;
1174
1175 return 0;
1176}
1177
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -07001178static void meminfo_log(union meminfo *mi) {
1179 for (int field_idx = 0; field_idx < MI_FIELD_COUNT; field_idx++) {
1180 android_log_write_int32(ctx, (int32_t)min(mi->arr[field_idx] * page_k, INT32_MAX));
1181 }
1182
1183 android_log_write_list(ctx, LOG_ID_EVENTS);
1184 android_log_reset(ctx);
1185}
1186
Todd Poynor3948f802013-07-09 19:35:14 -07001187static int proc_get_size(int pid) {
1188 char path[PATH_MAX];
1189 char line[LINE_MAX];
Colin Crossce85d952014-07-11 17:53:27 -07001190 int fd;
Todd Poynor3948f802013-07-09 19:35:14 -07001191 int rss = 0;
1192 int total;
Colin Crossce85d952014-07-11 17:53:27 -07001193 ssize_t ret;
Todd Poynor3948f802013-07-09 19:35:14 -07001194
Mark Salyzyn64d97d82018-04-09 09:50:32 -07001195 /* gid containing AID_READPROC required */
Todd Poynor3948f802013-07-09 19:35:14 -07001196 snprintf(path, PATH_MAX, "/proc/%d/statm", pid);
Nick Kralevichc68c8862015-12-18 20:52:37 -08001197 fd = open(path, O_RDONLY | O_CLOEXEC);
Colin Crossce85d952014-07-11 17:53:27 -07001198 if (fd == -1)
Todd Poynor3948f802013-07-09 19:35:14 -07001199 return -1;
Colin Crossce85d952014-07-11 17:53:27 -07001200
1201 ret = read_all(fd, line, sizeof(line) - 1);
1202 if (ret < 0) {
1203 close(fd);
Todd Poynor3948f802013-07-09 19:35:14 -07001204 return -1;
1205 }
1206
1207 sscanf(line, "%d %d ", &total, &rss);
Colin Crossce85d952014-07-11 17:53:27 -07001208 close(fd);
Todd Poynor3948f802013-07-09 19:35:14 -07001209 return rss;
1210}
1211
1212static char *proc_get_name(int pid) {
1213 char path[PATH_MAX];
1214 static char line[LINE_MAX];
Colin Crossce85d952014-07-11 17:53:27 -07001215 int fd;
Todd Poynor3948f802013-07-09 19:35:14 -07001216 char *cp;
Colin Crossce85d952014-07-11 17:53:27 -07001217 ssize_t ret;
Todd Poynor3948f802013-07-09 19:35:14 -07001218
Mark Salyzyn64d97d82018-04-09 09:50:32 -07001219 /* gid containing AID_READPROC required */
Todd Poynor3948f802013-07-09 19:35:14 -07001220 snprintf(path, PATH_MAX, "/proc/%d/cmdline", pid);
Nick Kralevichc68c8862015-12-18 20:52:37 -08001221 fd = open(path, O_RDONLY | O_CLOEXEC);
Colin Crossce85d952014-07-11 17:53:27 -07001222 if (fd == -1)
Todd Poynor3948f802013-07-09 19:35:14 -07001223 return NULL;
Colin Crossce85d952014-07-11 17:53:27 -07001224 ret = read_all(fd, line, sizeof(line) - 1);
1225 close(fd);
1226 if (ret < 0) {
Todd Poynor3948f802013-07-09 19:35:14 -07001227 return NULL;
1228 }
1229
1230 cp = strchr(line, ' ');
1231 if (cp)
1232 *cp = '\0';
1233
1234 return line;
1235}
1236
1237static struct proc *proc_adj_lru(int oomadj) {
1238 return (struct proc *)adjslot_tail(&procadjslot_list[ADJTOSLOT(oomadj)]);
1239}
1240
Suren Baghdasaryan662492a2017-12-08 13:17:06 -08001241static struct proc *proc_get_heaviest(int oomadj) {
1242 struct adjslot_list *head = &procadjslot_list[ADJTOSLOT(oomadj)];
1243 struct adjslot_list *curr = head->next;
1244 struct proc *maxprocp = NULL;
1245 int maxsize = 0;
1246 while (curr != head) {
1247 int pid = ((struct proc *)curr)->pid;
1248 int tasksize = proc_get_size(pid);
1249 if (tasksize <= 0) {
1250 struct adjslot_list *next = curr->next;
1251 pid_remove(pid);
1252 curr = next;
1253 } else {
1254 if (tasksize > maxsize) {
1255 maxsize = tasksize;
1256 maxprocp = (struct proc *)curr;
1257 }
1258 curr = curr->next;
1259 }
1260 }
1261 return maxprocp;
1262}
1263
Tim Murraye7853f62018-10-25 17:05:41 -07001264static int last_killed_pid = -1;
1265
Colin Cross16b09462014-07-14 12:39:56 -07001266/* Kill one process specified by procp. Returns the size of the process killed */
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001267static int kill_one_process(struct proc* procp) {
Colin Cross16b09462014-07-14 12:39:56 -07001268 int pid = procp->pid;
1269 uid_t uid = procp->uid;
1270 char *taskname;
1271 int tasksize;
1272 int r;
Suren Baghdasaryan01063272018-10-12 11:28:33 -07001273 int result = -1;
Colin Cross16b09462014-07-14 12:39:56 -07001274
Rajeev Kumar70450032018-01-31 17:54:56 -08001275#ifdef LMKD_LOG_STATS
Rajeev Kumar92b659b2018-02-21 19:08:15 -08001276 struct memory_stat mem_st = {};
Rajeev Kumar70450032018-01-31 17:54:56 -08001277 int memory_stat_parse_result = -1;
1278#endif
1279
Colin Cross16b09462014-07-14 12:39:56 -07001280 taskname = proc_get_name(pid);
1281 if (!taskname) {
Suren Baghdasaryan01063272018-10-12 11:28:33 -07001282 goto out;
Colin Cross16b09462014-07-14 12:39:56 -07001283 }
1284
1285 tasksize = proc_get_size(pid);
1286 if (tasksize <= 0) {
Suren Baghdasaryan01063272018-10-12 11:28:33 -07001287 goto out;
Colin Cross16b09462014-07-14 12:39:56 -07001288 }
1289
Rajeev Kumar70450032018-01-31 17:54:56 -08001290#ifdef LMKD_LOG_STATS
1291 if (enable_stats_log) {
Rajeev Kumar4dbc24d2018-10-05 12:34:59 -07001292 if (per_app_memcg) {
1293 memory_stat_parse_result = memory_stat_from_cgroup(&mem_st, pid, uid);
1294 } else {
1295 memory_stat_parse_result = memory_stat_from_procfs(&mem_st, pid);
1296 }
Rajeev Kumar70450032018-01-31 17:54:56 -08001297 }
1298#endif
1299
Suren Baghdasaryanc7135592018-01-04 10:43:58 -08001300 TRACE_KILL_START(pid);
1301
Mark Salyzyn64d97d82018-04-09 09:50:32 -07001302 /* CAP_KILL required */
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001303 r = kill(pid, SIGKILL);
Suren Baghdasaryand4a29902018-10-12 11:07:40 -07001304 inc_killcnt(procp->oomadj);
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001305 ALOGI("Kill '%s' (%d), uid %d, oom_adj %d to free %ldkB",
1306 taskname, pid, uid, procp->oomadj, tasksize * page_k);
Colin Cross16b09462014-07-14 12:39:56 -07001307
Suren Baghdasaryanc7135592018-01-04 10:43:58 -08001308 TRACE_KILL_END();
1309
Tim Murraye7853f62018-10-25 17:05:41 -07001310 last_killed_pid = pid;
1311
Colin Cross16b09462014-07-14 12:39:56 -07001312 if (r) {
Mark Salyzyn919f5382018-02-04 15:27:23 -08001313 ALOGE("kill(%d): errno=%d", pid, errno);
Suren Baghdasaryan01063272018-10-12 11:28:33 -07001314 goto out;
Rajeev Kumar70450032018-01-31 17:54:56 -08001315 } else {
1316#ifdef LMKD_LOG_STATS
1317 if (memory_stat_parse_result == 0) {
1318 stats_write_lmk_kill_occurred(log_ctx, LMK_KILL_OCCURRED, uid, taskname,
1319 procp->oomadj, mem_st.pgfault, mem_st.pgmajfault, mem_st.rss_in_bytes,
Jim Blackler1417cdb2018-11-21 16:22:36 +00001320 mem_st.cache_in_bytes, mem_st.swap_in_bytes, mem_st.process_start_time_ns);
Rajeev Kumar4dbc24d2018-10-05 12:34:59 -07001321 } else if (enable_stats_log) {
1322 stats_write_lmk_kill_occurred(log_ctx, LMK_KILL_OCCURRED, uid, taskname, procp->oomadj,
Jim Blackler1417cdb2018-11-21 16:22:36 +00001323 -1, -1, tasksize * BYTES_IN_KILOBYTE, -1, -1, -1);
Rajeev Kumar70450032018-01-31 17:54:56 -08001324 }
1325#endif
Suren Baghdasaryan01063272018-10-12 11:28:33 -07001326 result = tasksize;
Colin Cross16b09462014-07-14 12:39:56 -07001327 }
Mark Salyzyn919f5382018-02-04 15:27:23 -08001328
Suren Baghdasaryan01063272018-10-12 11:28:33 -07001329out:
1330 /*
1331 * WARNING: After pid_remove() procp is freed and can't be used!
1332 * Therefore placed at the end of the function.
1333 */
1334 pid_remove(pid);
1335 return result;
Colin Cross16b09462014-07-14 12:39:56 -07001336}
1337
1338/*
Suren Baghdasaryanf81b5f42018-10-26 11:32:15 -07001339 * Find one process to kill at or above the given oom_adj level.
1340 * Returns size of the killed process.
Colin Cross16b09462014-07-14 12:39:56 -07001341 */
Suren Baghdasaryanf81b5f42018-10-26 11:32:15 -07001342static int find_and_kill_process(int min_score_adj) {
Colin Cross16b09462014-07-14 12:39:56 -07001343 int i;
Suren Baghdasaryanf81b5f42018-10-26 11:32:15 -07001344 int killed_size = 0;
Colin Cross16b09462014-07-14 12:39:56 -07001345
Rajeev Kumar70450032018-01-31 17:54:56 -08001346#ifdef LMKD_LOG_STATS
Yang Lu5564f4e2018-05-15 04:59:44 +00001347 bool lmk_state_change_start = false;
Rajeev Kumar70450032018-01-31 17:54:56 -08001348#endif
1349
Chong Zhang0a4acdf2015-10-14 16:19:53 -07001350 for (i = OOM_SCORE_ADJ_MAX; i >= min_score_adj; i--) {
Colin Cross16b09462014-07-14 12:39:56 -07001351 struct proc *procp;
1352
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001353 while (true) {
Suren Baghdasaryan818b59b2018-04-13 11:49:54 -07001354 procp = kill_heaviest_task ?
1355 proc_get_heaviest(i) : proc_adj_lru(i);
Colin Cross16b09462014-07-14 12:39:56 -07001356
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001357 if (!procp)
1358 break;
1359
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001360 killed_size = kill_one_process(procp);
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001361 if (killed_size >= 0) {
Yang Lu5564f4e2018-05-15 04:59:44 +00001362#ifdef LMKD_LOG_STATS
1363 if (enable_stats_log && !lmk_state_change_start) {
1364 lmk_state_change_start = true;
1365 stats_write_lmk_state_changed(log_ctx, LMK_STATE_CHANGED,
1366 LMK_STATE_CHANGE_START);
1367 }
1368#endif
Suren Baghdasaryanf81b5f42018-10-26 11:32:15 -07001369 break;
Colin Cross16b09462014-07-14 12:39:56 -07001370 }
1371 }
Suren Baghdasaryanf81b5f42018-10-26 11:32:15 -07001372 if (killed_size) {
1373 break;
1374 }
Colin Cross16b09462014-07-14 12:39:56 -07001375 }
1376
Rajeev Kumar70450032018-01-31 17:54:56 -08001377#ifdef LMKD_LOG_STATS
Yang Lu5564f4e2018-05-15 04:59:44 +00001378 if (enable_stats_log && lmk_state_change_start) {
Rajeev Kumar70450032018-01-31 17:54:56 -08001379 stats_write_lmk_state_changed(log_ctx, LMK_STATE_CHANGED, LMK_STATE_CHANGE_STOP);
1380 }
1381#endif
1382
Suren Baghdasaryanf81b5f42018-10-26 11:32:15 -07001383 return killed_size;
Colin Cross16b09462014-07-14 12:39:56 -07001384}
1385
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -07001386static int64_t get_memory_usage(struct reread_data *file_data) {
Robert Beneac47f2992017-08-21 15:18:31 -07001387 int ret;
1388 int64_t mem_usage;
1389 char buf[32];
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -07001390
1391 if (reread_file(file_data, buf, sizeof(buf)) < 0) {
Robert Beneac47f2992017-08-21 15:18:31 -07001392 return -1;
1393 }
1394
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -07001395 if (!parse_int64(buf, &mem_usage)) {
1396 ALOGE("%s parse error", file_data->filename);
Robert Beneac47f2992017-08-21 15:18:31 -07001397 return -1;
1398 }
Robert Beneac47f2992017-08-21 15:18:31 -07001399 if (mem_usage == 0) {
1400 ALOGE("No memory!");
1401 return -1;
1402 }
1403 return mem_usage;
1404}
1405
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001406void record_low_pressure_levels(union meminfo *mi) {
1407 if (low_pressure_mem.min_nr_free_pages == -1 ||
1408 low_pressure_mem.min_nr_free_pages > mi->field.nr_free_pages) {
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001409 if (debug_process_killing) {
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001410 ALOGI("Low pressure min memory update from %" PRId64 " to %" PRId64,
1411 low_pressure_mem.min_nr_free_pages, mi->field.nr_free_pages);
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001412 }
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001413 low_pressure_mem.min_nr_free_pages = mi->field.nr_free_pages;
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001414 }
1415 /*
1416 * Free memory at low vmpressure events occasionally gets spikes,
1417 * possibly a stale low vmpressure event with memory already
1418 * freed up (no memory pressure should have been reported).
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001419 * Ignore large jumps in max_nr_free_pages that would mess up our stats.
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001420 */
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001421 if (low_pressure_mem.max_nr_free_pages == -1 ||
1422 (low_pressure_mem.max_nr_free_pages < mi->field.nr_free_pages &&
1423 mi->field.nr_free_pages - low_pressure_mem.max_nr_free_pages <
1424 low_pressure_mem.max_nr_free_pages * 0.1)) {
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001425 if (debug_process_killing) {
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001426 ALOGI("Low pressure max memory update from %" PRId64 " to %" PRId64,
1427 low_pressure_mem.max_nr_free_pages, mi->field.nr_free_pages);
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001428 }
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001429 low_pressure_mem.max_nr_free_pages = mi->field.nr_free_pages;
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001430 }
1431}
1432
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001433enum vmpressure_level upgrade_level(enum vmpressure_level level) {
1434 return (enum vmpressure_level)((level < VMPRESS_LEVEL_CRITICAL) ?
1435 level + 1 : level);
1436}
1437
1438enum vmpressure_level downgrade_level(enum vmpressure_level level) {
1439 return (enum vmpressure_level)((level > VMPRESS_LEVEL_LOW) ?
1440 level - 1 : level);
1441}
1442
Tim Murraye7853f62018-10-25 17:05:41 -07001443static bool is_kill_pending(void) {
1444 char buf[24];
1445
1446 if (last_killed_pid < 0) {
1447 return false;
1448 }
1449
1450 snprintf(buf, sizeof(buf), "/proc/%d/", last_killed_pid);
1451 if (access(buf, F_OK) == 0) {
1452 return true;
1453 }
1454
1455 // reset last killed PID because there's nothing pending
1456 last_killed_pid = -1;
1457 return false;
1458}
1459
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001460static void mp_event_common(int data, uint32_t events __unused) {
Todd Poynor3948f802013-07-09 19:35:14 -07001461 int ret;
1462 unsigned long long evcount;
Robert Beneac47f2992017-08-21 15:18:31 -07001463 int64_t mem_usage, memsw_usage;
Robert Benea6e8e7102017-09-13 15:20:30 -07001464 int64_t mem_pressure;
Suren Baghdasaryane82e15c2018-01-04 09:16:21 -08001465 enum vmpressure_level lvl;
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001466 union meminfo mi;
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001467 union zoneinfo zi;
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001468 struct timespec curr_tm;
Suren Baghdasaryan314a5052018-07-24 17:13:06 -07001469 static struct timespec last_kill_tm;
1470 static unsigned long kill_skip_count = 0;
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001471 enum vmpressure_level level = (enum vmpressure_level)data;
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001472 long other_free = 0, other_file = 0;
1473 int min_score_adj;
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001474 int minfree = 0;
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -07001475 static struct reread_data mem_usage_file_data = {
1476 .filename = MEMCG_MEMORY_USAGE,
1477 .fd = -1,
1478 };
1479 static struct reread_data memsw_usage_file_data = {
1480 .filename = MEMCG_MEMORYSW_USAGE,
1481 .fd = -1,
1482 };
Todd Poynor3948f802013-07-09 19:35:14 -07001483
Suren Baghdasaryane82e15c2018-01-04 09:16:21 -08001484 /*
1485 * Check all event counters from low to critical
1486 * and upgrade to the highest priority one. By reading
1487 * eventfd we also reset the event counters.
1488 */
1489 for (lvl = VMPRESS_LEVEL_LOW; lvl < VMPRESS_LEVEL_COUNT; lvl++) {
1490 if (mpevfd[lvl] != -1 &&
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -07001491 TEMP_FAILURE_RETRY(read(mpevfd[lvl],
1492 &evcount, sizeof(evcount))) > 0 &&
Suren Baghdasaryane82e15c2018-01-04 09:16:21 -08001493 evcount > 0 && lvl > level) {
1494 level = lvl;
1495 }
1496 }
Todd Poynor3948f802013-07-09 19:35:14 -07001497
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001498 if (clock_gettime(CLOCK_MONOTONIC_COARSE, &curr_tm) != 0) {
1499 ALOGE("Failed to get current time");
1500 return;
1501 }
1502
Suren Baghdasaryancaa2dc52018-01-17 17:28:01 -08001503 if (kill_timeout_ms) {
Tim Murraye7853f62018-10-25 17:05:41 -07001504 // If we're within the timeout, see if there's pending reclaim work
1505 // from the last killed process. If there is (as evidenced by
1506 // /proc/<pid> continuing to exist), skip killing for now.
1507 if ((get_time_diff_ms(&last_kill_tm, &curr_tm) < kill_timeout_ms) &&
1508 (low_ram_device || is_kill_pending())) {
Suren Baghdasaryan314a5052018-07-24 17:13:06 -07001509 kill_skip_count++;
Suren Baghdasaryancaa2dc52018-01-17 17:28:01 -08001510 return;
1511 }
1512 }
1513
Suren Baghdasaryan314a5052018-07-24 17:13:06 -07001514 if (kill_skip_count > 0) {
Suren Baghdasaryanda88b242018-05-10 16:10:56 -07001515 ALOGI("%lu memory pressure events were skipped after a kill!",
Suren Baghdasaryan314a5052018-07-24 17:13:06 -07001516 kill_skip_count);
1517 kill_skip_count = 0;
Suren Baghdasaryancaa2dc52018-01-17 17:28:01 -08001518 }
1519
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001520 if (meminfo_parse(&mi) < 0 || zoneinfo_parse(&zi) < 0) {
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001521 ALOGE("Failed to get free memory!");
1522 return;
1523 }
1524
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001525 if (use_minfree_levels) {
1526 int i;
1527
1528 other_free = mi.field.nr_free_pages - zi.field.totalreserve_pages;
1529 if (mi.field.nr_file_pages > (mi.field.shmem + mi.field.unevictable + mi.field.swap_cached)) {
1530 other_file = (mi.field.nr_file_pages - mi.field.shmem -
1531 mi.field.unevictable - mi.field.swap_cached);
1532 } else {
1533 other_file = 0;
1534 }
1535
1536 min_score_adj = OOM_SCORE_ADJ_MAX + 1;
1537 for (i = 0; i < lowmem_targets_size; i++) {
1538 minfree = lowmem_minfree[i];
1539 if (other_free < minfree && other_file < minfree) {
1540 min_score_adj = lowmem_adj[i];
1541 break;
1542 }
1543 }
1544
Suren Baghdasaryan20686f02018-05-18 14:42:00 -07001545 if (min_score_adj == OOM_SCORE_ADJ_MAX + 1) {
1546 if (debug_process_killing) {
1547 ALOGI("Ignore %s memory pressure event "
1548 "(free memory=%ldkB, cache=%ldkB, limit=%ldkB)",
1549 level_name[level], other_free * page_k, other_file * page_k,
1550 (long)lowmem_minfree[lowmem_targets_size - 1] * page_k);
1551 }
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001552 return;
Suren Baghdasaryan20686f02018-05-18 14:42:00 -07001553 }
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001554
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001555 goto do_kill;
1556 }
1557
Suren Baghdasaryan9926e572018-04-13 13:41:12 -07001558 if (level == VMPRESS_LEVEL_LOW) {
1559 record_low_pressure_levels(&mi);
1560 }
1561
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001562 if (level_oomadj[level] > OOM_SCORE_ADJ_MAX) {
1563 /* Do not monitor this pressure level */
1564 return;
1565 }
1566
Suren Baghdasaryan6499e5e2018-04-13 12:43:41 -07001567 if ((mem_usage = get_memory_usage(&mem_usage_file_data)) < 0) {
1568 goto do_kill;
1569 }
1570 if ((memsw_usage = get_memory_usage(&memsw_usage_file_data)) < 0) {
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001571 goto do_kill;
Robert Benea6e8e7102017-09-13 15:20:30 -07001572 }
Robert Beneac47f2992017-08-21 15:18:31 -07001573
Robert Benea6e8e7102017-09-13 15:20:30 -07001574 // Calculate percent for swappinness.
1575 mem_pressure = (mem_usage * 100) / memsw_usage;
1576
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001577 if (enable_pressure_upgrade && level != VMPRESS_LEVEL_CRITICAL) {
Robert Benea6e8e7102017-09-13 15:20:30 -07001578 // We are swapping too much.
1579 if (mem_pressure < upgrade_pressure) {
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001580 level = upgrade_level(level);
1581 if (debug_process_killing) {
1582 ALOGI("Event upgraded to %s", level_name[level]);
1583 }
Robert Beneac47f2992017-08-21 15:18:31 -07001584 }
1585 }
1586
Vic Yang360a1132018-08-07 10:18:22 -07001587 // If we still have enough swap space available, check if we want to
1588 // ignore/downgrade pressure events.
1589 if (mi.field.free_swap >=
1590 mi.field.total_swap * swap_free_low_percentage / 100) {
1591 // If the pressure is larger than downgrade_pressure lmk will not
1592 // kill any process, since enough memory is available.
1593 if (mem_pressure > downgrade_pressure) {
1594 if (debug_process_killing) {
1595 ALOGI("Ignore %s memory pressure", level_name[level]);
1596 }
1597 return;
1598 } else if (level == VMPRESS_LEVEL_CRITICAL && mem_pressure > upgrade_pressure) {
1599 if (debug_process_killing) {
1600 ALOGI("Downgrade critical memory pressure");
1601 }
1602 // Downgrade event, since enough memory available.
1603 level = downgrade_level(level);
Robert Benea6e8e7102017-09-13 15:20:30 -07001604 }
Robert Benea6e8e7102017-09-13 15:20:30 -07001605 }
1606
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001607do_kill:
Suren Baghdasaryanff61afb2018-04-13 11:45:38 -07001608 if (low_ram_device) {
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001609 /* For Go devices kill only one task */
Suren Baghdasaryanf81b5f42018-10-26 11:32:15 -07001610 if (find_and_kill_process(level_oomadj[level]) == 0) {
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001611 if (debug_process_killing) {
1612 ALOGI("Nothing to kill");
1613 }
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -07001614 } else {
1615 meminfo_log(&mi);
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001616 }
1617 } else {
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001618 int pages_freed;
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001619 static struct timespec last_report_tm;
1620 static unsigned long report_skip_count = 0;
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001621
1622 if (!use_minfree_levels) {
1623 /* If pressure level is less than critical and enough free swap then ignore */
1624 if (level < VMPRESS_LEVEL_CRITICAL &&
1625 mi.field.free_swap > low_pressure_mem.max_nr_free_pages) {
1626 if (debug_process_killing) {
1627 ALOGI("Ignoring pressure since %" PRId64
1628 " swap pages are available ",
1629 mi.field.free_swap);
1630 }
1631 return;
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001632 }
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001633 /* Free up enough memory to downgrate the memory pressure to low level */
Suren Baghdasaryanf81b5f42018-10-26 11:32:15 -07001634 if (mi.field.nr_free_pages >= low_pressure_mem.max_nr_free_pages) {
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001635 if (debug_process_killing) {
1636 ALOGI("Ignoring pressure since more memory is "
1637 "available (%" PRId64 ") than watermark (%" PRId64 ")",
1638 mi.field.nr_free_pages, low_pressure_mem.max_nr_free_pages);
1639 }
1640 return;
1641 }
1642 min_score_adj = level_oomadj[level];
Suren Baghdasaryan65f54a22018-01-17 17:17:44 -08001643 }
1644
Suren Baghdasaryanf81b5f42018-10-26 11:32:15 -07001645 pages_freed = find_and_kill_process(min_score_adj);
Suren Baghdasaryanda88b242018-05-10 16:10:56 -07001646
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001647 if (pages_freed == 0) {
1648 /* Rate limit kill reports when nothing was reclaimed */
1649 if (get_time_diff_ms(&last_report_tm, &curr_tm) < FAIL_REPORT_RLIMIT_MS) {
1650 report_skip_count++;
Suren Baghdasaryan314a5052018-07-24 17:13:06 -07001651 return;
1652 }
Tim Murraye7853f62018-10-25 17:05:41 -07001653 } else {
1654 /* If we killed anything, update the last killed timestamp. */
1655 last_kill_tm = curr_tm;
Robert Beneacaeaa652017-08-11 16:03:20 -07001656 }
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001657
1658 /* Log meminfo whenever we kill or when report rate limit allows */
1659 meminfo_log(&mi);
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001660
1661 if (use_minfree_levels) {
Suren Baghdasaryanf81b5f42018-10-26 11:32:15 -07001662 ALOGI("Reclaimed %ldkB, cache(%ldkB) and "
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001663 "free(%" PRId64 "kB)-reserved(%" PRId64 "kB) below min(%ldkB) for oom_adj %d",
Suren Baghdasaryanf81b5f42018-10-26 11:32:15 -07001664 pages_freed * page_k,
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001665 other_file * page_k, mi.field.nr_free_pages * page_k,
1666 zi.field.totalreserve_pages * page_k,
1667 minfree * page_k, min_score_adj);
1668 } else {
Suren Baghdasaryanf81b5f42018-10-26 11:32:15 -07001669 ALOGI("Reclaimed %ldkB at oom_adj %d",
1670 pages_freed * page_k, min_score_adj);
Suren Baghdasaryan36934412018-09-05 15:46:32 -07001671 }
1672
1673 if (report_skip_count > 0) {
1674 ALOGI("Suppressed %lu failed kill reports", report_skip_count);
1675 report_skip_count = 0;
1676 }
1677
1678 last_report_tm = curr_tm;
Colin Crossf8857cc2014-07-11 17:16:56 -07001679 }
Todd Poynor3948f802013-07-09 19:35:14 -07001680}
1681
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001682static bool init_mp_common(enum vmpressure_level level) {
Todd Poynor3948f802013-07-09 19:35:14 -07001683 int mpfd;
1684 int evfd;
1685 int evctlfd;
1686 char buf[256];
1687 struct epoll_event epev;
1688 int ret;
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001689 int level_idx = (int)level;
1690 const char *levelstr = level_name[level_idx];
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001691
Mark Salyzyn64d97d82018-04-09 09:50:32 -07001692 /* gid containing AID_SYSTEM required */
Nick Kralevichc68c8862015-12-18 20:52:37 -08001693 mpfd = open(MEMCG_SYSFS_PATH "memory.pressure_level", O_RDONLY | O_CLOEXEC);
Todd Poynor3948f802013-07-09 19:35:14 -07001694 if (mpfd < 0) {
1695 ALOGI("No kernel memory.pressure_level support (errno=%d)", errno);
1696 goto err_open_mpfd;
1697 }
1698
Nick Kralevichc68c8862015-12-18 20:52:37 -08001699 evctlfd = open(MEMCG_SYSFS_PATH "cgroup.event_control", O_WRONLY | O_CLOEXEC);
Todd Poynor3948f802013-07-09 19:35:14 -07001700 if (evctlfd < 0) {
1701 ALOGI("No kernel memory cgroup event control (errno=%d)", errno);
1702 goto err_open_evctlfd;
1703 }
1704
Nick Kralevichc68c8862015-12-18 20:52:37 -08001705 evfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
Todd Poynor3948f802013-07-09 19:35:14 -07001706 if (evfd < 0) {
1707 ALOGE("eventfd failed for level %s; errno=%d", levelstr, errno);
1708 goto err_eventfd;
1709 }
1710
1711 ret = snprintf(buf, sizeof(buf), "%d %d %s", evfd, mpfd, levelstr);
1712 if (ret >= (ssize_t)sizeof(buf)) {
1713 ALOGE("cgroup.event_control line overflow for level %s", levelstr);
1714 goto err;
1715 }
1716
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001717 ret = TEMP_FAILURE_RETRY(write(evctlfd, buf, strlen(buf) + 1));
Todd Poynor3948f802013-07-09 19:35:14 -07001718 if (ret == -1) {
1719 ALOGE("cgroup.event_control write failed for level %s; errno=%d",
1720 levelstr, errno);
1721 goto err;
1722 }
1723
1724 epev.events = EPOLLIN;
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001725 /* use data to store event level */
1726 vmpressure_hinfo[level_idx].data = level_idx;
1727 vmpressure_hinfo[level_idx].handler = mp_event_common;
1728 epev.data.ptr = (void *)&vmpressure_hinfo[level_idx];
Todd Poynor3948f802013-07-09 19:35:14 -07001729 ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, evfd, &epev);
1730 if (ret == -1) {
1731 ALOGE("epoll_ctl for level %s failed; errno=%d", levelstr, errno);
1732 goto err;
1733 }
1734 maxevents++;
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001735 mpevfd[level] = evfd;
Suren Baghdasaryan1bd2fc42018-01-04 08:54:53 -08001736 close(evctlfd);
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001737 return true;
Todd Poynor3948f802013-07-09 19:35:14 -07001738
1739err:
1740 close(evfd);
1741err_eventfd:
1742 close(evctlfd);
1743err_open_evctlfd:
1744 close(mpfd);
1745err_open_mpfd:
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001746 return false;
Robert Benea673e2762017-06-01 16:32:31 -07001747}
1748
Todd Poynor3948f802013-07-09 19:35:14 -07001749static int init(void) {
1750 struct epoll_event epev;
1751 int i;
1752 int ret;
1753
1754 page_k = sysconf(_SC_PAGESIZE);
1755 if (page_k == -1)
1756 page_k = PAGE_SIZE;
1757 page_k /= 1024;
1758
1759 epollfd = epoll_create(MAX_EPOLL_EVENTS);
1760 if (epollfd == -1) {
1761 ALOGE("epoll_create failed (errno=%d)", errno);
1762 return -1;
1763 }
1764
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001765 // mark data connections as not connected
1766 for (int i = 0; i < MAX_DATA_CONN; i++) {
1767 data_sock[i].sock = -1;
1768 }
1769
1770 ctrl_sock.sock = android_get_control_socket("lmkd");
1771 if (ctrl_sock.sock < 0) {
Todd Poynor3948f802013-07-09 19:35:14 -07001772 ALOGE("get lmkd control socket failed");
1773 return -1;
1774 }
1775
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001776 ret = listen(ctrl_sock.sock, MAX_DATA_CONN);
Todd Poynor3948f802013-07-09 19:35:14 -07001777 if (ret < 0) {
1778 ALOGE("lmkd control socket listen failed (errno=%d)", errno);
1779 return -1;
1780 }
1781
1782 epev.events = EPOLLIN;
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001783 ctrl_sock.handler_info.handler = ctrl_connect_handler;
1784 epev.data.ptr = (void *)&(ctrl_sock.handler_info);
1785 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_sock.sock, &epev) == -1) {
Todd Poynor3948f802013-07-09 19:35:14 -07001786 ALOGE("epoll_ctl for lmkd control socket failed (errno=%d)", errno);
1787 return -1;
1788 }
1789 maxevents++;
1790
Robert Benea164baeb2017-09-11 16:53:28 -07001791 has_inkernel_module = !access(INKERNEL_MINFREE_PATH, W_OK);
Suren Baghdasaryan979591b2018-01-18 17:27:30 -08001792 use_inkernel_interface = has_inkernel_module;
Todd Poynor3948f802013-07-09 19:35:14 -07001793
1794 if (use_inkernel_interface) {
1795 ALOGI("Using in-kernel low memory killer interface");
1796 } else {
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001797 if (!init_mp_common(VMPRESS_LEVEL_LOW) ||
1798 !init_mp_common(VMPRESS_LEVEL_MEDIUM) ||
1799 !init_mp_common(VMPRESS_LEVEL_CRITICAL)) {
Todd Poynor3948f802013-07-09 19:35:14 -07001800 ALOGE("Kernel does not support memory pressure events or in-kernel low memory killer");
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001801 return -1;
1802 }
Todd Poynor3948f802013-07-09 19:35:14 -07001803 }
1804
Chong Zhang0a4acdf2015-10-14 16:19:53 -07001805 for (i = 0; i <= ADJTOSLOT(OOM_SCORE_ADJ_MAX); i++) {
Todd Poynor3948f802013-07-09 19:35:14 -07001806 procadjslot_list[i].next = &procadjslot_list[i];
1807 procadjslot_list[i].prev = &procadjslot_list[i];
1808 }
1809
Suren Baghdasaryand4a29902018-10-12 11:07:40 -07001810 memset(killcnt_idx, KILLCNT_INVALID_IDX, sizeof(killcnt_idx));
1811
Todd Poynor3948f802013-07-09 19:35:14 -07001812 return 0;
1813}
1814
1815static void mainloop(void) {
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001816 struct event_handler_info* handler_info;
1817 struct epoll_event *evt;
1818
Todd Poynor3948f802013-07-09 19:35:14 -07001819 while (1) {
1820 struct epoll_event events[maxevents];
1821 int nevents;
1822 int i;
1823
Todd Poynor3948f802013-07-09 19:35:14 -07001824 nevents = epoll_wait(epollfd, events, maxevents, -1);
1825
1826 if (nevents == -1) {
1827 if (errno == EINTR)
1828 continue;
1829 ALOGE("epoll_wait failed (errno=%d)", errno);
1830 continue;
1831 }
1832
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001833 /*
1834 * First pass to see if any data socket connections were dropped.
1835 * Dropped connection should be handled before any other events
1836 * to deallocate data connection and correctly handle cases when
1837 * connection gets dropped and reestablished in the same epoll cycle.
1838 * In such cases it's essential to handle connection closures first.
1839 */
1840 for (i = 0, evt = &events[0]; i < nevents; ++i, evt++) {
1841 if ((evt->events & EPOLLHUP) && evt->data.ptr) {
1842 ALOGI("lmkd data connection dropped");
1843 handler_info = (struct event_handler_info*)evt->data.ptr;
1844 ctrl_data_close(handler_info->data);
1845 }
1846 }
1847
1848 /* Second pass to handle all other events */
1849 for (i = 0, evt = &events[0]; i < nevents; ++i, evt++) {
1850 if (evt->events & EPOLLERR)
Todd Poynor3948f802013-07-09 19:35:14 -07001851 ALOGD("EPOLLERR on event #%d", i);
Suren Baghdasaryan3cfb2c82018-01-26 12:51:19 -08001852 if (evt->events & EPOLLHUP) {
1853 /* This case was handled in the first pass */
1854 continue;
1855 }
1856 if (evt->data.ptr) {
1857 handler_info = (struct event_handler_info*)evt->data.ptr;
1858 handler_info->handler(handler_info->data, evt->events);
1859 }
Todd Poynor3948f802013-07-09 19:35:14 -07001860 }
1861 }
1862}
1863
Mark Salyzyne6ed68b2014-04-30 13:36:35 -07001864int main(int argc __unused, char **argv __unused) {
Colin Cross1a0d9be2014-07-14 14:31:15 -07001865 struct sched_param param = {
1866 .sched_priority = 1,
1867 };
1868
Suren Baghdasaryan96bf3a62017-12-08 12:58:52 -08001869 /* By default disable low level vmpressure events */
1870 level_oomadj[VMPRESS_LEVEL_LOW] =
1871 property_get_int32("ro.lmk.low", OOM_SCORE_ADJ_MAX + 1);
1872 level_oomadj[VMPRESS_LEVEL_MEDIUM] =
1873 property_get_int32("ro.lmk.medium", 800);
1874 level_oomadj[VMPRESS_LEVEL_CRITICAL] =
1875 property_get_int32("ro.lmk.critical", 0);
Robert Beneacaeaa652017-08-11 16:03:20 -07001876 debug_process_killing = property_get_bool("ro.lmk.debug", false);
Suren Baghdasaryanad2fd912017-12-08 13:08:41 -08001877
1878 /* By default disable upgrade/downgrade logic */
1879 enable_pressure_upgrade =
1880 property_get_bool("ro.lmk.critical_upgrade", false);
1881 upgrade_pressure =
1882 (int64_t)property_get_int32("ro.lmk.upgrade_pressure", 100);
1883 downgrade_pressure =
1884 (int64_t)property_get_int32("ro.lmk.downgrade_pressure", 100);
Suren Baghdasaryan662492a2017-12-08 13:17:06 -08001885 kill_heaviest_task =
Suren Baghdasaryan818b59b2018-04-13 11:49:54 -07001886 property_get_bool("ro.lmk.kill_heaviest_task", false);
Suren Baghdasaryanff61afb2018-04-13 11:45:38 -07001887 low_ram_device = property_get_bool("ro.config.low_ram", false);
Suren Baghdasaryancaa2dc52018-01-17 17:28:01 -08001888 kill_timeout_ms =
1889 (unsigned long)property_get_int32("ro.lmk.kill_timeout_ms", 0);
Suren Baghdasaryanffdc4dd2018-04-13 13:53:43 -07001890 use_minfree_levels =
1891 property_get_bool("ro.lmk.use_minfree_levels", false);
Suren Baghdasaryance13cb52018-06-19 18:38:12 -07001892 per_app_memcg =
1893 property_get_bool("ro.config.per_app_memcg", low_ram_device);
Vic Yang360a1132018-08-07 10:18:22 -07001894 swap_free_low_percentage =
1895 property_get_int32("ro.lmk.swap_free_low_percentage", 10);
Robert Benea58891d52017-07-31 17:15:20 -07001896
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -07001897 ctx = create_android_logger(MEMINFO_LOG_TAG);
1898
Rajeev Kumar70450032018-01-31 17:54:56 -08001899#ifdef LMKD_LOG_STATS
Rajeev Kumar1c669f72018-03-09 15:20:56 -08001900 statslog_init(&log_ctx, &enable_stats_log);
Rajeev Kumar70450032018-01-31 17:54:56 -08001901#endif
1902
Mark Salyzyn721d7c72018-03-21 12:24:58 -07001903 if (!init()) {
1904 if (!use_inkernel_interface) {
1905 /*
1906 * MCL_ONFAULT pins pages as they fault instead of loading
1907 * everything immediately all at once. (Which would be bad,
1908 * because as of this writing, we have a lot of mapped pages we
1909 * never use.) Old kernels will see MCL_ONFAULT and fail with
1910 * EINVAL; we ignore this failure.
1911 *
1912 * N.B. read the man page for mlockall. MCL_CURRENT | MCL_ONFAULT
1913 * pins ⊆ MCL_CURRENT, converging to just MCL_CURRENT as we fault
1914 * in pages.
1915 */
Mark Salyzyn64d97d82018-04-09 09:50:32 -07001916 /* CAP_IPC_LOCK required */
Mark Salyzyn721d7c72018-03-21 12:24:58 -07001917 if (mlockall(MCL_CURRENT | MCL_FUTURE | MCL_ONFAULT) && (errno != EINVAL)) {
1918 ALOGW("mlockall failed %s", strerror(errno));
1919 }
Daniel Colascione4dd5d002018-01-03 12:01:02 -08001920
Mark Salyzyn64d97d82018-04-09 09:50:32 -07001921 /* CAP_NICE required */
1922 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
1923 ALOGW("set SCHED_FIFO failed %s", strerror(errno));
1924 }
Mark Salyzyn721d7c72018-03-21 12:24:58 -07001925 }
1926
Todd Poynor3948f802013-07-09 19:35:14 -07001927 mainloop();
Mark Salyzyn721d7c72018-03-21 12:24:58 -07001928 }
Todd Poynor3948f802013-07-09 19:35:14 -07001929
Rajeev Kumar70450032018-01-31 17:54:56 -08001930#ifdef LMKD_LOG_STATS
Rajeev Kumar1c669f72018-03-09 15:20:56 -08001931 statslog_destroy(&log_ctx);
Rajeev Kumar70450032018-01-31 17:54:56 -08001932#endif
1933
Suren Baghdasaryan282ad1a2018-07-26 16:34:27 -07001934 android_log_destroy(&ctx);
1935
Todd Poynor3948f802013-07-09 19:35:14 -07001936 ALOGI("exiting");
1937 return 0;
1938}