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 33 extern "C" void get_malloc_leak_info(uint8_t** info, size_t* overallSize, 34 size_t* infoSize, size_t* totalMemory, size_t* backtraceSize); 35 36 extern "C" void free_malloc_leak_info(uint8_t* info); 37 38 #define DDMS_HEADER_SIGNATURE 0x812345dd 39 #define DDMS_VERSION 2 40 41 struct 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 54 namespace android { 55 56 static 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 */ 73 static 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 108 static JNINativeMethod method_table[] = { 109 { "getLeakInfo", "()[B", (void*) DdmHandleNativeHeap_getLeakInfo }, 110 }; 111 112 int register_android_ddm_DdmHandleNativeHeap(JNIEnv* env) { 113 return AndroidRuntime::registerNativeMethods(env, "android/ddm/DdmHandleNativeHeap", method_table, NELEM(method_table)); 114 } 115 116 }; 117