blob: 5e4487cdac6dfd1480c30ef772fb815222e570cf [file] [log] [blame]
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001/*
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 * Handle messages from debugger.
19 *
20 * GENERAL NOTE: we're not currently testing the message length for
21 * correctness. This is usually a bad idea, but here we can probably
22 * get away with it so long as the debugger isn't broken. We can
23 * change the "read" macros to use "dataLen" to avoid wandering into
24 * bad territory, and have a single "is dataLen correct" check at the
25 * end of each function. Not needed at this time.
26 */
27
28#include "atomic.h"
29#include "debugger.h"
30#include "jdwp/jdwp_priv.h"
31#include "jdwp/jdwp_handler.h"
32#include "jdwp/jdwp_event.h"
33#include "jdwp/jdwp_constants.h"
34#include "jdwp/jdwp_expand_buf.h"
35#include "logging.h"
36#include "macros.h"
37#include "stringprintf.h"
38
39#include <stdlib.h>
40#include <string.h>
41#include <unistd.h>
42
43namespace art {
44
45namespace JDWP {
46
47/*
48 * Helper function: read a "location" from an input buffer.
49 */
50static void jdwpReadLocation(const uint8_t** pBuf, JdwpLocation* pLoc) {
51 memset(pLoc, 0, sizeof(*pLoc)); /* allows memcmp() later */
Elliott Hughesd07986f2011-12-06 18:27:45 -080052 pLoc->typeTag = ReadTypeTag(pBuf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -070053 pLoc->classId = ReadObjectId(pBuf);
54 pLoc->methodId = ReadMethodId(pBuf);
Elliott Hughesf7c3b662011-10-27 12:04:56 -070055 pLoc->idx = Read8BE(pBuf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -070056}
57
58/*
59 * Helper function: write a "location" into the reply buffer.
60 */
61void AddLocation(ExpandBuf* pReply, const JdwpLocation* pLoc) {
62 expandBufAdd1(pReply, pLoc->typeTag);
63 expandBufAddObjectId(pReply, pLoc->classId);
64 expandBufAddMethodId(pReply, pLoc->methodId);
65 expandBufAdd8BE(pReply, pLoc->idx);
66}
67
68/*
69 * Helper function: read a variable-width value from the input buffer.
70 */
Elliott Hughesdbb40792011-11-18 17:05:22 -080071static uint64_t jdwpReadValue(const uint8_t** pBuf, size_t width) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -070072 uint64_t value = -1;
73 switch (width) {
Elliott Hughesf7c3b662011-10-27 12:04:56 -070074 case 1: value = Read1(pBuf); break;
75 case 2: value = Read2BE(pBuf); break;
76 case 4: value = Read4BE(pBuf); break;
77 case 8: value = Read8BE(pBuf); break;
Elliott Hughes872d4ec2011-10-21 17:07:15 -070078 default: LOG(FATAL) << width; break;
79 }
80 return value;
81}
82
83/*
84 * Helper function: write a variable-width value into the output input buffer.
85 */
86static void jdwpWriteValue(ExpandBuf* pReply, int width, uint64_t value) {
87 switch (width) {
88 case 1: expandBufAdd1(pReply, value); break;
89 case 2: expandBufAdd2BE(pReply, value); break;
90 case 4: expandBufAdd4BE(pReply, value); break;
91 case 8: expandBufAdd8BE(pReply, value); break;
92 default: LOG(FATAL) << width; break;
93 }
94}
95
96/*
97 * Common code for *_InvokeMethod requests.
98 *
99 * If "isConstructor" is set, this returns "objectId" rather than the
100 * expected-to-be-void return value of the called function.
101 */
102static JdwpError finishInvoke(JdwpState* state,
103 const uint8_t* buf, int dataLen, ExpandBuf* pReply,
104 ObjectId threadId, ObjectId objectId, RefTypeId classId, MethodId methodId,
105 bool isConstructor)
106{
107 CHECK(!isConstructor || objectId != 0);
108
Elliott Hughesf7c3b662011-10-27 12:04:56 -0700109 uint32_t numArgs = Read4BE(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700110
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800111 VLOG(jdwp) << StringPrintf(" --> threadId=%llx objectId=%llx", threadId, objectId);
112 VLOG(jdwp) << StringPrintf(" classId=%llx methodId=%x %s.%s", classId, methodId, Dbg::GetClassDescriptor(classId).c_str(), Dbg::GetMethodName(classId, methodId).c_str());
113 VLOG(jdwp) << StringPrintf(" %d args:", numArgs);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700114
115 uint64_t* argArray = NULL;
116 if (numArgs > 0) {
117 argArray = (ObjectId*) malloc(sizeof(ObjectId) * numArgs);
118 }
119
120 for (uint32_t i = 0; i < numArgs; i++) {
Elliott Hughesaed4be92011-12-02 16:16:23 -0800121 JDWP::JdwpTag typeTag = ReadTag(&buf);
Elliott Hughesdbb40792011-11-18 17:05:22 -0800122 size_t width = Dbg::GetTagWidth(typeTag);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700123 uint64_t value = jdwpReadValue(&buf, width);
124
Elliott Hughesabd04b92012-01-18 22:46:41 -0800125 VLOG(jdwp) << StringPrintf(" '%c'(%zd): 0x%llx", typeTag, width, value);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700126 argArray[i] = value;
127 }
128
Elliott Hughesf7c3b662011-10-27 12:04:56 -0700129 uint32_t options = Read4BE(&buf); /* enum InvokeOptions bit flags */
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800130 VLOG(jdwp) << StringPrintf(" options=0x%04x%s%s", options, (options & INVOKE_SINGLE_THREADED) ? " (SINGLE_THREADED)" : "", (options & INVOKE_NONVIRTUAL) ? " (NONVIRTUAL)" : "");
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700131
Elliott Hughesaed4be92011-12-02 16:16:23 -0800132 JDWP::JdwpTag resultTag;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700133 uint64_t resultValue;
134 ObjectId exceptObjId;
135 JdwpError err = Dbg::InvokeMethod(threadId, objectId, classId, methodId, numArgs, argArray, options, &resultTag, &resultValue, &exceptObjId);
136 if (err != ERR_NONE) {
137 goto bail;
138 }
139
140 if (err == ERR_NONE) {
141 if (isConstructor) {
142 expandBufAdd1(pReply, JT_OBJECT);
143 expandBufAddObjectId(pReply, objectId);
144 } else {
Elliott Hughesdbb40792011-11-18 17:05:22 -0800145 size_t width = Dbg::GetTagWidth(resultTag);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700146
147 expandBufAdd1(pReply, resultTag);
148 if (width != 0) {
149 jdwpWriteValue(pReply, width, resultValue);
150 }
151 }
152 expandBufAdd1(pReply, JT_OBJECT);
153 expandBufAddObjectId(pReply, exceptObjId);
154
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800155 VLOG(jdwp) << StringPrintf(" --> returned '%c' 0x%llx (except=%08llx)", resultTag, resultValue, exceptObjId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700156
157 /* show detailed debug output */
158 if (resultTag == JT_STRING && exceptObjId == 0) {
159 if (resultValue != 0) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800160 VLOG(jdwp) << " string '" << Dbg::StringToUtf8(resultValue) << "'";
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700161 } else {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800162 VLOG(jdwp) << " string (null)";
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700163 }
164 }
165 }
166
167bail:
168 free(argArray);
169 return err;
170}
171
172
173/*
174 * Request for version info.
175 */
176static JdwpError handleVM_Version(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
177 /* text information on runtime version */
178 std::string version(StringPrintf("Android Runtime %s", Runtime::Current()->GetVersion()));
Elliott Hughes4740cdf2011-12-07 14:07:12 -0800179 expandBufAddUtf8String(pReply, version);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700180 /* JDWP version numbers */
181 expandBufAdd4BE(pReply, 1); // major
182 expandBufAdd4BE(pReply, 5); // minor
183 /* VM JRE version */
Elliott Hughesa2155262011-11-16 16:26:58 -0800184 expandBufAddUtf8String(pReply, "1.6.0"); /* e.g. 1.6.0_22 */
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700185 /* target VM name */
Elliott Hughesa2155262011-11-16 16:26:58 -0800186 expandBufAddUtf8String(pReply, "DalvikVM");
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700187
188 return ERR_NONE;
189}
190
191/*
192 * Given a class JNI signature (e.g. "Ljava/lang/Error;"), return the
193 * referenceTypeID. We need to send back more than one if the class has
194 * been loaded by multiple class loaders.
195 */
196static JdwpError handleVM_ClassesBySignature(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800197 std::string classDescriptor(ReadNewUtf8String(&buf));
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800198 VLOG(jdwp) << " Req for class by signature '" << classDescriptor << "'";
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700199
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800200 std::vector<RefTypeId> ids;
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800201 Dbg::FindLoadedClassBySignature(classDescriptor.c_str(), ids);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700202
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800203 expandBufAdd4BE(pReply, ids.size());
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700204
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800205 for (size_t i = 0; i < ids.size(); ++i) {
206 // Get class vs. interface and status flags.
207 JDWP::JdwpTypeTag typeTag;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700208 uint32_t status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800209 if (!Dbg::GetClassInfo(ids[i], &typeTag, &status, NULL)) {
210 return ERR_INVALID_CLASS;
211 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700212
213 expandBufAdd1(pReply, typeTag);
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800214 expandBufAddRefTypeId(pReply, ids[i]);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700215 expandBufAdd4BE(pReply, status);
216 }
217
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700218 return ERR_NONE;
219}
220
221/*
222 * Handle request for the thread IDs of all running threads.
223 *
224 * We exclude ourselves from the list, because we don't allow ourselves
225 * to be suspended, and that violates some JDWP expectations.
226 */
227static JdwpError handleVM_AllThreads(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
228 ObjectId* pThreadIds;
229 uint32_t threadCount;
230 Dbg::GetAllThreads(&pThreadIds, &threadCount);
231
232 expandBufAdd4BE(pReply, threadCount);
233
234 ObjectId* walker = pThreadIds;
235 for (uint32_t i = 0; i < threadCount; i++) {
236 expandBufAddObjectId(pReply, *walker++);
237 }
238
239 free(pThreadIds);
240
241 return ERR_NONE;
242}
243
244/*
245 * List all thread groups that do not have a parent.
246 */
247static JdwpError handleVM_TopLevelThreadGroups(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
248 /*
249 * TODO: maintain a list of parentless thread groups in the VM.
250 *
251 * For now, just return "system". Application threads are created
252 * in "main", which is a child of "system".
253 */
254 uint32_t groups = 1;
255 expandBufAdd4BE(pReply, groups);
256 //threadGroupId = debugGetMainThreadGroup();
257 //expandBufAdd8BE(pReply, threadGroupId);
258 ObjectId threadGroupId = Dbg::GetSystemThreadGroupId();
259 expandBufAddObjectId(pReply, threadGroupId);
260
261 return ERR_NONE;
262}
263
264/*
265 * Respond with the sizes of the basic debugger types.
266 *
267 * All IDs are 8 bytes.
268 */
269static JdwpError handleVM_IDSizes(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
270 expandBufAdd4BE(pReply, sizeof(FieldId));
271 expandBufAdd4BE(pReply, sizeof(MethodId));
272 expandBufAdd4BE(pReply, sizeof(ObjectId));
273 expandBufAdd4BE(pReply, sizeof(RefTypeId));
274 expandBufAdd4BE(pReply, sizeof(FrameId));
275 return ERR_NONE;
276}
277
278/*
279 * The debugger is politely asking to disconnect. We're good with that.
280 *
281 * We could resume threads and clean up pinned references, but we can do
282 * that when the TCP connection drops.
283 */
284static JdwpError handleVM_Dispose(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
285 return ERR_NONE;
286}
287
288/*
289 * Suspend the execution of the application running in the VM (i.e. suspend
290 * all threads).
291 *
292 * This needs to increment the "suspend count" on all threads.
293 */
294static JdwpError handleVM_Suspend(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
Elliott Hughes475fc232011-10-25 15:00:35 -0700295 Dbg::SuspendVM();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700296 return ERR_NONE;
297}
298
299/*
300 * Resume execution. Decrements the "suspend count" of all threads.
301 */
302static JdwpError handleVM_Resume(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
303 Dbg::ResumeVM();
304 return ERR_NONE;
305}
306
307/*
308 * The debugger wants the entire VM to exit.
309 */
310static JdwpError handleVM_Exit(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
Elliott Hughesf7c3b662011-10-27 12:04:56 -0700311 uint32_t exitCode = Get4BE(buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700312
313 LOG(WARNING) << "Debugger is telling the VM to exit with code=" << exitCode;
314
315 Dbg::Exit(exitCode);
316 return ERR_NOT_IMPLEMENTED; // shouldn't get here
317}
318
319/*
320 * Create a new string in the VM and return its ID.
321 *
322 * (Ctrl-Shift-I in Eclipse on an array of objects causes it to create the
323 * string "java.util.Arrays".)
324 */
325static JdwpError handleVM_CreateString(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800326 std::string str(ReadNewUtf8String(&buf));
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800327 VLOG(jdwp) << " Req to create string '" << str << "'";
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700328 ObjectId stringId = Dbg::CreateString(str);
329 if (stringId == 0) {
330 return ERR_OUT_OF_MEMORY;
331 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700332 expandBufAddObjectId(pReply, stringId);
333 return ERR_NONE;
334}
335
336/*
337 * Tell the debugger what we are capable of.
338 */
339static JdwpError handleVM_Capabilities(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
340 expandBufAdd1(pReply, false); /* canWatchFieldModification */
341 expandBufAdd1(pReply, false); /* canWatchFieldAccess */
342 expandBufAdd1(pReply, false); /* canGetBytecodes */
343 expandBufAdd1(pReply, true); /* canGetSyntheticAttribute */
344 expandBufAdd1(pReply, false); /* canGetOwnedMonitorInfo */
345 expandBufAdd1(pReply, false); /* canGetCurrentContendedMonitor */
346 expandBufAdd1(pReply, false); /* canGetMonitorInfo */
347 return ERR_NONE;
348}
349
350/*
351 * Return classpath and bootclasspath.
352 */
353static JdwpError handleVM_ClassPaths(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
354 char baseDir[2] = "/";
355
356 /*
357 * TODO: make this real. Not important for remote debugging, but
358 * might be useful for local debugging.
359 */
360 uint32_t classPaths = 1;
361 uint32_t bootClassPaths = 0;
362
Elliott Hughesa2155262011-11-16 16:26:58 -0800363 expandBufAddUtf8String(pReply, baseDir);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700364 expandBufAdd4BE(pReply, classPaths);
365 for (uint32_t i = 0; i < classPaths; i++) {
Elliott Hughesa2155262011-11-16 16:26:58 -0800366 expandBufAddUtf8String(pReply, ".");
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700367 }
368
369 expandBufAdd4BE(pReply, bootClassPaths);
370 for (uint32_t i = 0; i < classPaths; i++) {
371 /* add bootclasspath components as strings */
372 }
373
374 return ERR_NONE;
375}
376
377/*
378 * Release a list of object IDs. (Seen in jdb.)
379 *
380 * Currently does nothing.
381 */
382static JdwpError HandleVM_DisposeObjects(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
383 return ERR_NONE;
384}
385
386/*
387 * Tell the debugger what we are capable of.
388 */
389static JdwpError handleVM_CapabilitiesNew(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
390 expandBufAdd1(pReply, false); /* canWatchFieldModification */
391 expandBufAdd1(pReply, false); /* canWatchFieldAccess */
392 expandBufAdd1(pReply, false); /* canGetBytecodes */
393 expandBufAdd1(pReply, true); /* canGetSyntheticAttribute */
394 expandBufAdd1(pReply, false); /* canGetOwnedMonitorInfo */
395 expandBufAdd1(pReply, false); /* canGetCurrentContendedMonitor */
396 expandBufAdd1(pReply, false); /* canGetMonitorInfo */
397 expandBufAdd1(pReply, false); /* canRedefineClasses */
398 expandBufAdd1(pReply, false); /* canAddMethod */
399 expandBufAdd1(pReply, false); /* canUnrestrictedlyRedefineClasses */
400 expandBufAdd1(pReply, false); /* canPopFrames */
401 expandBufAdd1(pReply, false); /* canUseInstanceFilters */
402 expandBufAdd1(pReply, false); /* canGetSourceDebugExtension */
403 expandBufAdd1(pReply, false); /* canRequestVMDeathEvent */
404 expandBufAdd1(pReply, false); /* canSetDefaultStratum */
405 expandBufAdd1(pReply, false); /* 1.6: canGetInstanceInfo */
406 expandBufAdd1(pReply, false); /* 1.6: canRequestMonitorEvents */
407 expandBufAdd1(pReply, false); /* 1.6: canGetMonitorFrameInfo */
408 expandBufAdd1(pReply, false); /* 1.6: canUseSourceNameFilters */
409 expandBufAdd1(pReply, false); /* 1.6: canGetConstantPool */
410 expandBufAdd1(pReply, false); /* 1.6: canForceEarlyReturn */
411
412 /* fill in reserved22 through reserved32; note count started at 1 */
413 for (int i = 22; i <= 32; i++) {
414 expandBufAdd1(pReply, false); /* reservedN */
415 }
416 return ERR_NONE;
417}
418
419/*
420 * Cough up the complete list of classes.
421 */
422static JdwpError handleVM_AllClassesWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800423 std::vector<JDWP::RefTypeId> classes;
424 Dbg::GetClassList(classes);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700425
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800426 expandBufAdd4BE(pReply, classes.size());
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700427
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800428 for (size_t i = 0; i < classes.size(); ++i) {
Elliott Hughesa2155262011-11-16 16:26:58 -0800429 static const char genericSignature[1] = "";
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800430 JDWP::JdwpTypeTag refTypeTag;
Elliott Hughesa2155262011-11-16 16:26:58 -0800431 std::string descriptor;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700432 uint32_t status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800433 if (!Dbg::GetClassInfo(classes[i], &refTypeTag, &status, &descriptor)) {
434 return ERR_INVALID_CLASS;
435 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700436
437 expandBufAdd1(pReply, refTypeTag);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800438 expandBufAddRefTypeId(pReply, classes[i]);
Elliott Hughes4740cdf2011-12-07 14:07:12 -0800439 expandBufAddUtf8String(pReply, descriptor);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700440 expandBufAddUtf8String(pReply, genericSignature);
441 expandBufAdd4BE(pReply, status);
442 }
443
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700444 return ERR_NONE;
445}
446
447/*
448 * Given a referenceTypeID, return a string with the JNI reference type
449 * signature (e.g. "Ljava/lang/Error;").
450 */
451static JdwpError handleRT_Signature(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
452 RefTypeId refTypeId = ReadRefTypeId(&buf);
453
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800454 VLOG(jdwp) << StringPrintf(" Req for signature of refTypeId=0x%llx", refTypeId);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800455 std::string signature;
456 if (!Dbg::GetSignature(refTypeId, signature)) {
457 return ERR_INVALID_CLASS;
458 }
Elliott Hughes4740cdf2011-12-07 14:07:12 -0800459 expandBufAddUtf8String(pReply, signature);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700460 return ERR_NONE;
461}
462
463/*
464 * Return the modifiers (a/k/a access flags) for a reference type.
465 */
466static JdwpError handleRT_Modifiers(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
467 RefTypeId refTypeId = ReadRefTypeId(&buf);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800468 uint32_t access_flags;
469 if (!Dbg::GetAccessFlags(refTypeId, access_flags)) {
470 return ERR_INVALID_CLASS;
471 }
472 expandBufAdd4BE(pReply, access_flags);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700473 return ERR_NONE;
474}
475
476/*
477 * Get values from static fields in a reference type.
478 */
479static JdwpError handleRT_GetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800480 ReadRefTypeId(&buf); // We don't need this, but we need to skip over it in the request.
Elliott Hughesf7c3b662011-10-27 12:04:56 -0700481 uint32_t numFields = Read4BE(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700482
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800483 VLOG(jdwp) << " RT_GetValues " << numFields << ":";
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700484
485 expandBufAdd4BE(pReply, numFields);
486 for (uint32_t i = 0; i < numFields; i++) {
487 FieldId fieldId = ReadFieldId(&buf);
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800488 Dbg::GetStaticFieldValue(fieldId, pReply);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700489 }
490
491 return ERR_NONE;
492}
493
494/*
495 * Get the name of the source file in which a reference type was declared.
496 */
497static JdwpError handleRT_SourceFile(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
498 RefTypeId refTypeId = ReadRefTypeId(&buf);
Elliott Hughes03181a82011-11-17 17:22:21 -0800499 std::string source_file;
500 if (!Dbg::GetSourceFile(refTypeId, source_file)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700501 return ERR_ABSENT_INFORMATION;
502 }
Elliott Hughes4740cdf2011-12-07 14:07:12 -0800503 expandBufAddUtf8String(pReply, source_file);
Elliott Hughes03181a82011-11-17 17:22:21 -0800504 return ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700505}
506
507/*
508 * Return the current status of the reference type.
509 */
510static JdwpError handleRT_Status(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
511 RefTypeId refTypeId = ReadRefTypeId(&buf);
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800512 JDWP::JdwpTypeTag typeTag;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700513 uint32_t status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800514 if (!Dbg::GetClassInfo(refTypeId, &typeTag, &status, NULL)) {
515 return ERR_INVALID_CLASS;
516 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700517 expandBufAdd4BE(pReply, status);
518 return ERR_NONE;
519}
520
521/*
522 * Return interfaces implemented directly by this class.
523 */
524static JdwpError handleRT_Interfaces(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
525 RefTypeId refTypeId = ReadRefTypeId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800526 VLOG(jdwp) << StringPrintf(" Req for interfaces in %llx (%s)", refTypeId, Dbg::GetClassDescriptor(refTypeId).c_str());
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800527 return Dbg::OutputDeclaredInterfaces(refTypeId, pReply) ? ERR_NONE : ERR_INVALID_CLASS;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700528}
529
530/*
531 * Return the class object corresponding to this type.
532 */
533static JdwpError handleRT_ClassObject(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
534 RefTypeId refTypeId = ReadRefTypeId(&buf);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800535 ObjectId classObjectId;
536 if (!Dbg::GetClassObject(refTypeId, classObjectId)) {
537 return ERR_INVALID_CLASS;
538 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800539 VLOG(jdwp) << StringPrintf(" RefTypeId %llx -> ObjectId %llx", refTypeId, classObjectId);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800540 expandBufAddObjectId(pReply, classObjectId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700541 return ERR_NONE;
542}
543
544/*
545 * Returns the value of the SourceDebugExtension attribute.
546 *
547 * JDB seems interested, but DEX files don't currently support this.
548 */
549static JdwpError handleRT_SourceDebugExtension(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
550 /* referenceTypeId in, string out */
551 return ERR_ABSENT_INFORMATION;
552}
553
554/*
555 * Like RT_Signature but with the possibility of a "generic signature".
556 */
557static JdwpError handleRT_SignatureWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
Elliott Hughesa2155262011-11-16 16:26:58 -0800558 static const char genericSignature[1] = "";
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700559
560 RefTypeId refTypeId = ReadRefTypeId(&buf);
561
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800562 VLOG(jdwp) << StringPrintf(" Req for signature of refTypeId=0x%llx", refTypeId);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800563 std::string signature;
564 if (Dbg::GetSignature(refTypeId, signature)) {
Elliott Hughes4740cdf2011-12-07 14:07:12 -0800565 expandBufAddUtf8String(pReply, signature);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700566 } else {
567 LOG(WARNING) << StringPrintf("No signature for refTypeId=0x%llx", refTypeId);
Elliott Hughesa2155262011-11-16 16:26:58 -0800568 expandBufAddUtf8String(pReply, "Lunknown;");
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700569 }
570 expandBufAddUtf8String(pReply, genericSignature);
571
572 return ERR_NONE;
573}
574
575/*
576 * Return the instance of java.lang.ClassLoader that loaded the specified
577 * reference type, or null if it was loaded by the system loader.
578 */
579static JdwpError handleRT_ClassLoader(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
580 RefTypeId refTypeId = ReadRefTypeId(&buf);
581
582 expandBufAddObjectId(pReply, Dbg::GetClassLoader(refTypeId));
583
584 return ERR_NONE;
585}
586
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800587static std::string Describe(const RefTypeId& refTypeId) {
588 std::string signature("unknown");
589 Dbg::GetSignature(refTypeId, signature);
590 return StringPrintf("refTypeId=0x%llx (%s)", refTypeId, signature.c_str());
591}
592
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700593/*
594 * Given a referenceTypeId, return a block of stuff that describes the
595 * fields declared by a class.
596 */
597static JdwpError handleRT_FieldsWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
598 RefTypeId refTypeId = ReadRefTypeId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800599 VLOG(jdwp) << " Req for fields in " << Describe(refTypeId);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800600 return Dbg::OutputDeclaredFields(refTypeId, true, pReply) ? ERR_NONE : ERR_INVALID_CLASS;
601}
602
603// Obsolete equivalent of FieldsWithGeneric, without the generic type information.
604static JdwpError handleRT_Fields(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
605 RefTypeId refTypeId = ReadRefTypeId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800606 VLOG(jdwp) << " Req for fields in " << Describe(refTypeId);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800607 return Dbg::OutputDeclaredFields(refTypeId, false, pReply) ? ERR_NONE : ERR_INVALID_CLASS;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700608}
609
610/*
611 * Given a referenceTypeID, return a block of goodies describing the
612 * methods declared by a class.
613 */
614static JdwpError handleRT_MethodsWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
615 RefTypeId refTypeId = ReadRefTypeId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800616 VLOG(jdwp) << " Req for methods in " << Describe(refTypeId);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800617 return Dbg::OutputDeclaredMethods(refTypeId, true, pReply) ? ERR_NONE : ERR_INVALID_CLASS;
618}
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700619
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800620// Obsolete equivalent of MethodsWithGeneric, without the generic type information.
621static JdwpError handleRT_Methods(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
622 RefTypeId refTypeId = ReadRefTypeId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800623 VLOG(jdwp) << " Req for methods in " << Describe(refTypeId);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800624 return Dbg::OutputDeclaredMethods(refTypeId, false, pReply) ? ERR_NONE : ERR_INVALID_CLASS;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700625}
626
627/*
628 * Return the immediate superclass of a class.
629 */
630static JdwpError handleCT_Superclass(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
631 RefTypeId classId = ReadRefTypeId(&buf);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800632 RefTypeId superClassId;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800633 JdwpError status = Dbg::GetSuperclass(classId, superClassId);
634 if (status != ERR_NONE) {
635 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800636 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700637 expandBufAddRefTypeId(pReply, superClassId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700638 return ERR_NONE;
639}
640
641/*
642 * Set static class values.
643 */
644static JdwpError handleCT_SetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
645 RefTypeId classId = ReadRefTypeId(&buf);
Elliott Hughesf7c3b662011-10-27 12:04:56 -0700646 uint32_t values = Read4BE(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700647
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800648 VLOG(jdwp) << StringPrintf(" Req to set %d values in classId=%llx", values, classId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700649
650 for (uint32_t i = 0; i < values; i++) {
651 FieldId fieldId = ReadFieldId(&buf);
Elliott Hughesaed4be92011-12-02 16:16:23 -0800652 JDWP::JdwpTag fieldTag = Dbg::GetStaticFieldBasicTag(fieldId);
Elliott Hughesdbb40792011-11-18 17:05:22 -0800653 size_t width = Dbg::GetTagWidth(fieldTag);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700654 uint64_t value = jdwpReadValue(&buf, width);
655
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800656 VLOG(jdwp) << StringPrintf(" --> field=%x tag=%c -> %lld", fieldId, fieldTag, value);
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800657 JdwpError status = Dbg::SetStaticFieldValue(fieldId, value, width);
658 if (status != ERR_NONE) {
659 return status;
660 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700661 }
662
663 return ERR_NONE;
664}
665
666/*
667 * Invoke a static method.
668 *
669 * Example: Eclipse sometimes uses java/lang/Class.forName(String s) on
670 * values in the "variables" display.
671 */
672static JdwpError handleCT_InvokeMethod(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
673 RefTypeId classId = ReadRefTypeId(&buf);
674 ObjectId threadId = ReadObjectId(&buf);
675 MethodId methodId = ReadMethodId(&buf);
676
677 return finishInvoke(state, buf, dataLen, pReply, threadId, 0, classId, methodId, false);
678}
679
680/*
681 * Create a new object of the requested type, and invoke the specified
682 * constructor.
683 *
684 * Example: in IntelliJ, create a watch on "new String(myByteArray)" to
685 * see the contents of a byte[] as a string.
686 */
687static JdwpError handleCT_NewInstance(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
688 RefTypeId classId = ReadRefTypeId(&buf);
689 ObjectId threadId = ReadObjectId(&buf);
690 MethodId methodId = ReadMethodId(&buf);
691
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800692 VLOG(jdwp) << "Creating instance of " << Dbg::GetClassDescriptor(classId);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800693 ObjectId objectId;
694 if (!Dbg::CreateObject(classId, objectId)) {
695 return ERR_INVALID_CLASS;
696 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700697 if (objectId == 0) {
698 return ERR_OUT_OF_MEMORY;
699 }
700 return finishInvoke(state, buf, dataLen, pReply, threadId, objectId, classId, methodId, true);
701}
702
703/*
704 * Create a new array object of the requested type and length.
705 */
706static JdwpError handleAT_newInstance(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
707 RefTypeId arrayTypeId = ReadRefTypeId(&buf);
Elliott Hughesf7c3b662011-10-27 12:04:56 -0700708 uint32_t length = Read4BE(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700709
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800710 VLOG(jdwp) << StringPrintf("Creating array %s[%u]", Dbg::GetClassDescriptor(arrayTypeId).c_str(), length);
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800711 ObjectId objectId;
712 if (!Dbg::CreateArrayObject(arrayTypeId, length, objectId)) {
713 return ERR_INVALID_CLASS;
714 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700715 if (objectId == 0) {
716 return ERR_OUT_OF_MEMORY;
717 }
718 expandBufAdd1(pReply, JT_ARRAY);
719 expandBufAddObjectId(pReply, objectId);
720 return ERR_NONE;
721}
722
723/*
724 * Return line number information for the method, if present.
725 */
726static JdwpError handleM_LineTable(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
727 RefTypeId refTypeId = ReadRefTypeId(&buf);
728 MethodId methodId = ReadMethodId(&buf);
729
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800730 VLOG(jdwp) << StringPrintf(" Req for line table in %s.%s", Dbg::GetClassDescriptor(refTypeId).c_str(), Dbg::GetMethodName(refTypeId,methodId).c_str());
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700731
732 Dbg::OutputLineTable(refTypeId, methodId, pReply);
733
734 return ERR_NONE;
735}
736
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800737static JdwpError handleM_VariableTable(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply, bool generic) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700738 RefTypeId classId = ReadRefTypeId(&buf);
739 MethodId methodId = ReadMethodId(&buf);
740
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800741 VLOG(jdwp) << StringPrintf(" Req for LocalVarTab in class=%s method=%s", Dbg::GetClassDescriptor(classId).c_str(), Dbg::GetMethodName(classId, methodId).c_str());
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700742
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800743 // We could return ERR_ABSENT_INFORMATION here if the DEX file was built without local variable
744 // information. That will cause Eclipse to make a best-effort attempt at displaying local
745 // variables anonymously. However, the attempt isn't very good, so we're probably better off just
746 // not showing anything.
747 Dbg::OutputVariableTable(classId, methodId, generic, pReply);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700748 return ERR_NONE;
749}
750
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800751static JdwpError handleM_VariableTable(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
752 return handleM_VariableTable(state, buf, dataLen, pReply, false);
753}
754
755static JdwpError handleM_VariableTableWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
756 return handleM_VariableTable(state, buf, dataLen, pReply, true);
757}
758
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700759/*
760 * Given an object reference, return the runtime type of the object
761 * (class or array).
762 *
763 * This can get called on different things, e.g. threadId gets
764 * passed in here.
765 */
766static JdwpError handleOR_ReferenceType(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
767 ObjectId objectId = ReadObjectId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800768 VLOG(jdwp) << StringPrintf(" Req for type of objectId=0x%llx", objectId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700769
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800770 JDWP::JdwpTypeTag refTypeTag;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700771 RefTypeId typeId;
772 Dbg::GetObjectType(objectId, &refTypeTag, &typeId);
773
774 expandBufAdd1(pReply, refTypeTag);
775 expandBufAddRefTypeId(pReply, typeId);
776
777 return ERR_NONE;
778}
779
780/*
781 * Get values from the fields of an object.
782 */
783static JdwpError handleOR_GetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
784 ObjectId objectId = ReadObjectId(&buf);
Elliott Hughesf7c3b662011-10-27 12:04:56 -0700785 uint32_t numFields = Read4BE(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700786
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800787 VLOG(jdwp) << StringPrintf(" Req for %d fields from objectId=0x%llx", numFields, objectId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700788
789 expandBufAdd4BE(pReply, numFields);
790
791 for (uint32_t i = 0; i < numFields; i++) {
792 FieldId fieldId = ReadFieldId(&buf);
793 Dbg::GetFieldValue(objectId, fieldId, pReply);
794 }
795
796 return ERR_NONE;
797}
798
799/*
800 * Set values in the fields of an object.
801 */
802static JdwpError handleOR_SetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
803 ObjectId objectId = ReadObjectId(&buf);
Elliott Hughesf7c3b662011-10-27 12:04:56 -0700804 uint32_t numFields = Read4BE(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700805
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800806 VLOG(jdwp) << StringPrintf(" Req to set %d fields in objectId=0x%llx", numFields, objectId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700807
808 for (uint32_t i = 0; i < numFields; i++) {
809 FieldId fieldId = ReadFieldId(&buf);
810
Elliott Hughesaed4be92011-12-02 16:16:23 -0800811 JDWP::JdwpTag fieldTag = Dbg::GetFieldBasicTag(fieldId);
Elliott Hughesdbb40792011-11-18 17:05:22 -0800812 size_t width = Dbg::GetTagWidth(fieldTag);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700813 uint64_t value = jdwpReadValue(&buf, width);
814
Elliott Hughesabd04b92012-01-18 22:46:41 -0800815 VLOG(jdwp) << StringPrintf(" --> fieldId=%x tag='%c'(%zd) value=%lld", fieldId, fieldTag, width, value);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700816
817 Dbg::SetFieldValue(objectId, fieldId, value, width);
818 }
819
820 return ERR_NONE;
821}
822
823/*
824 * Invoke an instance method. The invocation must occur in the specified
825 * thread, which must have been suspended by an event.
826 *
827 * The call is synchronous. All threads in the VM are resumed, unless the
828 * SINGLE_THREADED flag is set.
829 *
830 * If you ask Eclipse to "inspect" an object (or ask JDB to "print" an
831 * object), it will try to invoke the object's toString() function. This
832 * feature becomes crucial when examining ArrayLists with Eclipse.
833 */
834static JdwpError handleOR_InvokeMethod(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
835 ObjectId objectId = ReadObjectId(&buf);
836 ObjectId threadId = ReadObjectId(&buf);
837 RefTypeId classId = ReadRefTypeId(&buf);
838 MethodId methodId = ReadMethodId(&buf);
839
840 return finishInvoke(state, buf, dataLen, pReply, threadId, objectId, classId, methodId, false);
841}
842
843/*
844 * Disable garbage collection of the specified object.
845 */
846static JdwpError handleOR_DisableCollection(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
847 // this is currently a no-op
848 return ERR_NONE;
849}
850
851/*
852 * Enable garbage collection of the specified object.
853 */
854static JdwpError handleOR_EnableCollection(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
855 // this is currently a no-op
856 return ERR_NONE;
857}
858
859/*
860 * Determine whether an object has been garbage collected.
861 */
862static JdwpError handleOR_IsCollected(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
863 ObjectId objectId;
864
865 objectId = ReadObjectId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800866 VLOG(jdwp) << StringPrintf(" Req IsCollected(0x%llx)", objectId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700867
868 // TODO: currently returning false; must integrate with GC
869 expandBufAdd1(pReply, 0);
870
871 return ERR_NONE;
872}
873
874/*
875 * Return the string value in a string object.
876 */
877static JdwpError handleSR_Value(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
878 ObjectId stringObject = ReadObjectId(&buf);
Elliott Hughes68fdbd02011-11-29 19:22:47 -0800879 std::string str(Dbg::StringToUtf8(stringObject));
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700880
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800881 VLOG(jdwp) << StringPrintf(" Req for str %llx --> '%s'", stringObject, PrintableString(str).c_str());
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700882
Elliott Hughes4740cdf2011-12-07 14:07:12 -0800883 expandBufAddUtf8String(pReply, str);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700884
885 return ERR_NONE;
886}
887
888/*
889 * Return a thread's name.
890 */
891static JdwpError handleTR_Name(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
892 ObjectId threadId = ReadObjectId(&buf);
893
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800894 VLOG(jdwp) << StringPrintf(" Req for name of thread 0x%llx", threadId);
Elliott Hughesa2e54f62011-11-17 13:01:30 -0800895 std::string name;
896 if (!Dbg::GetThreadName(threadId, name)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700897 return ERR_INVALID_THREAD;
898 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800899 VLOG(jdwp) << StringPrintf(" Name of thread 0x%llx is \"%s\"", threadId, name.c_str());
Elliott Hughes4740cdf2011-12-07 14:07:12 -0800900 expandBufAddUtf8String(pReply, name);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700901
902 return ERR_NONE;
903}
904
905/*
906 * Suspend the specified thread.
907 *
908 * It's supposed to remain suspended even if interpreted code wants to
909 * resume it; only the JDI is allowed to resume it.
910 */
911static JdwpError handleTR_Suspend(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
912 ObjectId threadId = ReadObjectId(&buf);
913
914 if (threadId == Dbg::GetThreadSelfId()) {
915 LOG(INFO) << " Warning: ignoring request to suspend self";
916 return ERR_THREAD_NOT_SUSPENDED;
917 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800918 VLOG(jdwp) << StringPrintf(" Req to suspend thread 0x%llx", threadId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700919 Dbg::SuspendThread(threadId);
920 return ERR_NONE;
921}
922
923/*
924 * Resume the specified thread.
925 */
926static JdwpError handleTR_Resume(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
927 ObjectId threadId = ReadObjectId(&buf);
928
929 if (threadId == Dbg::GetThreadSelfId()) {
930 LOG(INFO) << " Warning: ignoring request to resume self";
931 return ERR_NONE;
932 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800933 VLOG(jdwp) << StringPrintf(" Req to resume thread 0x%llx", threadId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700934 Dbg::ResumeThread(threadId);
935 return ERR_NONE;
936}
937
938/*
939 * Return status of specified thread.
940 */
941static JdwpError handleTR_Status(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
942 ObjectId threadId = ReadObjectId(&buf);
943
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800944 VLOG(jdwp) << StringPrintf(" Req for status of thread 0x%llx", threadId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700945
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800946 JDWP::JdwpThreadStatus threadStatus;
947 JDWP::JdwpSuspendStatus suspendStatus;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700948 if (!Dbg::GetThreadStatus(threadId, &threadStatus, &suspendStatus)) {
949 return ERR_INVALID_THREAD;
950 }
951
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800952 VLOG(jdwp) << " --> " << threadStatus << ", " << suspendStatus;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700953
954 expandBufAdd4BE(pReply, threadStatus);
955 expandBufAdd4BE(pReply, suspendStatus);
956
957 return ERR_NONE;
958}
959
960/*
961 * Return the thread group that the specified thread is a member of.
962 */
963static JdwpError handleTR_ThreadGroup(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
964 ObjectId threadId = ReadObjectId(&buf);
965
966 /* currently not handling these */
967 ObjectId threadGroupId = Dbg::GetThreadGroup(threadId);
968 expandBufAddObjectId(pReply, threadGroupId);
969
970 return ERR_NONE;
971}
972
973/*
974 * Return the current call stack of a suspended thread.
975 *
976 * If the thread isn't suspended, the error code isn't defined, but should
977 * be THREAD_NOT_SUSPENDED.
978 */
979static JdwpError handleTR_Frames(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
980 ObjectId threadId = ReadObjectId(&buf);
Elliott Hughesf7c3b662011-10-27 12:04:56 -0700981 uint32_t startFrame = Read4BE(&buf);
982 uint32_t length = Read4BE(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700983
984 if (!Dbg::ThreadExists(threadId)) {
985 return ERR_INVALID_THREAD;
986 }
987 if (!Dbg::IsSuspended(threadId)) {
Elliott Hughesa2e54f62011-11-17 13:01:30 -0800988 LOG(WARNING) << StringPrintf(" Rejecting req for frames in running thread %llx", threadId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700989 return ERR_THREAD_NOT_SUSPENDED;
990 }
991
Elliott Hughes761928d2011-11-16 18:33:03 -0800992 size_t frameCount = Dbg::GetThreadFrameCount(threadId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700993
Elliott Hughesabd04b92012-01-18 22:46:41 -0800994 VLOG(jdwp) << StringPrintf(" Request for frames: threadId=%llx start=%d length=%d [count=%zd]", threadId, startFrame, length, frameCount);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700995 if (frameCount <= 0) {
996 return ERR_THREAD_NOT_SUSPENDED; /* == 0 means 100% native */
997 }
998 if (length == (uint32_t) -1) {
999 length = frameCount;
1000 }
Elliott Hughes761928d2011-11-16 18:33:03 -08001001 CHECK_GE(startFrame, 0U);
1002 CHECK_LT(startFrame, frameCount);
1003 CHECK_LE(startFrame + length, frameCount);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001004
1005 uint32_t frames = length;
1006 expandBufAdd4BE(pReply, frames);
1007 for (uint32_t i = startFrame; i < (startFrame+length); i++) {
1008 FrameId frameId;
1009 JdwpLocation loc;
1010
1011 Dbg::GetThreadFrame(threadId, i, &frameId, &loc);
1012
1013 expandBufAdd8BE(pReply, frameId);
1014 AddLocation(pReply, &loc);
1015
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001016 VLOG(jdwp) << StringPrintf(" Frame %d: id=%llx loc={type=%d cls=%llx mth=%x loc=%llx}", i, frameId, loc.typeTag, loc.classId, loc.methodId, loc.idx);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001017 }
1018
1019 return ERR_NONE;
1020}
1021
1022/*
1023 * Returns the #of frames on the specified thread, which must be suspended.
1024 */
1025static JdwpError handleTR_FrameCount(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1026 ObjectId threadId = ReadObjectId(&buf);
1027
1028 if (!Dbg::ThreadExists(threadId)) {
1029 return ERR_INVALID_THREAD;
1030 }
1031 if (!Dbg::IsSuspended(threadId)) {
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001032 LOG(WARNING) << StringPrintf(" Rejecting req for frames in running thread %llx", threadId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001033 return ERR_THREAD_NOT_SUSPENDED;
1034 }
1035
1036 int frameCount = Dbg::GetThreadFrameCount(threadId);
1037 if (frameCount < 0) {
1038 return ERR_INVALID_THREAD;
1039 }
1040 expandBufAdd4BE(pReply, (uint32_t)frameCount);
1041
1042 return ERR_NONE;
1043}
1044
1045/*
1046 * Get the monitor that the thread is waiting on.
1047 */
1048static JdwpError handleTR_CurrentContendedMonitor(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1049 ObjectId threadId;
1050
1051 threadId = ReadObjectId(&buf);
1052
1053 // TODO: create an Object to represent the monitor (we're currently
1054 // just using a raw Monitor struct in the VM)
1055
1056 return ERR_NOT_IMPLEMENTED;
1057}
1058
1059/*
1060 * Return the suspend count for the specified thread.
1061 *
1062 * (The thread *might* still be running -- it might not have examined
1063 * its suspend count recently.)
1064 */
1065static JdwpError handleTR_SuspendCount(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1066 ObjectId threadId = ReadObjectId(&buf);
1067
1068 uint32_t suspendCount = Dbg::GetThreadSuspendCount(threadId);
1069 expandBufAdd4BE(pReply, suspendCount);
1070
1071 return ERR_NONE;
1072}
1073
1074/*
1075 * Return the name of a thread group.
1076 *
1077 * The Eclipse debugger recognizes "main" and "system" as special.
1078 */
1079static JdwpError handleTGR_Name(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1080 ObjectId threadGroupId = ReadObjectId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001081 VLOG(jdwp) << StringPrintf(" Req for name of threadGroupId=0x%llx", threadGroupId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001082
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001083 expandBufAddUtf8String(pReply, Dbg::GetThreadGroupName(threadGroupId));
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001084
1085 return ERR_NONE;
1086}
1087
1088/*
1089 * Returns the thread group -- if any -- that contains the specified
1090 * thread group.
1091 */
1092static JdwpError handleTGR_Parent(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1093 ObjectId groupId = ReadObjectId(&buf);
1094
1095 ObjectId parentGroup = Dbg::GetThreadGroupParent(groupId);
1096 expandBufAddObjectId(pReply, parentGroup);
1097
1098 return ERR_NONE;
1099}
1100
1101/*
1102 * Return the active threads and thread groups that are part of the
1103 * specified thread group.
1104 */
1105static JdwpError handleTGR_Children(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1106 ObjectId threadGroupId = ReadObjectId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001107 VLOG(jdwp) << StringPrintf(" Req for threads in threadGroupId=0x%llx", threadGroupId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001108
1109 ObjectId* pThreadIds;
1110 uint32_t threadCount;
1111 Dbg::GetThreadGroupThreads(threadGroupId, &pThreadIds, &threadCount);
1112
1113 expandBufAdd4BE(pReply, threadCount);
1114
1115 for (uint32_t i = 0; i < threadCount; i++) {
1116 expandBufAddObjectId(pReply, pThreadIds[i]);
1117 }
1118 free(pThreadIds);
1119
1120 /*
1121 * TODO: finish support for child groups
1122 *
1123 * For now, just show that "main" is a child of "system".
1124 */
1125 if (threadGroupId == Dbg::GetSystemThreadGroupId()) {
1126 expandBufAdd4BE(pReply, 1);
1127 expandBufAddObjectId(pReply, Dbg::GetMainThreadGroupId());
1128 } else {
1129 expandBufAdd4BE(pReply, 0);
1130 }
1131
1132 return ERR_NONE;
1133}
1134
1135/*
1136 * Return the #of components in the array.
1137 */
1138static JdwpError handleAR_Length(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1139 ObjectId arrayId = ReadObjectId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001140 VLOG(jdwp) << StringPrintf(" Req for length of array 0x%llx", arrayId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001141
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001142 int length;
1143 JdwpError status = Dbg::GetArrayLength(arrayId, length);
1144 if (status != ERR_NONE) {
1145 return status;
1146 }
1147 VLOG(jdwp) << StringPrintf(" --> %d", length);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001148
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001149 expandBufAdd4BE(pReply, length);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001150
1151 return ERR_NONE;
1152}
1153
1154/*
1155 * Return the values from an array.
1156 */
1157static JdwpError handleAR_GetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1158 ObjectId arrayId = ReadObjectId(&buf);
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001159 uint32_t firstIndex = Read4BE(&buf);
1160 uint32_t length = Read4BE(&buf);
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001161 VLOG(jdwp) << StringPrintf(" Req for array values 0x%llx first=%d len=%d", arrayId, firstIndex, length);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001162
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001163 return Dbg::OutputArray(arrayId, firstIndex, length, pReply);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001164}
1165
1166/*
1167 * Set values in an array.
1168 */
1169static JdwpError handleAR_SetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1170 ObjectId arrayId = ReadObjectId(&buf);
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001171 uint32_t firstIndex = Read4BE(&buf);
1172 uint32_t values = Read4BE(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001173
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001174 VLOG(jdwp) << StringPrintf(" Req to set array values 0x%llx first=%d count=%d", arrayId, firstIndex, values);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001175
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001176 return Dbg::SetArrayElements(arrayId, firstIndex, values, buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001177}
1178
1179/*
1180 * Return the set of classes visible to a class loader. All classes which
1181 * have the class loader as a defining or initiating loader are returned.
1182 */
1183static JdwpError handleCLR_VisibleClasses(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1184 ObjectId classLoaderObject;
1185 uint32_t numClasses = 0;
1186 RefTypeId* classRefBuf = NULL;
1187 int i;
1188
1189 classLoaderObject = ReadObjectId(&buf);
1190
1191 Dbg::GetVisibleClassList(classLoaderObject, &numClasses, &classRefBuf);
1192
1193 expandBufAdd4BE(pReply, numClasses);
1194 for (i = 0; i < (int) numClasses; i++) {
1195 uint8_t refTypeTag = Dbg::GetClassObjectType(classRefBuf[i]);
1196
1197 expandBufAdd1(pReply, refTypeTag);
1198 expandBufAddRefTypeId(pReply, classRefBuf[i]);
1199 }
1200
1201 return ERR_NONE;
1202}
1203
1204/*
1205 * Return a newly-allocated string in which all occurrences of '.' have
1206 * been changed to '/'. If we find a '/' in the original string, NULL
1207 * is returned to avoid ambiguity.
1208 */
1209char* dvmDotToSlash(const char* str) {
1210 char* newStr = strdup(str);
1211 char* cp = newStr;
1212
1213 if (newStr == NULL) {
1214 return NULL;
1215 }
1216
1217 while (*cp != '\0') {
1218 if (*cp == '/') {
1219 CHECK(false);
1220 return NULL;
1221 }
1222 if (*cp == '.') {
1223 *cp = '/';
1224 }
1225 cp++;
1226 }
1227
1228 return newStr;
1229}
1230
1231/*
1232 * Set an event trigger.
1233 *
1234 * Reply with a requestID.
1235 */
1236static JdwpError handleER_Set(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1237 const uint8_t* origBuf = buf;
1238
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001239 uint8_t eventKind = Read1(&buf);
1240 uint8_t suspendPolicy = Read1(&buf);
1241 uint32_t modifierCount = Read4BE(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001242
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001243 VLOG(jdwp) << " Set(kind=" << JdwpEventKind(eventKind)
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001244 << " suspend=" << JdwpSuspendPolicy(suspendPolicy)
1245 << " mods=" << modifierCount << ")";
1246
1247 CHECK_LT(modifierCount, 256U); /* reasonableness check */
1248
1249 JdwpEvent* pEvent = EventAlloc(modifierCount);
1250 pEvent->eventKind = static_cast<JdwpEventKind>(eventKind);
1251 pEvent->suspendPolicy = static_cast<JdwpSuspendPolicy>(suspendPolicy);
1252 pEvent->modCount = modifierCount;
1253
1254 /*
1255 * Read modifiers. Ordering may be significant (see explanation of Count
1256 * mods in JDWP doc).
1257 */
1258 for (uint32_t idx = 0; idx < modifierCount; idx++) {
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001259 JdwpModKind modKind = static_cast<JdwpModKind>(Read1(&buf));
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001260
1261 pEvent->mods[idx].modKind = modKind;
1262
1263 switch (modKind) {
1264 case MK_COUNT: /* report once, when "--count" reaches 0 */
1265 {
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001266 uint32_t count = Read4BE(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001267 VLOG(jdwp) << " Count: " << count;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001268 if (count == 0) {
1269 return ERR_INVALID_COUNT;
1270 }
1271 pEvent->mods[idx].count.count = count;
1272 }
1273 break;
1274 case MK_CONDITIONAL: /* conditional on expression) */
1275 {
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001276 uint32_t exprId = Read4BE(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001277 VLOG(jdwp) << " Conditional: " << exprId;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001278 pEvent->mods[idx].conditional.exprId = exprId;
1279 }
1280 break;
1281 case MK_THREAD_ONLY: /* only report events in specified thread */
1282 {
1283 ObjectId threadId = ReadObjectId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001284 VLOG(jdwp) << StringPrintf(" ThreadOnly: %llx", threadId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001285 pEvent->mods[idx].threadOnly.threadId = threadId;
1286 }
1287 break;
1288 case MK_CLASS_ONLY: /* for ClassPrepare, MethodEntry */
1289 {
1290 RefTypeId clazzId = ReadRefTypeId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001291 VLOG(jdwp) << StringPrintf(" ClassOnly: %llx (%s)", clazzId, Dbg::GetClassDescriptor(clazzId).c_str());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001292 pEvent->mods[idx].classOnly.refTypeId = clazzId;
1293 }
1294 break;
1295 case MK_CLASS_MATCH: /* restrict events to matching classes */
1296 {
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001297 std::string pattern(ReadNewUtf8String(&buf));
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001298 VLOG(jdwp) << StringPrintf(" ClassMatch: '%s'", pattern.c_str());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001299 /* pattern is "java.foo.*", we want "java/foo/ *" */
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001300 pEvent->mods[idx].classMatch.classPattern = dvmDotToSlash(pattern.c_str());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001301 }
1302 break;
1303 case MK_CLASS_EXCLUDE: /* restrict events to non-matching classes */
1304 {
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001305 std::string pattern(ReadNewUtf8String(&buf));
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001306 VLOG(jdwp) << StringPrintf(" ClassExclude: '%s'", pattern.c_str());
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001307 pEvent->mods[idx].classExclude.classPattern = dvmDotToSlash(pattern.c_str());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001308 }
1309 break;
1310 case MK_LOCATION_ONLY: /* restrict certain events based on loc */
1311 {
1312 JdwpLocation loc;
1313
1314 jdwpReadLocation(&buf, &loc);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001315 VLOG(jdwp) << StringPrintf(" LocationOnly: typeTag=%d classId=%llx methodId=%x idx=%llx",
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001316 loc.typeTag, loc.classId, loc.methodId, loc.idx);
1317 pEvent->mods[idx].locationOnly.loc = loc;
1318 }
1319 break;
1320 case MK_EXCEPTION_ONLY: /* modifies EK_EXCEPTION events */
1321 {
1322 RefTypeId exceptionOrNull; /* null == all exceptions */
1323 uint8_t caught, uncaught;
1324
1325 exceptionOrNull = ReadRefTypeId(&buf);
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001326 caught = Read1(&buf);
1327 uncaught = Read1(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001328 VLOG(jdwp) << StringPrintf(" ExceptionOnly: type=%llx(%s) caught=%d uncaught=%d",
Elliott Hughesa2155262011-11-16 16:26:58 -08001329 exceptionOrNull, (exceptionOrNull == 0) ? "null" : Dbg::GetClassDescriptor(exceptionOrNull).c_str(), caught, uncaught);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001330
1331 pEvent->mods[idx].exceptionOnly.refTypeId = exceptionOrNull;
1332 pEvent->mods[idx].exceptionOnly.caught = caught;
1333 pEvent->mods[idx].exceptionOnly.uncaught = uncaught;
1334 }
1335 break;
1336 case MK_FIELD_ONLY: /* for field access/mod events */
1337 {
1338 RefTypeId declaring = ReadRefTypeId(&buf);
1339 FieldId fieldId = ReadFieldId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001340 VLOG(jdwp) << StringPrintf(" FieldOnly: %llx %x", declaring, fieldId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001341 pEvent->mods[idx].fieldOnly.refTypeId = declaring;
1342 pEvent->mods[idx].fieldOnly.fieldId = fieldId;
1343 }
1344 break;
1345 case MK_STEP: /* for use with EK_SINGLE_STEP */
1346 {
1347 ObjectId threadId;
1348 uint32_t size, depth;
1349
1350 threadId = ReadObjectId(&buf);
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001351 size = Read4BE(&buf);
1352 depth = Read4BE(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001353 VLOG(jdwp) << StringPrintf(" Step: thread=%llx", threadId)
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001354 << " size=" << JdwpStepSize(size) << " depth=" << JdwpStepDepth(depth);
1355
1356 pEvent->mods[idx].step.threadId = threadId;
1357 pEvent->mods[idx].step.size = size;
1358 pEvent->mods[idx].step.depth = depth;
1359 }
1360 break;
1361 case MK_INSTANCE_ONLY: /* report events related to a specific obj */
1362 {
1363 ObjectId instance = ReadObjectId(&buf);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001364 VLOG(jdwp) << StringPrintf(" InstanceOnly: %llx", instance);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001365 pEvent->mods[idx].instanceOnly.objectId = instance;
1366 }
1367 break;
1368 default:
1369 LOG(WARNING) << "GLITCH: unsupported modKind=" << modKind;
1370 break;
1371 }
1372 }
1373
1374 /*
1375 * Make sure we consumed all data. It is possible that the remote side
1376 * has sent us bad stuff, but for now we blame ourselves.
1377 */
1378 if (buf != origBuf + dataLen) {
1379 LOG(WARNING) << "GLITCH: dataLen is " << dataLen << ", we have consumed " << (buf - origBuf);
1380 }
1381
1382 /*
1383 * We reply with an integer "requestID".
1384 */
Elliott Hughes376a7a02011-10-24 18:35:55 -07001385 uint32_t requestId = state->NextEventSerial();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001386 expandBufAdd4BE(pReply, requestId);
1387
1388 pEvent->requestId = requestId;
1389
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001390 VLOG(jdwp) << StringPrintf(" --> event requestId=%#x", requestId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001391
1392 /* add it to the list */
Elliott Hughes761928d2011-11-16 18:33:03 -08001393 JdwpError err = state->RegisterEvent(pEvent);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001394 if (err != ERR_NONE) {
1395 /* registration failed, probably because event is bogus */
1396 EventFree(pEvent);
1397 LOG(WARNING) << "WARNING: event request rejected";
1398 }
1399 return err;
1400}
1401
1402/*
1403 * Clear an event. Failure to find an event with a matching ID is a no-op
1404 * and does not return an error.
1405 */
1406static JdwpError handleER_Clear(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1407 uint8_t eventKind;
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001408 eventKind = Read1(&buf);
1409 uint32_t requestId = Read4BE(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001410
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001411 VLOG(jdwp) << StringPrintf(" Req to clear eventKind=%d requestId=%#x", eventKind, requestId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001412
Elliott Hughes761928d2011-11-16 18:33:03 -08001413 state->UnregisterEventById(requestId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001414
1415 return ERR_NONE;
1416}
1417
1418/*
1419 * Return the values of arguments and local variables.
1420 */
1421static JdwpError handleSF_GetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1422 ObjectId threadId = ReadObjectId(&buf);
1423 FrameId frameId = ReadFrameId(&buf);
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001424 uint32_t slots = Read4BE(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001425
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001426 VLOG(jdwp) << StringPrintf(" Req for %d slots in threadId=%llx frameId=%llx", slots, threadId, frameId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001427
1428 expandBufAdd4BE(pReply, slots); /* "int values" */
1429 for (uint32_t i = 0; i < slots; i++) {
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001430 uint32_t slot = Read4BE(&buf);
Elliott Hughesaed4be92011-12-02 16:16:23 -08001431 JDWP::JdwpTag reqSigByte = ReadTag(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001432
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001433 VLOG(jdwp) << StringPrintf(" --> slot %d '%c'", slot, reqSigByte);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001434
Elliott Hughesdbb40792011-11-18 17:05:22 -08001435 size_t width = Dbg::GetTagWidth(reqSigByte);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001436 uint8_t* ptr = expandBufAddSpace(pReply, width+1);
1437 Dbg::GetLocalValue(threadId, frameId, slot, reqSigByte, ptr, width);
1438 }
1439
1440 return ERR_NONE;
1441}
1442
1443/*
1444 * Set the values of arguments and local variables.
1445 */
1446static JdwpError handleSF_SetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1447 ObjectId threadId = ReadObjectId(&buf);
1448 FrameId frameId = ReadFrameId(&buf);
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001449 uint32_t slots = Read4BE(&buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001450
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001451 VLOG(jdwp) << StringPrintf(" Req to set %d slots in threadId=%llx frameId=%llx", slots, threadId, frameId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001452
1453 for (uint32_t i = 0; i < slots; i++) {
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001454 uint32_t slot = Read4BE(&buf);
Elliott Hughesaed4be92011-12-02 16:16:23 -08001455 JDWP::JdwpTag sigByte = ReadTag(&buf);
Elliott Hughesdbb40792011-11-18 17:05:22 -08001456 size_t width = Dbg::GetTagWidth(sigByte);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001457 uint64_t value = jdwpReadValue(&buf, width);
1458
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001459 VLOG(jdwp) << StringPrintf(" --> slot %d '%c' %llx", slot, sigByte, value);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001460 Dbg::SetLocalValue(threadId, frameId, slot, sigByte, value, width);
1461 }
1462
1463 return ERR_NONE;
1464}
1465
1466/*
1467 * Returns the value of "this" for the specified frame.
1468 */
1469static JdwpError handleSF_ThisObject(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
Elliott Hughesd07986f2011-12-06 18:27:45 -08001470 ReadObjectId(&buf); // Skip thread id.
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001471 FrameId frameId = ReadFrameId(&buf);
1472
1473 ObjectId objectId;
Elliott Hughesd07986f2011-12-06 18:27:45 -08001474 if (!Dbg::GetThisObject(frameId, &objectId)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001475 return ERR_INVALID_FRAMEID;
1476 }
1477
1478 uint8_t objectTag = Dbg::GetObjectTag(objectId);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001479 VLOG(jdwp) << StringPrintf(" Req for 'this' in frame=%llx --> %llx '%c'", frameId, objectId, (char)objectTag);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001480
1481 expandBufAdd1(pReply, objectTag);
1482 expandBufAddObjectId(pReply, objectId);
1483
1484 return ERR_NONE;
1485}
1486
1487/*
1488 * Return the reference type reflected by this class object.
1489 *
1490 * This appears to be required because ReferenceTypeId values are NEVER
1491 * reused, whereas ClassIds can be recycled like any other object. (Either
1492 * that, or I have no idea what this is for.)
1493 */
1494static JdwpError handleCOR_ReflectedType(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1495 RefTypeId classObjectId = ReadRefTypeId(&buf);
1496
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001497 VLOG(jdwp) << StringPrintf(" Req for refTypeId for class=%llx (%s)", classObjectId, Dbg::GetClassDescriptor(classObjectId).c_str());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001498
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001499 bool is_interface;
1500 if (!Dbg::IsInterface(classObjectId, is_interface)) {
1501 return ERR_INVALID_CLASS;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001502 }
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001503
1504 expandBufAdd1(pReply, is_interface ? TT_INTERFACE : TT_CLASS);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001505 expandBufAddRefTypeId(pReply, classObjectId);
1506
1507 return ERR_NONE;
1508}
1509
1510/*
1511 * Handle a DDM packet with a single chunk in it.
1512 */
1513static JdwpError handleDDM_Chunk(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
1514 uint8_t* replyBuf = NULL;
1515 int replyLen = -1;
1516
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001517 VLOG(jdwp) << StringPrintf(" Handling DDM packet (%.4s)", buf);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001518
1519 /*
1520 * On first DDM packet, notify all handlers that DDM is running.
1521 */
1522 if (!state->ddmActive) {
1523 state->ddmActive = true;
1524 Dbg::DdmConnected();
1525 }
1526
1527 /*
1528 * If they want to send something back, we copy it into the buffer.
1529 * A no-copy approach would be nicer.
1530 *
1531 * TODO: consider altering the JDWP stuff to hold the packet header
1532 * in a separate buffer. That would allow us to writev() DDM traffic
1533 * instead of copying it into the expanding buffer. The reduction in
1534 * heap requirements is probably more valuable than the efficiency.
1535 */
1536 if (Dbg::DdmHandlePacket(buf, dataLen, &replyBuf, &replyLen)) {
1537 CHECK(replyLen > 0 && replyLen < 1*1024*1024);
1538 memcpy(expandBufAddSpace(pReply, replyLen), replyBuf, replyLen);
1539 free(replyBuf);
1540 }
1541 return ERR_NONE;
1542}
1543
1544/*
1545 * Handler map decl.
1546 */
1547typedef JdwpError (*JdwpRequestHandler)(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* reply);
1548
1549struct JdwpHandlerMap {
1550 uint8_t cmdSet;
1551 uint8_t cmd;
1552 JdwpRequestHandler func;
1553 const char* descr;
1554};
1555
1556/*
1557 * Map commands to functions.
1558 *
1559 * Command sets 0-63 are incoming requests, 64-127 are outbound requests,
1560 * and 128-256 are vendor-defined.
1561 */
1562static const JdwpHandlerMap gHandlerMap[] = {
1563 /* VirtualMachine command set (1) */
1564 { 1, 1, handleVM_Version, "VirtualMachine.Version" },
1565 { 1, 2, handleVM_ClassesBySignature, "VirtualMachine.ClassesBySignature" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001566 { 1, 3, NULL, "VirtualMachine.AllClasses" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001567 { 1, 4, handleVM_AllThreads, "VirtualMachine.AllThreads" },
1568 { 1, 5, handleVM_TopLevelThreadGroups, "VirtualMachine.TopLevelThreadGroups" },
1569 { 1, 6, handleVM_Dispose, "VirtualMachine.Dispose" },
1570 { 1, 7, handleVM_IDSizes, "VirtualMachine.IDSizes" },
1571 { 1, 8, handleVM_Suspend, "VirtualMachine.Suspend" },
1572 { 1, 9, handleVM_Resume, "VirtualMachine.Resume" },
1573 { 1, 10, handleVM_Exit, "VirtualMachine.Exit" },
1574 { 1, 11, handleVM_CreateString, "VirtualMachine.CreateString" },
1575 { 1, 12, handleVM_Capabilities, "VirtualMachine.Capabilities" },
1576 { 1, 13, handleVM_ClassPaths, "VirtualMachine.ClassPaths" },
1577 { 1, 14, HandleVM_DisposeObjects, "VirtualMachine.DisposeObjects" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001578 { 1, 15, NULL, "VirtualMachine.HoldEvents" },
1579 { 1, 16, NULL, "VirtualMachine.ReleaseEvents" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001580 { 1, 17, handleVM_CapabilitiesNew, "VirtualMachine.CapabilitiesNew" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001581 { 1, 18, NULL, "VirtualMachine.RedefineClasses" },
1582 { 1, 19, NULL, "VirtualMachine.SetDefaultStratum" },
1583 { 1, 20, handleVM_AllClassesWithGeneric, "VirtualMachine.AllClassesWithGeneric" },
1584 { 1, 21, NULL, "VirtualMachine.InstanceCounts" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001585
1586 /* ReferenceType command set (2) */
1587 { 2, 1, handleRT_Signature, "ReferenceType.Signature" },
1588 { 2, 2, handleRT_ClassLoader, "ReferenceType.ClassLoader" },
1589 { 2, 3, handleRT_Modifiers, "ReferenceType.Modifiers" },
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001590 { 2, 4, handleRT_Fields, "ReferenceType.Fields" },
1591 { 2, 5, handleRT_Methods, "ReferenceType.Methods" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001592 { 2, 6, handleRT_GetValues, "ReferenceType.GetValues" },
1593 { 2, 7, handleRT_SourceFile, "ReferenceType.SourceFile" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001594 { 2, 8, NULL, "ReferenceType.NestedTypes" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001595 { 2, 9, handleRT_Status, "ReferenceType.Status" },
1596 { 2, 10, handleRT_Interfaces, "ReferenceType.Interfaces" },
1597 { 2, 11, handleRT_ClassObject, "ReferenceType.ClassObject" },
1598 { 2, 12, handleRT_SourceDebugExtension, "ReferenceType.SourceDebugExtension" },
1599 { 2, 13, handleRT_SignatureWithGeneric, "ReferenceType.SignatureWithGeneric" },
1600 { 2, 14, handleRT_FieldsWithGeneric, "ReferenceType.FieldsWithGeneric" },
1601 { 2, 15, handleRT_MethodsWithGeneric, "ReferenceType.MethodsWithGeneric" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001602 { 2, 16, NULL, "ReferenceType.Instances" },
1603 { 2, 17, NULL, "ReferenceType.ClassFileVersion" },
1604 { 2, 18, NULL, "ReferenceType.ConstantPool" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001605
1606 /* ClassType command set (3) */
1607 { 3, 1, handleCT_Superclass, "ClassType.Superclass" },
1608 { 3, 2, handleCT_SetValues, "ClassType.SetValues" },
1609 { 3, 3, handleCT_InvokeMethod, "ClassType.InvokeMethod" },
1610 { 3, 4, handleCT_NewInstance, "ClassType.NewInstance" },
1611
1612 /* ArrayType command set (4) */
1613 { 4, 1, handleAT_newInstance, "ArrayType.NewInstance" },
1614
1615 /* InterfaceType command set (5) */
1616
1617 /* Method command set (6) */
1618 { 6, 1, handleM_LineTable, "Method.LineTable" },
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001619 { 6, 2, handleM_VariableTable, "Method.VariableTable" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001620 { 6, 3, NULL, "Method.Bytecodes" },
1621 { 6, 4, NULL, "Method.IsObsolete" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001622 { 6, 5, handleM_VariableTableWithGeneric, "Method.VariableTableWithGeneric" },
1623
1624 /* Field command set (8) */
1625
1626 /* ObjectReference command set (9) */
1627 { 9, 1, handleOR_ReferenceType, "ObjectReference.ReferenceType" },
1628 { 9, 2, handleOR_GetValues, "ObjectReference.GetValues" },
1629 { 9, 3, handleOR_SetValues, "ObjectReference.SetValues" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001630 { 9, 4, NULL, "ObjectReference.UNUSED" },
1631 { 9, 5, NULL, "ObjectReference.MonitorInfo" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001632 { 9, 6, handleOR_InvokeMethod, "ObjectReference.InvokeMethod" },
1633 { 9, 7, handleOR_DisableCollection, "ObjectReference.DisableCollection" },
1634 { 9, 8, handleOR_EnableCollection, "ObjectReference.EnableCollection" },
1635 { 9, 9, handleOR_IsCollected, "ObjectReference.IsCollected" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001636 { 9, 10, NULL, "ObjectReference.ReferringObjects" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001637
1638 /* StringReference command set (10) */
1639 { 10, 1, handleSR_Value, "StringReference.Value" },
1640
1641 /* ThreadReference command set (11) */
1642 { 11, 1, handleTR_Name, "ThreadReference.Name" },
1643 { 11, 2, handleTR_Suspend, "ThreadReference.Suspend" },
1644 { 11, 3, handleTR_Resume, "ThreadReference.Resume" },
1645 { 11, 4, handleTR_Status, "ThreadReference.Status" },
1646 { 11, 5, handleTR_ThreadGroup, "ThreadReference.ThreadGroup" },
1647 { 11, 6, handleTR_Frames, "ThreadReference.Frames" },
1648 { 11, 7, handleTR_FrameCount, "ThreadReference.FrameCount" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001649 { 11, 8, NULL, "ThreadReference.OwnedMonitors" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001650 { 11, 9, handleTR_CurrentContendedMonitor, "ThreadReference.CurrentContendedMonitor" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001651 { 11, 10, NULL, "ThreadReference.Stop" },
1652 { 11, 11, NULL,"ThreadReference.Interrupt" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001653 { 11, 12, handleTR_SuspendCount, "ThreadReference.SuspendCount" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001654 { 11, 13, NULL, "ThreadReference.OwnedMonitorsStackDepthInfo" },
1655 { 11, 14, NULL, "ThreadReference.ForceEarlyReturn" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001656
1657 /* ThreadGroupReference command set (12) */
1658 { 12, 1, handleTGR_Name, "ThreadGroupReference.Name" },
1659 { 12, 2, handleTGR_Parent, "ThreadGroupReference.Parent" },
1660 { 12, 3, handleTGR_Children, "ThreadGroupReference.Children" },
1661
1662 /* ArrayReference command set (13) */
1663 { 13, 1, handleAR_Length, "ArrayReference.Length" },
1664 { 13, 2, handleAR_GetValues, "ArrayReference.GetValues" },
1665 { 13, 3, handleAR_SetValues, "ArrayReference.SetValues" },
1666
1667 /* ClassLoaderReference command set (14) */
1668 { 14, 1, handleCLR_VisibleClasses, "ClassLoaderReference.VisibleClasses" },
1669
1670 /* EventRequest command set (15) */
1671 { 15, 1, handleER_Set, "EventRequest.Set" },
1672 { 15, 2, handleER_Clear, "EventRequest.Clear" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001673 { 15, 3, NULL, "EventRequest.ClearAllBreakpoints" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001674
1675 /* StackFrame command set (16) */
1676 { 16, 1, handleSF_GetValues, "StackFrame.GetValues" },
1677 { 16, 2, handleSF_SetValues, "StackFrame.SetValues" },
1678 { 16, 3, handleSF_ThisObject, "StackFrame.ThisObject" },
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001679 { 16, 4, NULL, "StackFrame.PopFrames" },
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001680
1681 /* ClassObjectReference command set (17) */
1682 { 17, 1, handleCOR_ReflectedType,"ClassObjectReference.ReflectedType" },
1683
1684 /* Event command set (64) */
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001685 { 64, 100, NULL, "Event.Composite" }, // sent from VM to debugger, never received by VM
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001686
1687 { 199, 1, handleDDM_Chunk, "DDM.Chunk" },
1688};
1689
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001690static const char* GetCommandName(size_t cmdSet, size_t cmd) {
1691 for (int i = 0; i < (int) arraysize(gHandlerMap); i++) {
1692 if (gHandlerMap[i].cmdSet == cmdSet && gHandlerMap[i].cmd == cmd) {
1693 return gHandlerMap[i].descr;
1694 }
1695 }
1696 return "?UNKNOWN?";
1697}
1698
1699static std::string DescribeCommand(const JdwpReqHeader* pHeader, int dataLen) {
1700 std::string result;
1701 result += "REQ: ";
1702 result += GetCommandName(pHeader->cmdSet, pHeader->cmd);
1703 result += StringPrintf(" (dataLen=%d id=0x%06x)", dataLen, pHeader->id);
1704 return result;
1705}
1706
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001707/*
1708 * Process a request from the debugger.
1709 *
1710 * On entry, the JDWP thread is in VMWAIT.
1711 */
Elliott Hughes376a7a02011-10-24 18:35:55 -07001712void JdwpState::ProcessRequest(const JdwpReqHeader* pHeader, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001713 JdwpError result = ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001714
1715 if (pHeader->cmdSet != kJDWPDdmCmdSet) {
1716 /*
1717 * Activity from a debugger, not merely ddms. Mark us as having an
1718 * active debugger session, and zero out the last-activity timestamp
1719 * so waitForDebugger() doesn't return if we stall for a bit here.
1720 */
Elliott Hughesa2155262011-11-16 16:26:58 -08001721 Dbg::GoActive();
Elliott Hughes376a7a02011-10-24 18:35:55 -07001722 QuasiAtomicSwap64(0, &lastActivityWhen);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001723 }
1724
1725 /*
1726 * If a debugger event has fired in another thread, wait until the
1727 * initiating thread has suspended itself before processing messages
1728 * from the debugger. Otherwise we (the JDWP thread) could be told to
1729 * resume the thread before it has suspended.
1730 *
1731 * We call with an argument of zero to wait for the current event
1732 * thread to finish, and then clear the block. Depending on the thread
1733 * suspend policy, this may allow events in other threads to fire,
1734 * but those events have no bearing on what the debugger has sent us
1735 * in the current request.
1736 *
1737 * Note that we MUST clear the event token before waking the event
1738 * thread up, or risk waiting for the thread to suspend after we've
1739 * told it to resume.
1740 */
Elliott Hughes376a7a02011-10-24 18:35:55 -07001741 SetWaitForEventThread(0);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001742
1743 /*
1744 * Tell the VM that we're running and shouldn't be interrupted by GC.
1745 * Do this after anything that can stall indefinitely.
1746 */
1747 Dbg::ThreadRunning();
1748
1749 expandBufAddSpace(pReply, kJDWPHeaderLen);
1750
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001751 size_t i;
1752 for (i = 0; i < arraysize(gHandlerMap); i++) {
1753 if (gHandlerMap[i].cmdSet == pHeader->cmdSet && gHandlerMap[i].cmd == pHeader->cmd && gHandlerMap[i].func != NULL) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001754 VLOG(jdwp) << DescribeCommand(pHeader, dataLen);
Elliott Hughes376a7a02011-10-24 18:35:55 -07001755 result = (*gHandlerMap[i].func)(this, buf, dataLen, pReply);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001756 break;
1757 }
1758 }
1759 if (i == arraysize(gHandlerMap)) {
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001760 LOG(ERROR) << DescribeCommand(pHeader, dataLen);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001761 if (dataLen > 0) {
1762 HexDump(buf, dataLen);
1763 }
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001764 LOG(ERROR) << "command not implemented";
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001765 result = ERR_NOT_IMPLEMENTED;
1766 }
1767
1768 /*
1769 * Set up the reply header.
1770 *
1771 * If we encountered an error, only send the header back.
1772 */
1773 uint8_t* replyBuf = expandBufGetBuffer(pReply);
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001774 Set4BE(replyBuf + 4, pHeader->id);
1775 Set1(replyBuf + 8, kJDWPFlagReply);
1776 Set2BE(replyBuf + 9, result);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001777 if (result == ERR_NONE) {
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001778 Set4BE(replyBuf + 0, expandBufGetLength(pReply));
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001779 } else {
Elliott Hughesf7c3b662011-10-27 12:04:56 -07001780 Set4BE(replyBuf + 0, kJDWPHeaderLen);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001781 }
1782
Elliott Hughesa3c24aa2011-12-07 15:34:09 -08001783 size_t respLen = expandBufGetLength(pReply) - kJDWPHeaderLen;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001784 if (false) {
1785 LOG(INFO) << "reply: dataLen=" << respLen << " err=" << result << (result != ERR_NONE ? " **FAILED**" : "");
1786 if (respLen > 0) {
1787 HexDump(expandBufGetBuffer(pReply) + kJDWPHeaderLen, respLen);
1788 }
1789 }
1790
1791 /*
1792 * Update last-activity timestamp. We really only need this during
1793 * the initial setup. Only update if this is a non-DDMS packet.
1794 */
1795 if (pHeader->cmdSet != kJDWPDdmCmdSet) {
Elliott Hughes7162ad92011-10-27 14:08:42 -07001796 QuasiAtomicSwap64(MilliTime(), &lastActivityWhen);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001797 }
1798
1799 /* tell the VM that GC is okay again */
1800 Dbg::ThreadWaiting();
1801}
1802
1803} // namespace JDWP
1804
1805} // namespace art