1 /*
2 * Copyright (C) 2007 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 "android.os.Debug"
18 #include "JNIHelp.h"
19 #include "jni.h"
20 #include <utils/String8.h>
21 #include "utils/misc.h"
22 #include "cutils/debugger.h"
23 #include <memtrack/memtrack.h>
24 #include <memunreachable/memunreachable.h>
25
26 #include <cutils/log.h>
27 #include <fcntl.h>
28 #include <inttypes.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33 #include <time.h>
34 #include <sys/time.h>
35 #include <errno.h>
36 #include <assert.h>
37 #include <ctype.h>
38 #include <malloc.h>
39
40 #include <iomanip>
41 #include <string>
42
43 namespace android
44 {
45
46 enum {
47 HEAP_UNKNOWN,
48 HEAP_DALVIK,
49 HEAP_NATIVE,
50
51 HEAP_DALVIK_OTHER,
52 HEAP_STACK,
53 HEAP_CURSOR,
54 HEAP_ASHMEM,
55 HEAP_GL_DEV,
56 HEAP_UNKNOWN_DEV,
57 HEAP_SO,
58 HEAP_JAR,
59 HEAP_APK,
60 HEAP_TTF,
61 HEAP_DEX,
62 HEAP_OAT,
63 HEAP_ART,
64 HEAP_UNKNOWN_MAP,
65 HEAP_GRAPHICS,
66 HEAP_GL,
67 HEAP_OTHER_MEMTRACK,
68
69 HEAP_DALVIK_NORMAL,
70 HEAP_DALVIK_LARGE,
71 HEAP_DALVIK_LINEARALLOC,
72 HEAP_DALVIK_ACCOUNTING,
73 HEAP_DALVIK_CODE_CACHE,
74 HEAP_DALVIK_ZYGOTE,
75 HEAP_DALVIK_NON_MOVING,
76 HEAP_DALVIK_INDIRECT_REFERENCE_TABLE,
77
78 _NUM_HEAP,
79 _NUM_EXCLUSIVE_HEAP = HEAP_OTHER_MEMTRACK+1,
80 _NUM_CORE_HEAP = HEAP_NATIVE+1
81 };
82
83 struct stat_fields {
84 jfieldID pss_field;
85 jfieldID pssSwappable_field;
86 jfieldID privateDirty_field;
87 jfieldID sharedDirty_field;
88 jfieldID privateClean_field;
89 jfieldID sharedClean_field;
90 jfieldID swappedOut_field;
91 jfieldID swappedOutPss_field;
92 };
93
94 struct stat_field_names {
95 const char* pss_name;
96 const char* pssSwappable_name;
97 const char* privateDirty_name;
98 const char* sharedDirty_name;
99 const char* privateClean_name;
100 const char* sharedClean_name;
101 const char* swappedOut_name;
102 const char* swappedOutPss_name;
103 };
104
105 static stat_fields stat_fields[_NUM_CORE_HEAP];
106
107 static stat_field_names stat_field_names[_NUM_CORE_HEAP] = {
108 { "otherPss", "otherSwappablePss", "otherPrivateDirty", "otherSharedDirty",
109 "otherPrivateClean", "otherSharedClean", "otherSwappedOut", "otherSwappedOutPss" },
110 { "dalvikPss", "dalvikSwappablePss", "dalvikPrivateDirty", "dalvikSharedDirty",
111 "dalvikPrivateClean", "dalvikSharedClean", "dalvikSwappedOut", "dalvikSwappedOutPss" },
112 { "nativePss", "nativeSwappablePss", "nativePrivateDirty", "nativeSharedDirty",
113 "nativePrivateClean", "nativeSharedClean", "nativeSwappedOut", "nativeSwappedOutPss" }
114 };
115
116 jfieldID otherStats_field;
117 jfieldID hasSwappedOutPss_field;
118
119 static bool memtrackLoaded;
120
121 struct stats_t {
122 int pss;
123 int swappablePss;
124 int privateDirty;
125 int sharedDirty;
126 int privateClean;
127 int sharedClean;
128 int swappedOut;
129 int swappedOutPss;
130 };
131
132 #define BINDER_STATS "/proc/binder/stats"
133
android_os_Debug_getNativeHeapSize(JNIEnv * env,jobject clazz)134 static jlong android_os_Debug_getNativeHeapSize(JNIEnv *env, jobject clazz)
135 {
136 struct mallinfo info = mallinfo();
137 return (jlong) info.usmblks;
138 }
139
android_os_Debug_getNativeHeapAllocatedSize(JNIEnv * env,jobject clazz)140 static jlong android_os_Debug_getNativeHeapAllocatedSize(JNIEnv *env, jobject clazz)
141 {
142 struct mallinfo info = mallinfo();
143 return (jlong) info.uordblks;
144 }
145
android_os_Debug_getNativeHeapFreeSize(JNIEnv * env,jobject clazz)146 static jlong android_os_Debug_getNativeHeapFreeSize(JNIEnv *env, jobject clazz)
147 {
148 struct mallinfo info = mallinfo();
149 return (jlong) info.fordblks;
150 }
151
152 // Container used to retrieve graphics memory pss
153 struct graphics_memory_pss
154 {
155 int graphics;
156 int gl;
157 int other;
158 };
159
160 /*
161 * Uses libmemtrack to retrieve graphics memory that the process is using.
162 * Any graphics memory reported in /proc/pid/smaps is not included here.
163 */
read_memtrack_memory(struct memtrack_proc * p,int pid,struct graphics_memory_pss * graphics_mem)164 static int read_memtrack_memory(struct memtrack_proc* p, int pid,
165 struct graphics_memory_pss* graphics_mem)
166 {
167 int err = memtrack_proc_get(p, pid);
168 if (err != 0) {
169 ALOGW("failed to get memory consumption info: %d", err);
170 return err;
171 }
172
173 ssize_t pss = memtrack_proc_graphics_pss(p);
174 if (pss < 0) {
175 ALOGW("failed to get graphics pss: %zd", pss);
176 return pss;
177 }
178 graphics_mem->graphics = pss / 1024;
179
180 pss = memtrack_proc_gl_pss(p);
181 if (pss < 0) {
182 ALOGW("failed to get gl pss: %zd", pss);
183 return pss;
184 }
185 graphics_mem->gl = pss / 1024;
186
187 pss = memtrack_proc_other_pss(p);
188 if (pss < 0) {
189 ALOGW("failed to get other pss: %zd", pss);
190 return pss;
191 }
192 graphics_mem->other = pss / 1024;
193
194 return 0;
195 }
196
197 /*
198 * Retrieves the graphics memory that is unaccounted for in /proc/pid/smaps.
199 */
read_memtrack_memory(int pid,struct graphics_memory_pss * graphics_mem)200 static int read_memtrack_memory(int pid, struct graphics_memory_pss* graphics_mem)
201 {
202 if (!memtrackLoaded) {
203 return -1;
204 }
205
206 struct memtrack_proc* p = memtrack_proc_new();
207 if (p == NULL) {
208 ALOGW("failed to create memtrack_proc");
209 return -1;
210 }
211
212 int err = read_memtrack_memory(p, pid, graphics_mem);
213 memtrack_proc_destroy(p);
214 return err;
215 }
216
read_mapinfo(FILE * fp,stats_t * stats,bool * foundSwapPss)217 static void read_mapinfo(FILE *fp, stats_t* stats, bool* foundSwapPss)
218 {
219 char line[1024];
220 int len, nameLen;
221 bool skip, done = false;
222
223 unsigned pss = 0, swappable_pss = 0;
224 float sharing_proportion = 0.0;
225 unsigned shared_clean = 0, shared_dirty = 0;
226 unsigned private_clean = 0, private_dirty = 0;
227 unsigned swapped_out = 0, swapped_out_pss = 0;
228 bool is_swappable = false;
229 unsigned temp;
230
231 uint64_t start;
232 uint64_t end = 0;
233 uint64_t prevEnd = 0;
234 char* name;
235 int name_pos;
236
237 int whichHeap = HEAP_UNKNOWN;
238 int subHeap = HEAP_UNKNOWN;
239 int prevHeap = HEAP_UNKNOWN;
240
241 *foundSwapPss = false;
242
243 if(fgets(line, sizeof(line), fp) == 0) return;
244
245 while (!done) {
246 prevHeap = whichHeap;
247 prevEnd = end;
248 whichHeap = HEAP_UNKNOWN;
249 subHeap = HEAP_UNKNOWN;
250 skip = false;
251 is_swappable = false;
252
253 len = strlen(line);
254 if (len < 1) return;
255 line[--len] = 0;
256
257 if (sscanf(line, "%" SCNx64 "-%" SCNx64 " %*s %*x %*x:%*x %*d%n", &start, &end, &name_pos) != 2) {
258 skip = true;
259 } else {
260 while (isspace(line[name_pos])) {
261 name_pos += 1;
262 }
263 name = line + name_pos;
264 nameLen = strlen(name);
265 // Trim the end of the line if it is " (deleted)".
266 const char* deleted_str = " (deleted)";
267 if (nameLen > (int)strlen(deleted_str) &&
268 strcmp(name+nameLen-strlen(deleted_str), deleted_str) == 0) {
269 nameLen -= strlen(deleted_str);
270 name[nameLen] = '\0';
271 }
272 if ((strstr(name, "[heap]") == name)) {
273 whichHeap = HEAP_NATIVE;
274 } else if (strncmp(name, "[anon:libc_malloc]", 18) == 0) {
275 whichHeap = HEAP_NATIVE;
276 } else if (strncmp(name, "[stack", 6) == 0) {
277 whichHeap = HEAP_STACK;
278 } else if (nameLen > 3 && strcmp(name+nameLen-3, ".so") == 0) {
279 whichHeap = HEAP_SO;
280 is_swappable = true;
281 } else if (nameLen > 4 && strcmp(name+nameLen-4, ".jar") == 0) {
282 whichHeap = HEAP_JAR;
283 is_swappable = true;
284 } else if (nameLen > 4 && strcmp(name+nameLen-4, ".apk") == 0) {
285 whichHeap = HEAP_APK;
286 is_swappable = true;
287 } else if (nameLen > 4 && strcmp(name+nameLen-4, ".ttf") == 0) {
288 whichHeap = HEAP_TTF;
289 is_swappable = true;
290 } else if ((nameLen > 4 && strstr(name, ".dex") != NULL) ||
291 (nameLen > 5 && strcmp(name+nameLen-5, ".odex") == 0)) {
292 whichHeap = HEAP_DEX;
293 is_swappable = true;
294 } else if (nameLen > 4 && strcmp(name+nameLen-4, ".oat") == 0) {
295 whichHeap = HEAP_OAT;
296 is_swappable = true;
297 } else if (nameLen > 4 && strcmp(name+nameLen-4, ".art") == 0) {
298 whichHeap = HEAP_ART;
299 is_swappable = true;
300 } else if (strncmp(name, "/dev/", 5) == 0) {
301 if (strncmp(name, "/dev/kgsl-3d0", 13) == 0) {
302 whichHeap = HEAP_GL_DEV;
303 } else if (strncmp(name, "/dev/ashmem", 11) == 0) {
304 if (strncmp(name, "/dev/ashmem/dalvik-", 19) == 0) {
305 whichHeap = HEAP_DALVIK_OTHER;
306 if (strstr(name, "/dev/ashmem/dalvik-LinearAlloc") == name) {
307 subHeap = HEAP_DALVIK_LINEARALLOC;
308 } else if ((strstr(name, "/dev/ashmem/dalvik-alloc space") == name) ||
309 (strstr(name, "/dev/ashmem/dalvik-main space") == name)) {
310 // This is the regular Dalvik heap.
311 whichHeap = HEAP_DALVIK;
312 subHeap = HEAP_DALVIK_NORMAL;
313 } else if (strstr(name, "/dev/ashmem/dalvik-large object space") == name ||
314 strstr(name, "/dev/ashmem/dalvik-free list large object space")
315 == name) {
316 whichHeap = HEAP_DALVIK;
317 subHeap = HEAP_DALVIK_LARGE;
318 } else if (strstr(name, "/dev/ashmem/dalvik-non moving space") == name) {
319 whichHeap = HEAP_DALVIK;
320 subHeap = HEAP_DALVIK_NON_MOVING;
321 } else if (strstr(name, "/dev/ashmem/dalvik-zygote space") == name) {
322 whichHeap = HEAP_DALVIK;
323 subHeap = HEAP_DALVIK_ZYGOTE;
324 } else if (strstr(name, "/dev/ashmem/dalvik-indirect ref") == name) {
325 subHeap = HEAP_DALVIK_INDIRECT_REFERENCE_TABLE;
326 } else if (strstr(name, "/dev/ashmem/dalvik-jit-code-cache") == name) {
327 subHeap = HEAP_DALVIK_CODE_CACHE;
328 } else {
329 subHeap = HEAP_DALVIK_ACCOUNTING; // Default to accounting.
330 }
331 } else if (strncmp(name, "/dev/ashmem/CursorWindow", 24) == 0) {
332 whichHeap = HEAP_CURSOR;
333 } else if (strncmp(name, "/dev/ashmem/libc malloc", 23) == 0) {
334 whichHeap = HEAP_NATIVE;
335 } else {
336 whichHeap = HEAP_ASHMEM;
337 }
338 } else {
339 whichHeap = HEAP_UNKNOWN_DEV;
340 }
341 } else if (strncmp(name, "[anon:", 6) == 0) {
342 whichHeap = HEAP_UNKNOWN;
343 } else if (nameLen > 0) {
344 whichHeap = HEAP_UNKNOWN_MAP;
345 } else if (start == prevEnd && prevHeap == HEAP_SO) {
346 // bss section of a shared library.
347 whichHeap = HEAP_SO;
348 }
349 }
350
351 //ALOGI("native=%d dalvik=%d sqlite=%d: %s\n", isNativeHeap, isDalvikHeap,
352 // isSqliteHeap, line);
353
354 shared_clean = 0;
355 shared_dirty = 0;
356 private_clean = 0;
357 private_dirty = 0;
358 swapped_out = 0;
359 swapped_out_pss = 0;
360
361 while (true) {
362 if (fgets(line, 1024, fp) == 0) {
363 done = true;
364 break;
365 }
366
367 if (line[0] == 'S' && sscanf(line, "Size: %d kB", &temp) == 1) {
368 /* size = temp; */
369 } else if (line[0] == 'R' && sscanf(line, "Rss: %d kB", &temp) == 1) {
370 /* resident = temp; */
371 } else if (line[0] == 'P' && sscanf(line, "Pss: %d kB", &temp) == 1) {
372 pss = temp;
373 } else if (line[0] == 'S' && sscanf(line, "Shared_Clean: %d kB", &temp) == 1) {
374 shared_clean = temp;
375 } else if (line[0] == 'S' && sscanf(line, "Shared_Dirty: %d kB", &temp) == 1) {
376 shared_dirty = temp;
377 } else if (line[0] == 'P' && sscanf(line, "Private_Clean: %d kB", &temp) == 1) {
378 private_clean = temp;
379 } else if (line[0] == 'P' && sscanf(line, "Private_Dirty: %d kB", &temp) == 1) {
380 private_dirty = temp;
381 } else if (line[0] == 'R' && sscanf(line, "Referenced: %d kB", &temp) == 1) {
382 /* referenced = temp; */
383 } else if (line[0] == 'S' && sscanf(line, "Swap: %d kB", &temp) == 1) {
384 swapped_out = temp;
385 } else if (line[0] == 'S' && sscanf(line, "SwapPss: %d kB", &temp) == 1) {
386 *foundSwapPss = true;
387 swapped_out_pss = temp;
388 } else if (sscanf(line, "%" SCNx64 "-%" SCNx64 " %*s %*x %*x:%*x %*d", &start, &end) == 2) {
389 // looks like a new mapping
390 // example: "10000000-10001000 ---p 10000000 00:00 0"
391 break;
392 }
393 }
394
395 if (!skip) {
396 if (is_swappable && (pss > 0)) {
397 sharing_proportion = 0.0;
398 if ((shared_clean > 0) || (shared_dirty > 0)) {
399 sharing_proportion = (pss - private_clean
400 - private_dirty)/(shared_clean+shared_dirty);
401 }
402 swappable_pss = (sharing_proportion*shared_clean) + private_clean;
403 } else
404 swappable_pss = 0;
405
406 stats[whichHeap].pss += pss;
407 stats[whichHeap].swappablePss += swappable_pss;
408 stats[whichHeap].privateDirty += private_dirty;
409 stats[whichHeap].sharedDirty += shared_dirty;
410 stats[whichHeap].privateClean += private_clean;
411 stats[whichHeap].sharedClean += shared_clean;
412 stats[whichHeap].swappedOut += swapped_out;
413 stats[whichHeap].swappedOutPss += swapped_out_pss;
414 if (whichHeap == HEAP_DALVIK || whichHeap == HEAP_DALVIK_OTHER) {
415 stats[subHeap].pss += pss;
416 stats[subHeap].swappablePss += swappable_pss;
417 stats[subHeap].privateDirty += private_dirty;
418 stats[subHeap].sharedDirty += shared_dirty;
419 stats[subHeap].privateClean += private_clean;
420 stats[subHeap].sharedClean += shared_clean;
421 stats[subHeap].swappedOut += swapped_out;
422 stats[subHeap].swappedOutPss += swapped_out_pss;
423 }
424 }
425 }
426 }
427
load_maps(int pid,stats_t * stats,bool * foundSwapPss)428 static void load_maps(int pid, stats_t* stats, bool* foundSwapPss)
429 {
430 char tmp[128];
431 FILE *fp;
432
433 sprintf(tmp, "/proc/%d/smaps", pid);
434 fp = fopen(tmp, "r");
435 if (fp == 0) return;
436
437 read_mapinfo(fp, stats, foundSwapPss);
438 fclose(fp);
439 }
440
android_os_Debug_getDirtyPagesPid(JNIEnv * env,jobject clazz,jint pid,jobject object)441 static void android_os_Debug_getDirtyPagesPid(JNIEnv *env, jobject clazz,
442 jint pid, jobject object)
443 {
444 bool foundSwapPss;
445 stats_t stats[_NUM_HEAP];
446 memset(&stats, 0, sizeof(stats));
447
448 load_maps(pid, stats, &foundSwapPss);
449
450 struct graphics_memory_pss graphics_mem;
451 if (read_memtrack_memory(pid, &graphics_mem) == 0) {
452 stats[HEAP_GRAPHICS].pss = graphics_mem.graphics;
453 stats[HEAP_GRAPHICS].privateDirty = graphics_mem.graphics;
454 stats[HEAP_GL].pss = graphics_mem.gl;
455 stats[HEAP_GL].privateDirty = graphics_mem.gl;
456 stats[HEAP_OTHER_MEMTRACK].pss = graphics_mem.other;
457 stats[HEAP_OTHER_MEMTRACK].privateDirty = graphics_mem.other;
458 }
459
460 for (int i=_NUM_CORE_HEAP; i<_NUM_EXCLUSIVE_HEAP; i++) {
461 stats[HEAP_UNKNOWN].pss += stats[i].pss;
462 stats[HEAP_UNKNOWN].swappablePss += stats[i].swappablePss;
463 stats[HEAP_UNKNOWN].privateDirty += stats[i].privateDirty;
464 stats[HEAP_UNKNOWN].sharedDirty += stats[i].sharedDirty;
465 stats[HEAP_UNKNOWN].privateClean += stats[i].privateClean;
466 stats[HEAP_UNKNOWN].sharedClean += stats[i].sharedClean;
467 stats[HEAP_UNKNOWN].swappedOut += stats[i].swappedOut;
468 stats[HEAP_UNKNOWN].swappedOutPss += stats[i].swappedOutPss;
469 }
470
471 for (int i=0; i<_NUM_CORE_HEAP; i++) {
472 env->SetIntField(object, stat_fields[i].pss_field, stats[i].pss);
473 env->SetIntField(object, stat_fields[i].pssSwappable_field, stats[i].swappablePss);
474 env->SetIntField(object, stat_fields[i].privateDirty_field, stats[i].privateDirty);
475 env->SetIntField(object, stat_fields[i].sharedDirty_field, stats[i].sharedDirty);
476 env->SetIntField(object, stat_fields[i].privateClean_field, stats[i].privateClean);
477 env->SetIntField(object, stat_fields[i].sharedClean_field, stats[i].sharedClean);
478 env->SetIntField(object, stat_fields[i].swappedOut_field, stats[i].swappedOut);
479 env->SetIntField(object, stat_fields[i].swappedOutPss_field, stats[i].swappedOutPss);
480 }
481
482
483 env->SetBooleanField(object, hasSwappedOutPss_field, foundSwapPss);
484 jintArray otherIntArray = (jintArray)env->GetObjectField(object, otherStats_field);
485
486 jint* otherArray = (jint*)env->GetPrimitiveArrayCritical(otherIntArray, 0);
487 if (otherArray == NULL) {
488 return;
489 }
490
491 int j=0;
492 for (int i=_NUM_CORE_HEAP; i<_NUM_HEAP; i++) {
493 otherArray[j++] = stats[i].pss;
494 otherArray[j++] = stats[i].swappablePss;
495 otherArray[j++] = stats[i].privateDirty;
496 otherArray[j++] = stats[i].sharedDirty;
497 otherArray[j++] = stats[i].privateClean;
498 otherArray[j++] = stats[i].sharedClean;
499 otherArray[j++] = stats[i].swappedOut;
500 otherArray[j++] = stats[i].swappedOutPss;
501 }
502
503 env->ReleasePrimitiveArrayCritical(otherIntArray, otherArray, 0);
504 }
505
android_os_Debug_getDirtyPages(JNIEnv * env,jobject clazz,jobject object)506 static void android_os_Debug_getDirtyPages(JNIEnv *env, jobject clazz, jobject object)
507 {
508 android_os_Debug_getDirtyPagesPid(env, clazz, getpid(), object);
509 }
510
android_os_Debug_getPssPid(JNIEnv * env,jobject clazz,jint pid,jlongArray outUssSwapPss,jlongArray outMemtrack)511 static jlong android_os_Debug_getPssPid(JNIEnv *env, jobject clazz, jint pid,
512 jlongArray outUssSwapPss, jlongArray outMemtrack)
513 {
514 char line[1024];
515 jlong pss = 0;
516 jlong swapPss = 0;
517 jlong uss = 0;
518 jlong memtrack = 0;
519
520 char tmp[128];
521 FILE *fp;
522
523 struct graphics_memory_pss graphics_mem;
524 if (read_memtrack_memory(pid, &graphics_mem) == 0) {
525 pss = uss = memtrack = graphics_mem.graphics + graphics_mem.gl + graphics_mem.other;
526 }
527
528 sprintf(tmp, "/proc/%d/smaps", pid);
529 fp = fopen(tmp, "r");
530
531 if (fp != 0) {
532 while (true) {
533 if (fgets(line, 1024, fp) == NULL) {
534 break;
535 }
536
537 if (line[0] == 'P') {
538 if (strncmp(line, "Pss:", 4) == 0) {
539 char* c = line + 4;
540 while (*c != 0 && (*c < '0' || *c > '9')) {
541 c++;
542 }
543 pss += atoi(c);
544 } else if (strncmp(line, "Private_Clean:", 14) == 0
545 || strncmp(line, "Private_Dirty:", 14) == 0) {
546 char* c = line + 14;
547 while (*c != 0 && (*c < '0' || *c > '9')) {
548 c++;
549 }
550 uss += atoi(c);
551 }
552 } else if (line[0] == 'S' && strncmp(line, "SwapPss:", 8) == 0) {
553 char* c = line + 8;
554 jlong lSwapPss;
555 while (*c != 0 && (*c < '0' || *c > '9')) {
556 c++;
557 }
558 lSwapPss = atoi(c);
559 swapPss += lSwapPss;
560 pss += lSwapPss; // Also in swap, those pages would be accounted as Pss without SWAP
561 }
562 }
563
564 fclose(fp);
565 }
566
567 if (outUssSwapPss != NULL) {
568 if (env->GetArrayLength(outUssSwapPss) >= 1) {
569 jlong* outUssSwapPssArray = env->GetLongArrayElements(outUssSwapPss, 0);
570 if (outUssSwapPssArray != NULL) {
571 outUssSwapPssArray[0] = uss;
572 if (env->GetArrayLength(outUssSwapPss) >= 2) {
573 outUssSwapPssArray[1] = swapPss;
574 }
575 }
576 env->ReleaseLongArrayElements(outUssSwapPss, outUssSwapPssArray, 0);
577 }
578 }
579
580 if (outMemtrack != NULL) {
581 if (env->GetArrayLength(outMemtrack) >= 1) {
582 jlong* outMemtrackArray = env->GetLongArrayElements(outMemtrack, 0);
583 if (outMemtrackArray != NULL) {
584 outMemtrackArray[0] = memtrack;
585 }
586 env->ReleaseLongArrayElements(outMemtrack, outMemtrackArray, 0);
587 }
588 }
589
590 return pss;
591 }
592
android_os_Debug_getPss(JNIEnv * env,jobject clazz)593 static jlong android_os_Debug_getPss(JNIEnv *env, jobject clazz)
594 {
595 return android_os_Debug_getPssPid(env, clazz, getpid(), NULL, NULL);
596 }
597
get_allocated_vmalloc_memory()598 static long get_allocated_vmalloc_memory() {
599 char line[1024];
600 // Ignored tags that don't actually consume memory (ie remappings)
601 static const char* const ignored_tags[] = {
602 "ioremap",
603 "map_lowmem",
604 "vm_map_ram",
605 NULL
606 };
607 long size, vmalloc_allocated_size = 0;
608 FILE* fp = fopen("/proc/vmallocinfo", "r");
609 if (fp == NULL) {
610 return 0;
611 }
612 while (true) {
613 if (fgets(line, 1024, fp) == NULL) {
614 break;
615 }
616 bool valid_line = true;
617 int i = 0;
618 while (ignored_tags[i]) {
619 if (strstr(line, ignored_tags[i]) != NULL) {
620 valid_line = false;
621 break;
622 }
623 i++;
624 }
625 if (valid_line && (sscanf(line, "%*x-%*x %ld", &size) == 1)) {
626 vmalloc_allocated_size += size;
627 }
628 }
629 fclose(fp);
630 return vmalloc_allocated_size;
631 }
632
633 enum {
634 MEMINFO_TOTAL,
635 MEMINFO_FREE,
636 MEMINFO_BUFFERS,
637 MEMINFO_CACHED,
638 MEMINFO_SHMEM,
639 MEMINFO_SLAB,
640 MEMINFO_SWAP_TOTAL,
641 MEMINFO_SWAP_FREE,
642 MEMINFO_ZRAM_TOTAL,
643 MEMINFO_MAPPED,
644 MEMINFO_VMALLOC_USED,
645 MEMINFO_PAGE_TABLES,
646 MEMINFO_KERNEL_STACK,
647 MEMINFO_COUNT
648 };
649
get_zram_mem_used()650 static long long get_zram_mem_used()
651 {
652 #define ZRAM_SYSFS "/sys/block/zram0/"
653 FILE *f = fopen(ZRAM_SYSFS "mm_stat", "r");
654 if (f) {
655 long long mem_used_total = 0;
656
657 int matched = fscanf(f, "%*d %*d %lld %*d %*d %*d %*d", &mem_used_total);
658 if (matched != 1)
659 ALOGW("failed to parse " ZRAM_SYSFS "mm_stat");
660
661 fclose(f);
662 return mem_used_total;
663 }
664
665 f = fopen(ZRAM_SYSFS "mem_used_total", "r");
666 if (f) {
667 long long mem_used_total = 0;
668
669 int matched = fscanf(f, "%lld", &mem_used_total);
670 if (matched != 1)
671 ALOGW("failed to parse " ZRAM_SYSFS "mem_used_total");
672
673 fclose(f);
674 return mem_used_total;
675 }
676
677 return 0;
678 }
679
android_os_Debug_getMemInfo(JNIEnv * env,jobject clazz,jlongArray out)680 static void android_os_Debug_getMemInfo(JNIEnv *env, jobject clazz, jlongArray out)
681 {
682 char buffer[1024];
683 size_t numFound = 0;
684
685 if (out == NULL) {
686 jniThrowNullPointerException(env, "out == null");
687 return;
688 }
689
690 int fd = open("/proc/meminfo", O_RDONLY);
691
692 if (fd < 0) {
693 ALOGW("Unable to open /proc/meminfo: %s\n", strerror(errno));
694 return;
695 }
696
697 int len = read(fd, buffer, sizeof(buffer)-1);
698 close(fd);
699
700 if (len < 0) {
701 ALOGW("Empty /proc/meminfo");
702 return;
703 }
704 buffer[len] = 0;
705
706 static const char* const tags[] = {
707 "MemTotal:",
708 "MemFree:",
709 "Buffers:",
710 "Cached:",
711 "Shmem:",
712 "Slab:",
713 "SwapTotal:",
714 "SwapFree:",
715 "ZRam:",
716 "Mapped:",
717 "VmallocUsed:",
718 "PageTables:",
719 "KernelStack:",
720 NULL
721 };
722 static const int tagsLen[] = {
723 9,
724 8,
725 8,
726 7,
727 6,
728 5,
729 10,
730 9,
731 5,
732 7,
733 12,
734 11,
735 12,
736 0
737 };
738 long mem[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
739
740 char* p = buffer;
741 while (*p && numFound < (sizeof(tagsLen) / sizeof(tagsLen[0]))) {
742 int i = 0;
743 while (tags[i]) {
744 if (strncmp(p, tags[i], tagsLen[i]) == 0) {
745 p += tagsLen[i];
746 while (*p == ' ') p++;
747 char* num = p;
748 while (*p >= '0' && *p <= '9') p++;
749 if (*p != 0) {
750 *p = 0;
751 p++;
752 }
753 mem[i] = atoll(num);
754 numFound++;
755 break;
756 }
757 i++;
758 }
759 while (*p && *p != '\n') {
760 p++;
761 }
762 if (*p) p++;
763 }
764
765 mem[MEMINFO_ZRAM_TOTAL] = get_zram_mem_used() / 1024;
766 // Recompute Vmalloc Used since the value in meminfo
767 // doesn't account for I/O remapping which doesn't use RAM.
768 mem[MEMINFO_VMALLOC_USED] = get_allocated_vmalloc_memory() / 1024;
769
770 int maxNum = env->GetArrayLength(out);
771 if (maxNum > MEMINFO_COUNT) {
772 maxNum = MEMINFO_COUNT;
773 }
774 jlong* outArray = env->GetLongArrayElements(out, 0);
775 if (outArray != NULL) {
776 for (int i=0; i<maxNum; i++) {
777 outArray[i] = mem[i];
778 }
779 }
780 env->ReleaseLongArrayElements(out, outArray, 0);
781 }
782
783
read_binder_stat(const char * stat)784 static jint read_binder_stat(const char* stat)
785 {
786 FILE* fp = fopen(BINDER_STATS, "r");
787 if (fp == NULL) {
788 return -1;
789 }
790
791 char line[1024];
792
793 char compare[128];
794 int len = snprintf(compare, 128, "proc %d", getpid());
795
796 // loop until we have the block that represents this process
797 do {
798 if (fgets(line, 1024, fp) == 0) {
799 fclose(fp);
800 return -1;
801 }
802 } while (strncmp(compare, line, len));
803
804 // now that we have this process, read until we find the stat that we are looking for
805 len = snprintf(compare, 128, " %s: ", stat);
806
807 do {
808 if (fgets(line, 1024, fp) == 0) {
809 fclose(fp);
810 return -1;
811 }
812 } while (strncmp(compare, line, len));
813
814 // we have the line, now increment the line ptr to the value
815 char* ptr = line + len;
816 jint result = atoi(ptr);
817 fclose(fp);
818 return result;
819 }
820
android_os_Debug_getBinderSentTransactions(JNIEnv * env,jobject clazz)821 static jint android_os_Debug_getBinderSentTransactions(JNIEnv *env, jobject clazz)
822 {
823 return read_binder_stat("bcTRANSACTION");
824 }
825
android_os_getBinderReceivedTransactions(JNIEnv * env,jobject clazz)826 static jint android_os_getBinderReceivedTransactions(JNIEnv *env, jobject clazz)
827 {
828 return read_binder_stat("brTRANSACTION");
829 }
830
831 // these are implemented in android_util_Binder.cpp
832 jint android_os_Debug_getLocalObjectCount(JNIEnv* env, jobject clazz);
833 jint android_os_Debug_getProxyObjectCount(JNIEnv* env, jobject clazz);
834 jint android_os_Debug_getDeathObjectCount(JNIEnv* env, jobject clazz);
835
836
837 /* pulled out of bionic */
838 extern "C" void get_malloc_leak_info(uint8_t** info, size_t* overallSize,
839 size_t* infoSize, size_t* totalMemory, size_t* backtraceSize);
840 extern "C" void free_malloc_leak_info(uint8_t* info);
841 #define SIZE_FLAG_ZYGOTE_CHILD (1<<31)
842 #define BACKTRACE_SIZE 32
843
844 /*
845 * This is a qsort() callback.
846 *
847 * See dumpNativeHeap() for comments about the data format and sort order.
848 */
compareHeapRecords(const void * vrec1,const void * vrec2)849 static int compareHeapRecords(const void* vrec1, const void* vrec2)
850 {
851 const size_t* rec1 = (const size_t*) vrec1;
852 const size_t* rec2 = (const size_t*) vrec2;
853 size_t size1 = *rec1;
854 size_t size2 = *rec2;
855
856 if (size1 < size2) {
857 return 1;
858 } else if (size1 > size2) {
859 return -1;
860 }
861
862 intptr_t* bt1 = (intptr_t*)(rec1 + 2);
863 intptr_t* bt2 = (intptr_t*)(rec2 + 2);
864 for (size_t idx = 0; idx < BACKTRACE_SIZE; idx++) {
865 intptr_t addr1 = bt1[idx];
866 intptr_t addr2 = bt2[idx];
867 if (addr1 == addr2) {
868 if (addr1 == 0)
869 break;
870 continue;
871 }
872 if (addr1 < addr2) {
873 return -1;
874 } else if (addr1 > addr2) {
875 return 1;
876 }
877 }
878
879 return 0;
880 }
881
882 /*
883 * The get_malloc_leak_info() call returns an array of structs that
884 * look like this:
885 *
886 * size_t size
887 * size_t allocations
888 * intptr_t backtrace[32]
889 *
890 * "size" is the size of the allocation, "backtrace" is a fixed-size
891 * array of function pointers, and "allocations" is the number of
892 * allocations with the exact same size and backtrace.
893 *
894 * The entries are sorted by descending total size (i.e. size*allocations)
895 * then allocation count. For best results with "diff" we'd like to sort
896 * primarily by individual size then stack trace. Since the entries are
897 * fixed-size, and we're allowed (by the current implementation) to mangle
898 * them, we can do this in place.
899 */
dumpNativeHeap(FILE * fp)900 static void dumpNativeHeap(FILE* fp)
901 {
902 uint8_t* info = NULL;
903 size_t overallSize, infoSize, totalMemory, backtraceSize;
904
905 get_malloc_leak_info(&info, &overallSize, &infoSize, &totalMemory,
906 &backtraceSize);
907 if (info == NULL) {
908 fprintf(fp, "Native heap dump not available. To enable, run these"
909 " commands (requires root):\n");
910 fprintf(fp, "$ adb shell setprop libc.debug.malloc 1\n");
911 fprintf(fp, "$ adb shell stop\n");
912 fprintf(fp, "$ adb shell start\n");
913 return;
914 }
915 assert(infoSize != 0);
916 assert(overallSize % infoSize == 0);
917
918 fprintf(fp, "Android Native Heap Dump v1.0\n\n");
919
920 size_t recordCount = overallSize / infoSize;
921 fprintf(fp, "Total memory: %zu\n", totalMemory);
922 fprintf(fp, "Allocation records: %zd\n", recordCount);
923 if (backtraceSize != BACKTRACE_SIZE) {
924 fprintf(fp, "WARNING: mismatched backtrace sizes (%zu vs. %d)\n",
925 backtraceSize, BACKTRACE_SIZE);
926 }
927 fprintf(fp, "\n");
928
929 /* re-sort the entries */
930 qsort(info, recordCount, infoSize, compareHeapRecords);
931
932 /* dump the entries to the file */
933 const uint8_t* ptr = info;
934 for (size_t idx = 0; idx < recordCount; idx++) {
935 size_t size = *(size_t*) ptr;
936 size_t allocations = *(size_t*) (ptr + sizeof(size_t));
937 intptr_t* backtrace = (intptr_t*) (ptr + sizeof(size_t) * 2);
938
939 fprintf(fp, "z %d sz %8zu num %4zu bt",
940 (size & SIZE_FLAG_ZYGOTE_CHILD) != 0,
941 size & ~SIZE_FLAG_ZYGOTE_CHILD,
942 allocations);
943 for (size_t bt = 0; bt < backtraceSize; bt++) {
944 if (backtrace[bt] == 0) {
945 break;
946 } else {
947 #ifdef __LP64__
948 fprintf(fp, " %016" PRIxPTR, backtrace[bt]);
949 #else
950 fprintf(fp, " %08" PRIxPTR, backtrace[bt]);
951 #endif
952 }
953 }
954 fprintf(fp, "\n");
955
956 ptr += infoSize;
957 }
958
959 free_malloc_leak_info(info);
960
961 fprintf(fp, "MAPS\n");
962 const char* maps = "/proc/self/maps";
963 FILE* in = fopen(maps, "r");
964 if (in == NULL) {
965 fprintf(fp, "Could not open %s\n", maps);
966 return;
967 }
968 char buf[BUFSIZ];
969 while (size_t n = fread(buf, sizeof(char), BUFSIZ, in)) {
970 fwrite(buf, sizeof(char), n, fp);
971 }
972 fclose(in);
973
974 fprintf(fp, "END\n");
975 }
976
977 /*
978 * Dump the native heap, writing human-readable output to the specified
979 * file descriptor.
980 */
android_os_Debug_dumpNativeHeap(JNIEnv * env,jobject clazz,jobject fileDescriptor)981 static void android_os_Debug_dumpNativeHeap(JNIEnv* env, jobject clazz,
982 jobject fileDescriptor)
983 {
984 if (fileDescriptor == NULL) {
985 jniThrowNullPointerException(env, "fd == null");
986 return;
987 }
988 int origFd = jniGetFDFromFileDescriptor(env, fileDescriptor);
989 if (origFd < 0) {
990 jniThrowRuntimeException(env, "Invalid file descriptor");
991 return;
992 }
993
994 /* dup() the descriptor so we don't close the original with fclose() */
995 int fd = dup(origFd);
996 if (fd < 0) {
997 ALOGW("dup(%d) failed: %s\n", origFd, strerror(errno));
998 jniThrowRuntimeException(env, "dup() failed");
999 return;
1000 }
1001
1002 FILE* fp = fdopen(fd, "w");
1003 if (fp == NULL) {
1004 ALOGW("fdopen(%d) failed: %s\n", fd, strerror(errno));
1005 close(fd);
1006 jniThrowRuntimeException(env, "fdopen() failed");
1007 return;
1008 }
1009
1010 ALOGD("Native heap dump starting...\n");
1011 dumpNativeHeap(fp);
1012 ALOGD("Native heap dump complete.\n");
1013
1014 fclose(fp);
1015 }
1016
1017
android_os_Debug_dumpNativeBacktraceToFile(JNIEnv * env,jobject clazz,jint pid,jstring fileName)1018 static void android_os_Debug_dumpNativeBacktraceToFile(JNIEnv* env, jobject clazz,
1019 jint pid, jstring fileName)
1020 {
1021 if (fileName == NULL) {
1022 jniThrowNullPointerException(env, "file == null");
1023 return;
1024 }
1025 const jchar* str = env->GetStringCritical(fileName, 0);
1026 String8 fileName8;
1027 if (str) {
1028 fileName8 = String8(reinterpret_cast<const char16_t*>(str),
1029 env->GetStringLength(fileName));
1030 env->ReleaseStringCritical(fileName, str);
1031 }
1032
1033 int fd = open(fileName8.string(), O_CREAT | O_WRONLY | O_NOFOLLOW, 0666); /* -rw-rw-rw- */
1034 if (fd < 0) {
1035 fprintf(stderr, "Can't open %s: %s\n", fileName8.string(), strerror(errno));
1036 return;
1037 }
1038
1039 if (lseek(fd, 0, SEEK_END) < 0) {
1040 fprintf(stderr, "lseek: %s\n", strerror(errno));
1041 } else {
1042 dump_backtrace_to_file(pid, fd);
1043 }
1044
1045 close(fd);
1046 }
1047
android_os_Debug_getUnreachableMemory(JNIEnv * env,jobject clazz,jint limit,jboolean contents)1048 static jstring android_os_Debug_getUnreachableMemory(JNIEnv* env, jobject clazz,
1049 jint limit, jboolean contents)
1050 {
1051 std::string s = GetUnreachableMemoryString(contents, limit);
1052 return env->NewStringUTF(s.c_str());
1053 }
1054
1055 /*
1056 * JNI registration.
1057 */
1058
1059 static const JNINativeMethod gMethods[] = {
1060 { "getNativeHeapSize", "()J",
1061 (void*) android_os_Debug_getNativeHeapSize },
1062 { "getNativeHeapAllocatedSize", "()J",
1063 (void*) android_os_Debug_getNativeHeapAllocatedSize },
1064 { "getNativeHeapFreeSize", "()J",
1065 (void*) android_os_Debug_getNativeHeapFreeSize },
1066 { "getMemoryInfo", "(Landroid/os/Debug$MemoryInfo;)V",
1067 (void*) android_os_Debug_getDirtyPages },
1068 { "getMemoryInfo", "(ILandroid/os/Debug$MemoryInfo;)V",
1069 (void*) android_os_Debug_getDirtyPagesPid },
1070 { "getPss", "()J",
1071 (void*) android_os_Debug_getPss },
1072 { "getPss", "(I[J[J)J",
1073 (void*) android_os_Debug_getPssPid },
1074 { "getMemInfo", "([J)V",
1075 (void*) android_os_Debug_getMemInfo },
1076 { "dumpNativeHeap", "(Ljava/io/FileDescriptor;)V",
1077 (void*) android_os_Debug_dumpNativeHeap },
1078 { "getBinderSentTransactions", "()I",
1079 (void*) android_os_Debug_getBinderSentTransactions },
1080 { "getBinderReceivedTransactions", "()I",
1081 (void*) android_os_getBinderReceivedTransactions },
1082 { "getBinderLocalObjectCount", "()I",
1083 (void*)android_os_Debug_getLocalObjectCount },
1084 { "getBinderProxyObjectCount", "()I",
1085 (void*)android_os_Debug_getProxyObjectCount },
1086 { "getBinderDeathObjectCount", "()I",
1087 (void*)android_os_Debug_getDeathObjectCount },
1088 { "dumpNativeBacktraceToFile", "(ILjava/lang/String;)V",
1089 (void*)android_os_Debug_dumpNativeBacktraceToFile },
1090 { "getUnreachableMemory", "(IZ)Ljava/lang/String;",
1091 (void*)android_os_Debug_getUnreachableMemory },
1092 };
1093
register_android_os_Debug(JNIEnv * env)1094 int register_android_os_Debug(JNIEnv *env)
1095 {
1096 int err = memtrack_init();
1097 if (err != 0) {
1098 memtrackLoaded = false;
1099 ALOGE("failed to load memtrack module: %d", err);
1100 } else {
1101 memtrackLoaded = true;
1102 }
1103
1104 jclass clazz = env->FindClass("android/os/Debug$MemoryInfo");
1105
1106 // Sanity check the number of other statistics expected in Java matches here.
1107 jfieldID numOtherStats_field = env->GetStaticFieldID(clazz, "NUM_OTHER_STATS", "I");
1108 jint numOtherStats = env->GetStaticIntField(clazz, numOtherStats_field);
1109 jfieldID numDvkStats_field = env->GetStaticFieldID(clazz, "NUM_DVK_STATS", "I");
1110 jint numDvkStats = env->GetStaticIntField(clazz, numDvkStats_field);
1111 int expectedNumOtherStats = _NUM_HEAP - _NUM_CORE_HEAP;
1112 if ((numOtherStats + numDvkStats) != expectedNumOtherStats) {
1113 jniThrowExceptionFmt(env, "java/lang/RuntimeException",
1114 "android.os.Debug.Meminfo.NUM_OTHER_STATS+android.os.Debug.Meminfo.NUM_DVK_STATS=%d expected %d",
1115 numOtherStats+numDvkStats, expectedNumOtherStats);
1116 return JNI_ERR;
1117 }
1118
1119 otherStats_field = env->GetFieldID(clazz, "otherStats", "[I");
1120 hasSwappedOutPss_field = env->GetFieldID(clazz, "hasSwappedOutPss", "Z");
1121
1122 for (int i=0; i<_NUM_CORE_HEAP; i++) {
1123 stat_fields[i].pss_field =
1124 env->GetFieldID(clazz, stat_field_names[i].pss_name, "I");
1125 stat_fields[i].pssSwappable_field =
1126 env->GetFieldID(clazz, stat_field_names[i].pssSwappable_name, "I");
1127 stat_fields[i].privateDirty_field =
1128 env->GetFieldID(clazz, stat_field_names[i].privateDirty_name, "I");
1129 stat_fields[i].sharedDirty_field =
1130 env->GetFieldID(clazz, stat_field_names[i].sharedDirty_name, "I");
1131 stat_fields[i].privateClean_field =
1132 env->GetFieldID(clazz, stat_field_names[i].privateClean_name, "I");
1133 stat_fields[i].sharedClean_field =
1134 env->GetFieldID(clazz, stat_field_names[i].sharedClean_name, "I");
1135 stat_fields[i].swappedOut_field =
1136 env->GetFieldID(clazz, stat_field_names[i].swappedOut_name, "I");
1137 stat_fields[i].swappedOutPss_field =
1138 env->GetFieldID(clazz, stat_field_names[i].swappedOutPss_name, "I");
1139 }
1140
1141 return jniRegisterNativeMethods(env, "android/os/Debug", gMethods, NELEM(gMethods));
1142 }
1143
1144 }; // namespace android
1145