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