android_ddm_DdmHandleNativeHeap.cpp revision 3b2dc9e2253671fd8432fb0b1e18a0b5a38c4dea 
1/* //device/libs/android_runtime/android_ddm_DdmHandleNativeHeap.cpp
2**
3** Copyright 2006, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#undef LOG_TAG
19#define LOG_TAG "DdmHandleNativeHeap"
20
21#include <JNIHelp.h>
22#include <jni.h>
23#include <android_runtime/AndroidRuntime.h>
24
25#include <utils/Log.h>
26#include <utils/String8.h>
27
28#include <fcntl.h>
29#include <errno.h>
30#include <sys/types.h>
31#include <sys/stat.h>
32
33extern "C" void get_malloc_leak_info(uint8_t** info, size_t* overallSize,
34                                     size_t* infoSize, size_t* totalMemory, size_t* backtraceSize);
35
36extern "C" void free_malloc_leak_info(uint8_t* info);
37
38#define DDMS_HEADER_SIGNATURE 0x812345dd
39#define DDMS_VERSION 2
40
41struct Header {
42#if defined(__LP64__)
43    uint32_t signature;
44    uint16_t version;
45    uint16_t pointerSize;
46#endif
47    size_t mapSize;
48    size_t allocSize;
49    size_t allocInfoSize;
50    size_t totalMemory;
51    size_t backtraceSize;
52};
53
54namespace android {
55
56static void ReadFile(const char* path, String8& s) {
57    int fd = open(path, O_RDONLY);
58    if (fd != -1) {
59        char bytes[1024];
60        ssize_t byteCount;
61        while ((byteCount = TEMP_FAILURE_RETRY(read(fd, bytes, sizeof(bytes)))) > 0) {
62            s.append(bytes, byteCount);
63        }
64        close(fd);
65    }
66}
67
68/*
69 * Retrieve the native heap information and the info from /proc/self/maps,
70 * copy them into a byte[] with a "struct Header" that holds data offsets,
71 * and return the array.
72 */
73static jbyteArray DdmHandleNativeHeap_getLeakInfo(JNIEnv* env, jobject) {
74    Header header;
75    memset(&header, 0, sizeof(header));
76
77    String8 maps;
78    ReadFile("/proc/self/maps", maps);
79    header.mapSize = maps.size();
80
81    uint8_t* allocBytes;
82    get_malloc_leak_info(&allocBytes, &header.allocSize, &header.allocInfoSize,
83                         &header.totalMemory, &header.backtraceSize);
84
85    ALOGD("*** mapSize: %d allocSize: %d allocInfoSize: %d totalMemory: %d",
86          header.mapSize, header.allocSize, header.allocInfoSize, header.totalMemory);
87
88#if defined(__LP64__)
89    header.signature = DDMS_HEADER_SIGNATURE;
90    header.version = DDMS_VERSION;
91    header.pointerSize = sizeof(void*);
92#endif
93
94    jbyteArray array = env->NewByteArray(sizeof(Header) + header.mapSize + header.allocSize);
95    if (array != NULL) {
96        env->SetByteArrayRegion(array, 0,
97                                sizeof(header), reinterpret_cast<jbyte*>(&header));
98        env->SetByteArrayRegion(array, sizeof(header),
99                                maps.size(), reinterpret_cast<const jbyte*>(maps.string()));
100        env->SetByteArrayRegion(array, sizeof(header) + maps.size(),
101                                header.allocSize, reinterpret_cast<jbyte*>(allocBytes));
102    }
103
104    free_malloc_leak_info(allocBytes);
105    return array;
106}
107
108static JNINativeMethod method_table[] = {
109    { "getLeakInfo", "()[B", (void*) DdmHandleNativeHeap_getLeakInfo },
110};
111
112int register_android_ddm_DdmHandleNativeHeap(JNIEnv* env) {
113    return AndroidRuntime::registerNativeMethods(env, "android/ddm/DdmHandleNativeHeap", method_table, NELEM(method_table));
114}
115
116};
117