Home | History | Annotate | Download | only in native
      1 /*
      2  * Copyright (C) 2008 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 /*
     18  * org.apache.harmony.dalvik.ddmc.DdmVmInternal
     19  */
     20 #include "Dalvik.h"
     21 #include "native/InternalNativePriv.h"
     22 
     23 
     24 /*
     25  * public static void threadNotify(boolean enable)
     26  *
     27  * Enable DDM thread notifications.
     28  */
     29 static void Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_threadNotify(
     30     const u4* args, JValue* pResult)
     31 {
     32     bool enable = (args[0] != 0);
     33 
     34     //ALOGI("ddmThreadNotification: %d", enable);
     35     dvmDdmSetThreadNotification(enable);
     36     RETURN_VOID();
     37 }
     38 
     39 /*
     40  * public static byte[] getThreadStats()
     41  *
     42  * Get a buffer full of thread info.
     43  */
     44 static void Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getThreadStats(
     45     const u4* args, JValue* pResult)
     46 {
     47     UNUSED_PARAMETER(args);
     48 
     49     ArrayObject* result = dvmDdmGenerateThreadStats();
     50     dvmReleaseTrackedAlloc((Object*) result, NULL);
     51     RETURN_PTR(result);
     52 }
     53 
     54 /*
     55  * public static int heapInfoNotify(int what)
     56  *
     57  * Enable DDM heap notifications.
     58  */
     59 static void Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_heapInfoNotify(
     60     const u4* args, JValue* pResult)
     61 {
     62     int when = args[0];
     63     bool ret;
     64 
     65     ret = dvmDdmHandleHpifChunk(when);
     66     RETURN_BOOLEAN(ret);
     67 }
     68 
     69 /*
     70  * public static boolean heapSegmentNotify(int when, int what, bool native)
     71  *
     72  * Enable DDM heap notifications.
     73  */
     74 static void
     75     Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_heapSegmentNotify(
     76     const u4* args, JValue* pResult)
     77 {
     78     int  when   = args[0];        // 0=never (off), 1=during GC
     79     int  what   = args[1];        // 0=merged objects, 1=distinct objects
     80     bool native = (args[2] != 0); // false=virtual heap, true=native heap
     81     bool ret;
     82 
     83     ret = dvmDdmHandleHpsgNhsgChunk(when, what, native);
     84     RETURN_BOOLEAN(ret);
     85 }
     86 
     87 /*
     88  * public static StackTraceElement[] getStackTraceById(int threadId)
     89  *
     90  * Get a stack trace as an array of StackTraceElement objects.  Returns
     91  * NULL on failure, e.g. if the threadId couldn't be found.
     92  */
     93 static void
     94     Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getStackTraceById(
     95     const u4* args, JValue* pResult)
     96 {
     97     u4 threadId = args[0];
     98     ArrayObject* trace;
     99 
    100     trace = dvmDdmGetStackTraceById(threadId);
    101     RETURN_PTR(trace);
    102 }
    103 
    104 /*
    105  * public static void enableRecentAllocations(boolean enable)
    106  *
    107  * Enable or disable recent allocation tracking.
    108  */
    109 static void
    110     Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_enableRecentAllocations(
    111     const u4* args, JValue* pResult)
    112 {
    113     bool enable = (args[0] != 0);
    114 
    115     if (enable)
    116         (void) dvmEnableAllocTracker();
    117     else
    118         (void) dvmDisableAllocTracker();
    119     RETURN_VOID();
    120 }
    121 
    122 /*
    123  * public static boolean getRecentAllocationStatus()
    124  *
    125  * Returns "true" if allocation tracking is enabled.
    126  */
    127 static void
    128     Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getRecentAllocationStatus(
    129     const u4* args, JValue* pResult)
    130 {
    131     UNUSED_PARAMETER(args);
    132     RETURN_BOOLEAN(gDvm.allocRecords != NULL);
    133 }
    134 
    135 /*
    136  * public static byte[] getRecentAllocations()
    137  *
    138  * Fill a buffer with data on recent heap allocations.
    139  */
    140 static void
    141     Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getRecentAllocations(
    142     const u4* args, JValue* pResult)
    143 {
    144     ArrayObject* data;
    145 
    146     data = dvmDdmGetRecentAllocations();
    147     dvmReleaseTrackedAlloc((Object*) data, NULL);
    148     RETURN_PTR(data);
    149 }
    150 
    151 const DalvikNativeMethod dvm_org_apache_harmony_dalvik_ddmc_DdmVmInternal[] = {
    152     { "threadNotify",       "(Z)V",
    153       Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_threadNotify },
    154     { "getThreadStats",     "()[B",
    155       Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getThreadStats },
    156     { "heapInfoNotify",     "(I)Z",
    157       Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_heapInfoNotify },
    158     { "heapSegmentNotify",  "(IIZ)Z",
    159       Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_heapSegmentNotify },
    160     { "getStackTraceById",  "(I)[Ljava/lang/StackTraceElement;",
    161       Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getStackTraceById },
    162     { "enableRecentAllocations", "(Z)V",
    163       Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_enableRecentAllocations },
    164     { "getRecentAllocationStatus", "()Z",
    165       Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getRecentAllocationStatus },
    166     { "getRecentAllocations", "()[B",
    167       Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getRecentAllocations },
    168     { NULL, NULL, NULL },
    169 };
    170