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 */
Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_threadNotify(const u4 * args,JValue * pResult)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 //LOGI("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 */
Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getThreadStats(const u4 * args,JValue * pResult)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 */
Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_heapInfoNotify(const u4 * args,JValue * pResult)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
Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_heapSegmentNotify(const u4 * args,JValue * pResult)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
Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getStackTraceById(const u4 * args,JValue * pResult)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
Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_enableRecentAllocations(const u4 * args,JValue * pResult)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
Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getRecentAllocationStatus(const u4 * args,JValue * pResult)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
Dalvik_org_apache_harmony_dalvik_ddmc_DdmVmInternal_getRecentAllocations(const u4 * args,JValue * pResult)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