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