Home | History | Annotate | Download | only in jni 
      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 <nativehelper/JNIHelp.h>
     22 #include <jni.h>
     23 #include "core_jni_helpers.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: %zu allocSize: %zu allocInfoSize: %zu totalMemory: %zu",
     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 const JNINativeMethod method_table[] = {
    109     { "getLeakInfo", "()[B", (void*) DdmHandleNativeHeap_getLeakInfo },
    110 };
    111 
    112 int register_android_ddm_DdmHandleNativeHeap(JNIEnv* env) {
    113     return RegisterMethodsOrDie(env, "android/ddm/DdmHandleNativeHeap", method_table,
    114                                 NELEM(method_table));
    115 }
    116 
    117 };
    118