Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 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 | * 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 | |
| 43 | namespace art { |
| 44 | |
| 45 | namespace JDWP { |
| 46 | |
| 47 | /* |
| 48 | * Helper function: read a "location" from an input buffer. |
| 49 | */ |
| 50 | static void jdwpReadLocation(const uint8_t** pBuf, JdwpLocation* pLoc) { |
| 51 | memset(pLoc, 0, sizeof(*pLoc)); /* allows memcmp() later */ |
Elliott Hughes | d07986f | 2011-12-06 18:27:45 -0800 | [diff] [blame] | 52 | pLoc->typeTag = ReadTypeTag(pBuf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 53 | pLoc->classId = ReadObjectId(pBuf); |
| 54 | pLoc->methodId = ReadMethodId(pBuf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 55 | pLoc->idx = Read8BE(pBuf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 56 | } |
| 57 | |
| 58 | /* |
| 59 | * Helper function: write a "location" into the reply buffer. |
| 60 | */ |
| 61 | void 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 Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 71 | static uint64_t jdwpReadValue(const uint8_t** pBuf, size_t width) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 72 | uint64_t value = -1; |
| 73 | switch (width) { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 74 | 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 Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 78 | 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 | */ |
| 86 | static 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 | */ |
| 102 | static 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 Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 109 | uint32_t numArgs = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 110 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 111 | 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 Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 114 | |
| 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 Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 121 | JDWP::JdwpTag typeTag = ReadTag(&buf); |
Elliott Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 122 | size_t width = Dbg::GetTagWidth(typeTag); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 123 | uint64_t value = jdwpReadValue(&buf, width); |
| 124 | |
Elliott Hughes | abd04b9 | 2012-01-18 22:46:41 -0800 | [diff] [blame] | 125 | VLOG(jdwp) << StringPrintf(" '%c'(%zd): 0x%llx", typeTag, width, value); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 126 | argArray[i] = value; |
| 127 | } |
| 128 | |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 129 | uint32_t options = Read4BE(&buf); /* enum InvokeOptions bit flags */ |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 130 | VLOG(jdwp) << StringPrintf(" options=0x%04x%s%s", options, (options & INVOKE_SINGLE_THREADED) ? " (SINGLE_THREADED)" : "", (options & INVOKE_NONVIRTUAL) ? " (NONVIRTUAL)" : ""); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 131 | |
Elliott Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 132 | JDWP::JdwpTag resultTag; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 133 | 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 Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 145 | size_t width = Dbg::GetTagWidth(resultTag); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 146 | |
| 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 Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 155 | VLOG(jdwp) << StringPrintf(" --> returned '%c' 0x%llx (except=%08llx)", resultTag, resultValue, exceptObjId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 156 | |
| 157 | /* show detailed debug output */ |
| 158 | if (resultTag == JT_STRING && exceptObjId == 0) { |
| 159 | if (resultValue != 0) { |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 160 | VLOG(jdwp) << " string '" << Dbg::StringToUtf8(resultValue) << "'"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 161 | } else { |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 162 | VLOG(jdwp) << " string (null)"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 163 | } |
| 164 | } |
| 165 | } |
| 166 | |
| 167 | bail: |
| 168 | free(argArray); |
| 169 | return err; |
| 170 | } |
| 171 | |
| 172 | |
| 173 | /* |
| 174 | * Request for version info. |
| 175 | */ |
| 176 | static 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 Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 179 | expandBufAddUtf8String(pReply, version); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 180 | /* JDWP version numbers */ |
| 181 | expandBufAdd4BE(pReply, 1); // major |
| 182 | expandBufAdd4BE(pReply, 5); // minor |
| 183 | /* VM JRE version */ |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 184 | expandBufAddUtf8String(pReply, "1.6.0"); /* e.g. 1.6.0_22 */ |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 185 | /* target VM name */ |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 186 | expandBufAddUtf8String(pReply, "DalvikVM"); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 187 | |
| 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 | */ |
| 196 | static JdwpError handleVM_ClassesBySignature(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 197 | std::string classDescriptor(ReadNewUtf8String(&buf)); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 198 | VLOG(jdwp) << " Req for class by signature '" << classDescriptor << "'"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 199 | |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 200 | std::vector<RefTypeId> ids; |
Elliott Hughes | c3b77c7 | 2011-12-15 20:56:48 -0800 | [diff] [blame] | 201 | Dbg::FindLoadedClassBySignature(classDescriptor.c_str(), ids); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 202 | |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 203 | expandBufAdd4BE(pReply, ids.size()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 204 | |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 205 | for (size_t i = 0; i < ids.size(); ++i) { |
| 206 | // Get class vs. interface and status flags. |
| 207 | JDWP::JdwpTypeTag typeTag; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 208 | uint32_t status; |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 209 | if (!Dbg::GetClassInfo(ids[i], &typeTag, &status, NULL)) { |
| 210 | return ERR_INVALID_CLASS; |
| 211 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 212 | |
| 213 | expandBufAdd1(pReply, typeTag); |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 214 | expandBufAddRefTypeId(pReply, ids[i]); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 215 | expandBufAdd4BE(pReply, status); |
| 216 | } |
| 217 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 218 | 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 | */ |
| 227 | static 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 | */ |
| 247 | static 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 | */ |
| 269 | static 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 | */ |
| 284 | static 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 | */ |
| 294 | static JdwpError handleVM_Suspend(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | 475fc23 | 2011-10-25 15:00:35 -0700 | [diff] [blame] | 295 | Dbg::SuspendVM(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 296 | return ERR_NONE; |
| 297 | } |
| 298 | |
| 299 | /* |
| 300 | * Resume execution. Decrements the "suspend count" of all threads. |
| 301 | */ |
| 302 | static 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 | */ |
| 310 | static JdwpError handleVM_Exit(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 311 | uint32_t exitCode = Get4BE(buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 312 | |
| 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 | */ |
| 325 | static JdwpError handleVM_CreateString(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 326 | std::string str(ReadNewUtf8String(&buf)); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 327 | VLOG(jdwp) << " Req to create string '" << str << "'"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 328 | ObjectId stringId = Dbg::CreateString(str); |
| 329 | if (stringId == 0) { |
| 330 | return ERR_OUT_OF_MEMORY; |
| 331 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 332 | expandBufAddObjectId(pReply, stringId); |
| 333 | return ERR_NONE; |
| 334 | } |
| 335 | |
| 336 | /* |
| 337 | * Tell the debugger what we are capable of. |
| 338 | */ |
| 339 | static 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 | */ |
| 353 | static 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 Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 363 | expandBufAddUtf8String(pReply, baseDir); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 364 | expandBufAdd4BE(pReply, classPaths); |
| 365 | for (uint32_t i = 0; i < classPaths; i++) { |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 366 | expandBufAddUtf8String(pReply, "."); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 367 | } |
| 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 | */ |
| 382 | static 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 | */ |
| 389 | static 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 | */ |
| 422 | static JdwpError handleVM_AllClassesWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 423 | std::vector<JDWP::RefTypeId> classes; |
| 424 | Dbg::GetClassList(classes); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 425 | |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 426 | expandBufAdd4BE(pReply, classes.size()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 427 | |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 428 | for (size_t i = 0; i < classes.size(); ++i) { |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 429 | static const char genericSignature[1] = ""; |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 430 | JDWP::JdwpTypeTag refTypeTag; |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 431 | std::string descriptor; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 432 | uint32_t status; |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 433 | if (!Dbg::GetClassInfo(classes[i], &refTypeTag, &status, &descriptor)) { |
| 434 | return ERR_INVALID_CLASS; |
| 435 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 436 | |
| 437 | expandBufAdd1(pReply, refTypeTag); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 438 | expandBufAddRefTypeId(pReply, classes[i]); |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 439 | expandBufAddUtf8String(pReply, descriptor); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 440 | expandBufAddUtf8String(pReply, genericSignature); |
| 441 | expandBufAdd4BE(pReply, status); |
| 442 | } |
| 443 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 444 | 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 | */ |
| 451 | static JdwpError handleRT_Signature(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 452 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
| 453 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 454 | VLOG(jdwp) << StringPrintf(" Req for signature of refTypeId=0x%llx", refTypeId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 455 | std::string signature; |
| 456 | if (!Dbg::GetSignature(refTypeId, signature)) { |
| 457 | return ERR_INVALID_CLASS; |
| 458 | } |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 459 | expandBufAddUtf8String(pReply, signature); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 460 | return ERR_NONE; |
| 461 | } |
| 462 | |
| 463 | /* |
| 464 | * Return the modifiers (a/k/a access flags) for a reference type. |
| 465 | */ |
| 466 | static JdwpError handleRT_Modifiers(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 467 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 468 | uint32_t access_flags; |
| 469 | if (!Dbg::GetAccessFlags(refTypeId, access_flags)) { |
| 470 | return ERR_INVALID_CLASS; |
| 471 | } |
| 472 | expandBufAdd4BE(pReply, access_flags); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 473 | return ERR_NONE; |
| 474 | } |
| 475 | |
| 476 | /* |
| 477 | * Get values from static fields in a reference type. |
| 478 | */ |
| 479 | static JdwpError handleRT_GetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 480 | ReadRefTypeId(&buf); // We don't need this, but we need to skip over it in the request. |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 481 | uint32_t numFields = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 482 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 483 | VLOG(jdwp) << " RT_GetValues " << numFields << ":"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 484 | |
| 485 | expandBufAdd4BE(pReply, numFields); |
| 486 | for (uint32_t i = 0; i < numFields; i++) { |
| 487 | FieldId fieldId = ReadFieldId(&buf); |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 488 | Dbg::GetStaticFieldValue(fieldId, pReply); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 489 | } |
| 490 | |
| 491 | return ERR_NONE; |
| 492 | } |
| 493 | |
| 494 | /* |
| 495 | * Get the name of the source file in which a reference type was declared. |
| 496 | */ |
| 497 | static JdwpError handleRT_SourceFile(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 498 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 03181a8 | 2011-11-17 17:22:21 -0800 | [diff] [blame] | 499 | std::string source_file; |
| 500 | if (!Dbg::GetSourceFile(refTypeId, source_file)) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 501 | return ERR_ABSENT_INFORMATION; |
| 502 | } |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 503 | expandBufAddUtf8String(pReply, source_file); |
Elliott Hughes | 03181a8 | 2011-11-17 17:22:21 -0800 | [diff] [blame] | 504 | return ERR_NONE; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 505 | } |
| 506 | |
| 507 | /* |
| 508 | * Return the current status of the reference type. |
| 509 | */ |
| 510 | static JdwpError handleRT_Status(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 511 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 512 | JDWP::JdwpTypeTag typeTag; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 513 | uint32_t status; |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 514 | if (!Dbg::GetClassInfo(refTypeId, &typeTag, &status, NULL)) { |
| 515 | return ERR_INVALID_CLASS; |
| 516 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 517 | expandBufAdd4BE(pReply, status); |
| 518 | return ERR_NONE; |
| 519 | } |
| 520 | |
| 521 | /* |
| 522 | * Return interfaces implemented directly by this class. |
| 523 | */ |
| 524 | static JdwpError handleRT_Interfaces(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 525 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 526 | VLOG(jdwp) << StringPrintf(" Req for interfaces in %llx (%s)", refTypeId, Dbg::GetClassDescriptor(refTypeId).c_str()); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 527 | return Dbg::OutputDeclaredInterfaces(refTypeId, pReply) ? ERR_NONE : ERR_INVALID_CLASS; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 528 | } |
| 529 | |
| 530 | /* |
| 531 | * Return the class object corresponding to this type. |
| 532 | */ |
| 533 | static JdwpError handleRT_ClassObject(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 534 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 535 | ObjectId classObjectId; |
| 536 | if (!Dbg::GetClassObject(refTypeId, classObjectId)) { |
| 537 | return ERR_INVALID_CLASS; |
| 538 | } |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 539 | VLOG(jdwp) << StringPrintf(" RefTypeId %llx -> ObjectId %llx", refTypeId, classObjectId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 540 | expandBufAddObjectId(pReply, classObjectId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 541 | 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 | */ |
| 549 | static 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 | */ |
| 557 | static JdwpError handleRT_SignatureWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 558 | static const char genericSignature[1] = ""; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 559 | |
| 560 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
| 561 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 562 | VLOG(jdwp) << StringPrintf(" Req for signature of refTypeId=0x%llx", refTypeId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 563 | std::string signature; |
| 564 | if (Dbg::GetSignature(refTypeId, signature)) { |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 565 | expandBufAddUtf8String(pReply, signature); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 566 | } else { |
| 567 | LOG(WARNING) << StringPrintf("No signature for refTypeId=0x%llx", refTypeId); |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 568 | expandBufAddUtf8String(pReply, "Lunknown;"); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 569 | } |
| 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 | */ |
| 579 | static 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 Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 587 | static 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 Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 593 | /* |
| 594 | * Given a referenceTypeId, return a block of stuff that describes the |
| 595 | * fields declared by a class. |
| 596 | */ |
| 597 | static JdwpError handleRT_FieldsWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 598 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 599 | VLOG(jdwp) << " Req for fields in " << Describe(refTypeId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 600 | return Dbg::OutputDeclaredFields(refTypeId, true, pReply) ? ERR_NONE : ERR_INVALID_CLASS; |
| 601 | } |
| 602 | |
| 603 | // Obsolete equivalent of FieldsWithGeneric, without the generic type information. |
| 604 | static JdwpError handleRT_Fields(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 605 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 606 | VLOG(jdwp) << " Req for fields in " << Describe(refTypeId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 607 | return Dbg::OutputDeclaredFields(refTypeId, false, pReply) ? ERR_NONE : ERR_INVALID_CLASS; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 608 | } |
| 609 | |
| 610 | /* |
| 611 | * Given a referenceTypeID, return a block of goodies describing the |
| 612 | * methods declared by a class. |
| 613 | */ |
| 614 | static JdwpError handleRT_MethodsWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 615 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 616 | VLOG(jdwp) << " Req for methods in " << Describe(refTypeId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 617 | return Dbg::OutputDeclaredMethods(refTypeId, true, pReply) ? ERR_NONE : ERR_INVALID_CLASS; |
| 618 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 619 | |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 620 | // Obsolete equivalent of MethodsWithGeneric, without the generic type information. |
| 621 | static JdwpError handleRT_Methods(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 622 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 623 | VLOG(jdwp) << " Req for methods in " << Describe(refTypeId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 624 | return Dbg::OutputDeclaredMethods(refTypeId, false, pReply) ? ERR_NONE : ERR_INVALID_CLASS; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 625 | } |
| 626 | |
| 627 | /* |
| 628 | * Return the immediate superclass of a class. |
| 629 | */ |
| 630 | static JdwpError handleCT_Superclass(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 631 | RefTypeId classId = ReadRefTypeId(&buf); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 632 | RefTypeId superClassId; |
| 633 | if (!Dbg::GetSuperclass(classId, superClassId)) { |
| 634 | return ERR_INVALID_CLASS; |
| 635 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 636 | expandBufAddRefTypeId(pReply, superClassId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 637 | return ERR_NONE; |
| 638 | } |
| 639 | |
| 640 | /* |
| 641 | * Set static class values. |
| 642 | */ |
| 643 | static JdwpError handleCT_SetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 644 | RefTypeId classId = ReadRefTypeId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 645 | uint32_t values = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 646 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 647 | VLOG(jdwp) << StringPrintf(" Req to set %d values in classId=%llx", values, classId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 648 | |
| 649 | for (uint32_t i = 0; i < values; i++) { |
| 650 | FieldId fieldId = ReadFieldId(&buf); |
Elliott Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 651 | JDWP::JdwpTag fieldTag = Dbg::GetStaticFieldBasicTag(fieldId); |
Elliott Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 652 | size_t width = Dbg::GetTagWidth(fieldTag); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 653 | uint64_t value = jdwpReadValue(&buf, width); |
| 654 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 655 | VLOG(jdwp) << StringPrintf(" --> field=%x tag=%c -> %lld", fieldId, fieldTag, value); |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 656 | Dbg::SetStaticFieldValue(fieldId, value, width); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 657 | } |
| 658 | |
| 659 | return ERR_NONE; |
| 660 | } |
| 661 | |
| 662 | /* |
| 663 | * Invoke a static method. |
| 664 | * |
| 665 | * Example: Eclipse sometimes uses java/lang/Class.forName(String s) on |
| 666 | * values in the "variables" display. |
| 667 | */ |
| 668 | static JdwpError handleCT_InvokeMethod(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 669 | RefTypeId classId = ReadRefTypeId(&buf); |
| 670 | ObjectId threadId = ReadObjectId(&buf); |
| 671 | MethodId methodId = ReadMethodId(&buf); |
| 672 | |
| 673 | return finishInvoke(state, buf, dataLen, pReply, threadId, 0, classId, methodId, false); |
| 674 | } |
| 675 | |
| 676 | /* |
| 677 | * Create a new object of the requested type, and invoke the specified |
| 678 | * constructor. |
| 679 | * |
| 680 | * Example: in IntelliJ, create a watch on "new String(myByteArray)" to |
| 681 | * see the contents of a byte[] as a string. |
| 682 | */ |
| 683 | static JdwpError handleCT_NewInstance(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 684 | RefTypeId classId = ReadRefTypeId(&buf); |
| 685 | ObjectId threadId = ReadObjectId(&buf); |
| 686 | MethodId methodId = ReadMethodId(&buf); |
| 687 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 688 | VLOG(jdwp) << "Creating instance of " << Dbg::GetClassDescriptor(classId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 689 | ObjectId objectId; |
| 690 | if (!Dbg::CreateObject(classId, objectId)) { |
| 691 | return ERR_INVALID_CLASS; |
| 692 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 693 | if (objectId == 0) { |
| 694 | return ERR_OUT_OF_MEMORY; |
| 695 | } |
| 696 | return finishInvoke(state, buf, dataLen, pReply, threadId, objectId, classId, methodId, true); |
| 697 | } |
| 698 | |
| 699 | /* |
| 700 | * Create a new array object of the requested type and length. |
| 701 | */ |
| 702 | static JdwpError handleAT_newInstance(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 703 | RefTypeId arrayTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 704 | uint32_t length = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 705 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 706 | VLOG(jdwp) << StringPrintf("Creating array %s[%u]", Dbg::GetClassDescriptor(arrayTypeId).c_str(), length); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 707 | ObjectId objectId; |
| 708 | if (!Dbg::CreateArrayObject(arrayTypeId, length, objectId)) { |
| 709 | return ERR_INVALID_CLASS; |
| 710 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 711 | if (objectId == 0) { |
| 712 | return ERR_OUT_OF_MEMORY; |
| 713 | } |
| 714 | expandBufAdd1(pReply, JT_ARRAY); |
| 715 | expandBufAddObjectId(pReply, objectId); |
| 716 | return ERR_NONE; |
| 717 | } |
| 718 | |
| 719 | /* |
| 720 | * Return line number information for the method, if present. |
| 721 | */ |
| 722 | static JdwpError handleM_LineTable(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 723 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
| 724 | MethodId methodId = ReadMethodId(&buf); |
| 725 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 726 | VLOG(jdwp) << StringPrintf(" Req for line table in %s.%s", Dbg::GetClassDescriptor(refTypeId).c_str(), Dbg::GetMethodName(refTypeId,methodId).c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 727 | |
| 728 | Dbg::OutputLineTable(refTypeId, methodId, pReply); |
| 729 | |
| 730 | return ERR_NONE; |
| 731 | } |
| 732 | |
| 733 | /* |
| 734 | * Pull out the LocalVariableTable goodies. |
| 735 | */ |
| 736 | static JdwpError handleM_VariableTableWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 737 | RefTypeId classId = ReadRefTypeId(&buf); |
| 738 | MethodId methodId = ReadMethodId(&buf); |
| 739 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 740 | VLOG(jdwp) << StringPrintf(" Req for LocalVarTab in class=%s method=%s", Dbg::GetClassDescriptor(classId).c_str(), Dbg::GetMethodName(classId, methodId).c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 741 | |
| 742 | /* |
| 743 | * We could return ERR_ABSENT_INFORMATION here if the DEX file was |
| 744 | * built without local variable information. That will cause Eclipse |
| 745 | * to make a best-effort attempt at displaying local variables |
| 746 | * anonymously. However, the attempt isn't very good, so we're probably |
| 747 | * better off just not showing anything. |
| 748 | */ |
| 749 | Dbg::OutputVariableTable(classId, methodId, true, pReply); |
| 750 | return ERR_NONE; |
| 751 | } |
| 752 | |
| 753 | /* |
| 754 | * Given an object reference, return the runtime type of the object |
| 755 | * (class or array). |
| 756 | * |
| 757 | * This can get called on different things, e.g. threadId gets |
| 758 | * passed in here. |
| 759 | */ |
| 760 | static JdwpError handleOR_ReferenceType(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 761 | ObjectId objectId = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 762 | VLOG(jdwp) << StringPrintf(" Req for type of objectId=0x%llx", objectId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 763 | |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 764 | JDWP::JdwpTypeTag refTypeTag; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 765 | RefTypeId typeId; |
| 766 | Dbg::GetObjectType(objectId, &refTypeTag, &typeId); |
| 767 | |
| 768 | expandBufAdd1(pReply, refTypeTag); |
| 769 | expandBufAddRefTypeId(pReply, typeId); |
| 770 | |
| 771 | return ERR_NONE; |
| 772 | } |
| 773 | |
| 774 | /* |
| 775 | * Get values from the fields of an object. |
| 776 | */ |
| 777 | static JdwpError handleOR_GetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 778 | ObjectId objectId = ReadObjectId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 779 | uint32_t numFields = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 780 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 781 | VLOG(jdwp) << StringPrintf(" Req for %d fields from objectId=0x%llx", numFields, objectId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 782 | |
| 783 | expandBufAdd4BE(pReply, numFields); |
| 784 | |
| 785 | for (uint32_t i = 0; i < numFields; i++) { |
| 786 | FieldId fieldId = ReadFieldId(&buf); |
| 787 | Dbg::GetFieldValue(objectId, fieldId, pReply); |
| 788 | } |
| 789 | |
| 790 | return ERR_NONE; |
| 791 | } |
| 792 | |
| 793 | /* |
| 794 | * Set values in the fields of an object. |
| 795 | */ |
| 796 | static JdwpError handleOR_SetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 797 | ObjectId objectId = ReadObjectId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 798 | uint32_t numFields = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 799 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 800 | VLOG(jdwp) << StringPrintf(" Req to set %d fields in objectId=0x%llx", numFields, objectId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 801 | |
| 802 | for (uint32_t i = 0; i < numFields; i++) { |
| 803 | FieldId fieldId = ReadFieldId(&buf); |
| 804 | |
Elliott Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 805 | JDWP::JdwpTag fieldTag = Dbg::GetFieldBasicTag(fieldId); |
Elliott Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 806 | size_t width = Dbg::GetTagWidth(fieldTag); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 807 | uint64_t value = jdwpReadValue(&buf, width); |
| 808 | |
Elliott Hughes | abd04b9 | 2012-01-18 22:46:41 -0800 | [diff] [blame] | 809 | VLOG(jdwp) << StringPrintf(" --> fieldId=%x tag='%c'(%zd) value=%lld", fieldId, fieldTag, width, value); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 810 | |
| 811 | Dbg::SetFieldValue(objectId, fieldId, value, width); |
| 812 | } |
| 813 | |
| 814 | return ERR_NONE; |
| 815 | } |
| 816 | |
| 817 | /* |
| 818 | * Invoke an instance method. The invocation must occur in the specified |
| 819 | * thread, which must have been suspended by an event. |
| 820 | * |
| 821 | * The call is synchronous. All threads in the VM are resumed, unless the |
| 822 | * SINGLE_THREADED flag is set. |
| 823 | * |
| 824 | * If you ask Eclipse to "inspect" an object (or ask JDB to "print" an |
| 825 | * object), it will try to invoke the object's toString() function. This |
| 826 | * feature becomes crucial when examining ArrayLists with Eclipse. |
| 827 | */ |
| 828 | static JdwpError handleOR_InvokeMethod(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 829 | ObjectId objectId = ReadObjectId(&buf); |
| 830 | ObjectId threadId = ReadObjectId(&buf); |
| 831 | RefTypeId classId = ReadRefTypeId(&buf); |
| 832 | MethodId methodId = ReadMethodId(&buf); |
| 833 | |
| 834 | return finishInvoke(state, buf, dataLen, pReply, threadId, objectId, classId, methodId, false); |
| 835 | } |
| 836 | |
| 837 | /* |
| 838 | * Disable garbage collection of the specified object. |
| 839 | */ |
| 840 | static JdwpError handleOR_DisableCollection(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 841 | // this is currently a no-op |
| 842 | return ERR_NONE; |
| 843 | } |
| 844 | |
| 845 | /* |
| 846 | * Enable garbage collection of the specified object. |
| 847 | */ |
| 848 | static JdwpError handleOR_EnableCollection(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 849 | // this is currently a no-op |
| 850 | return ERR_NONE; |
| 851 | } |
| 852 | |
| 853 | /* |
| 854 | * Determine whether an object has been garbage collected. |
| 855 | */ |
| 856 | static JdwpError handleOR_IsCollected(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 857 | ObjectId objectId; |
| 858 | |
| 859 | objectId = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 860 | VLOG(jdwp) << StringPrintf(" Req IsCollected(0x%llx)", objectId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 861 | |
| 862 | // TODO: currently returning false; must integrate with GC |
| 863 | expandBufAdd1(pReply, 0); |
| 864 | |
| 865 | return ERR_NONE; |
| 866 | } |
| 867 | |
| 868 | /* |
| 869 | * Return the string value in a string object. |
| 870 | */ |
| 871 | static JdwpError handleSR_Value(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 872 | ObjectId stringObject = ReadObjectId(&buf); |
Elliott Hughes | 68fdbd0 | 2011-11-29 19:22:47 -0800 | [diff] [blame] | 873 | std::string str(Dbg::StringToUtf8(stringObject)); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 874 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 875 | VLOG(jdwp) << StringPrintf(" Req for str %llx --> '%s'", stringObject, PrintableString(str).c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 876 | |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 877 | expandBufAddUtf8String(pReply, str); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 878 | |
| 879 | return ERR_NONE; |
| 880 | } |
| 881 | |
| 882 | /* |
| 883 | * Return a thread's name. |
| 884 | */ |
| 885 | static JdwpError handleTR_Name(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 886 | ObjectId threadId = ReadObjectId(&buf); |
| 887 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 888 | VLOG(jdwp) << StringPrintf(" Req for name of thread 0x%llx", threadId); |
Elliott Hughes | a2e54f6 | 2011-11-17 13:01:30 -0800 | [diff] [blame] | 889 | std::string name; |
| 890 | if (!Dbg::GetThreadName(threadId, name)) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 891 | return ERR_INVALID_THREAD; |
| 892 | } |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 893 | VLOG(jdwp) << StringPrintf(" Name of thread 0x%llx is \"%s\"", threadId, name.c_str()); |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 894 | expandBufAddUtf8String(pReply, name); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 895 | |
| 896 | return ERR_NONE; |
| 897 | } |
| 898 | |
| 899 | /* |
| 900 | * Suspend the specified thread. |
| 901 | * |
| 902 | * It's supposed to remain suspended even if interpreted code wants to |
| 903 | * resume it; only the JDI is allowed to resume it. |
| 904 | */ |
| 905 | static JdwpError handleTR_Suspend(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 906 | ObjectId threadId = ReadObjectId(&buf); |
| 907 | |
| 908 | if (threadId == Dbg::GetThreadSelfId()) { |
| 909 | LOG(INFO) << " Warning: ignoring request to suspend self"; |
| 910 | return ERR_THREAD_NOT_SUSPENDED; |
| 911 | } |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 912 | VLOG(jdwp) << StringPrintf(" Req to suspend thread 0x%llx", threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 913 | Dbg::SuspendThread(threadId); |
| 914 | return ERR_NONE; |
| 915 | } |
| 916 | |
| 917 | /* |
| 918 | * Resume the specified thread. |
| 919 | */ |
| 920 | static JdwpError handleTR_Resume(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 921 | ObjectId threadId = ReadObjectId(&buf); |
| 922 | |
| 923 | if (threadId == Dbg::GetThreadSelfId()) { |
| 924 | LOG(INFO) << " Warning: ignoring request to resume self"; |
| 925 | return ERR_NONE; |
| 926 | } |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 927 | VLOG(jdwp) << StringPrintf(" Req to resume thread 0x%llx", threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 928 | Dbg::ResumeThread(threadId); |
| 929 | return ERR_NONE; |
| 930 | } |
| 931 | |
| 932 | /* |
| 933 | * Return status of specified thread. |
| 934 | */ |
| 935 | static JdwpError handleTR_Status(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 936 | ObjectId threadId = ReadObjectId(&buf); |
| 937 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 938 | VLOG(jdwp) << StringPrintf(" Req for status of thread 0x%llx", threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 939 | |
Elliott Hughes | 3d30d9b | 2011-12-07 17:35:48 -0800 | [diff] [blame] | 940 | JDWP::JdwpThreadStatus threadStatus; |
| 941 | JDWP::JdwpSuspendStatus suspendStatus; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 942 | if (!Dbg::GetThreadStatus(threadId, &threadStatus, &suspendStatus)) { |
| 943 | return ERR_INVALID_THREAD; |
| 944 | } |
| 945 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 946 | VLOG(jdwp) << " --> " << threadStatus << ", " << suspendStatus; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 947 | |
| 948 | expandBufAdd4BE(pReply, threadStatus); |
| 949 | expandBufAdd4BE(pReply, suspendStatus); |
| 950 | |
| 951 | return ERR_NONE; |
| 952 | } |
| 953 | |
| 954 | /* |
| 955 | * Return the thread group that the specified thread is a member of. |
| 956 | */ |
| 957 | static JdwpError handleTR_ThreadGroup(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 958 | ObjectId threadId = ReadObjectId(&buf); |
| 959 | |
| 960 | /* currently not handling these */ |
| 961 | ObjectId threadGroupId = Dbg::GetThreadGroup(threadId); |
| 962 | expandBufAddObjectId(pReply, threadGroupId); |
| 963 | |
| 964 | return ERR_NONE; |
| 965 | } |
| 966 | |
| 967 | /* |
| 968 | * Return the current call stack of a suspended thread. |
| 969 | * |
| 970 | * If the thread isn't suspended, the error code isn't defined, but should |
| 971 | * be THREAD_NOT_SUSPENDED. |
| 972 | */ |
| 973 | static JdwpError handleTR_Frames(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 974 | ObjectId threadId = ReadObjectId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 975 | uint32_t startFrame = Read4BE(&buf); |
| 976 | uint32_t length = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 977 | |
| 978 | if (!Dbg::ThreadExists(threadId)) { |
| 979 | return ERR_INVALID_THREAD; |
| 980 | } |
| 981 | if (!Dbg::IsSuspended(threadId)) { |
Elliott Hughes | a2e54f6 | 2011-11-17 13:01:30 -0800 | [diff] [blame] | 982 | LOG(WARNING) << StringPrintf(" Rejecting req for frames in running thread %llx", threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 983 | return ERR_THREAD_NOT_SUSPENDED; |
| 984 | } |
| 985 | |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 986 | size_t frameCount = Dbg::GetThreadFrameCount(threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 987 | |
Elliott Hughes | abd04b9 | 2012-01-18 22:46:41 -0800 | [diff] [blame] | 988 | VLOG(jdwp) << StringPrintf(" Request for frames: threadId=%llx start=%d length=%d [count=%zd]", threadId, startFrame, length, frameCount); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 989 | if (frameCount <= 0) { |
| 990 | return ERR_THREAD_NOT_SUSPENDED; /* == 0 means 100% native */ |
| 991 | } |
| 992 | if (length == (uint32_t) -1) { |
| 993 | length = frameCount; |
| 994 | } |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 995 | CHECK_GE(startFrame, 0U); |
| 996 | CHECK_LT(startFrame, frameCount); |
| 997 | CHECK_LE(startFrame + length, frameCount); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 998 | |
| 999 | uint32_t frames = length; |
| 1000 | expandBufAdd4BE(pReply, frames); |
| 1001 | for (uint32_t i = startFrame; i < (startFrame+length); i++) { |
| 1002 | FrameId frameId; |
| 1003 | JdwpLocation loc; |
| 1004 | |
| 1005 | Dbg::GetThreadFrame(threadId, i, &frameId, &loc); |
| 1006 | |
| 1007 | expandBufAdd8BE(pReply, frameId); |
| 1008 | AddLocation(pReply, &loc); |
| 1009 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1010 | 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 Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1011 | } |
| 1012 | |
| 1013 | return ERR_NONE; |
| 1014 | } |
| 1015 | |
| 1016 | /* |
| 1017 | * Returns the #of frames on the specified thread, which must be suspended. |
| 1018 | */ |
| 1019 | static JdwpError handleTR_FrameCount(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1020 | ObjectId threadId = ReadObjectId(&buf); |
| 1021 | |
| 1022 | if (!Dbg::ThreadExists(threadId)) { |
| 1023 | return ERR_INVALID_THREAD; |
| 1024 | } |
| 1025 | if (!Dbg::IsSuspended(threadId)) { |
Elliott Hughes | a2e54f6 | 2011-11-17 13:01:30 -0800 | [diff] [blame] | 1026 | LOG(WARNING) << StringPrintf(" Rejecting req for frames in running thread %llx", threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1027 | return ERR_THREAD_NOT_SUSPENDED; |
| 1028 | } |
| 1029 | |
| 1030 | int frameCount = Dbg::GetThreadFrameCount(threadId); |
| 1031 | if (frameCount < 0) { |
| 1032 | return ERR_INVALID_THREAD; |
| 1033 | } |
| 1034 | expandBufAdd4BE(pReply, (uint32_t)frameCount); |
| 1035 | |
| 1036 | return ERR_NONE; |
| 1037 | } |
| 1038 | |
| 1039 | /* |
| 1040 | * Get the monitor that the thread is waiting on. |
| 1041 | */ |
| 1042 | static JdwpError handleTR_CurrentContendedMonitor(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1043 | ObjectId threadId; |
| 1044 | |
| 1045 | threadId = ReadObjectId(&buf); |
| 1046 | |
| 1047 | // TODO: create an Object to represent the monitor (we're currently |
| 1048 | // just using a raw Monitor struct in the VM) |
| 1049 | |
| 1050 | return ERR_NOT_IMPLEMENTED; |
| 1051 | } |
| 1052 | |
| 1053 | /* |
| 1054 | * Return the suspend count for the specified thread. |
| 1055 | * |
| 1056 | * (The thread *might* still be running -- it might not have examined |
| 1057 | * its suspend count recently.) |
| 1058 | */ |
| 1059 | static JdwpError handleTR_SuspendCount(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1060 | ObjectId threadId = ReadObjectId(&buf); |
| 1061 | |
| 1062 | uint32_t suspendCount = Dbg::GetThreadSuspendCount(threadId); |
| 1063 | expandBufAdd4BE(pReply, suspendCount); |
| 1064 | |
| 1065 | return ERR_NONE; |
| 1066 | } |
| 1067 | |
| 1068 | /* |
| 1069 | * Return the name of a thread group. |
| 1070 | * |
| 1071 | * The Eclipse debugger recognizes "main" and "system" as special. |
| 1072 | */ |
| 1073 | static JdwpError handleTGR_Name(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1074 | ObjectId threadGroupId = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1075 | VLOG(jdwp) << StringPrintf(" Req for name of threadGroupId=0x%llx", threadGroupId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1076 | |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 1077 | expandBufAddUtf8String(pReply, Dbg::GetThreadGroupName(threadGroupId)); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1078 | |
| 1079 | return ERR_NONE; |
| 1080 | } |
| 1081 | |
| 1082 | /* |
| 1083 | * Returns the thread group -- if any -- that contains the specified |
| 1084 | * thread group. |
| 1085 | */ |
| 1086 | static JdwpError handleTGR_Parent(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1087 | ObjectId groupId = ReadObjectId(&buf); |
| 1088 | |
| 1089 | ObjectId parentGroup = Dbg::GetThreadGroupParent(groupId); |
| 1090 | expandBufAddObjectId(pReply, parentGroup); |
| 1091 | |
| 1092 | return ERR_NONE; |
| 1093 | } |
| 1094 | |
| 1095 | /* |
| 1096 | * Return the active threads and thread groups that are part of the |
| 1097 | * specified thread group. |
| 1098 | */ |
| 1099 | static JdwpError handleTGR_Children(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1100 | ObjectId threadGroupId = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1101 | VLOG(jdwp) << StringPrintf(" Req for threads in threadGroupId=0x%llx", threadGroupId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1102 | |
| 1103 | ObjectId* pThreadIds; |
| 1104 | uint32_t threadCount; |
| 1105 | Dbg::GetThreadGroupThreads(threadGroupId, &pThreadIds, &threadCount); |
| 1106 | |
| 1107 | expandBufAdd4BE(pReply, threadCount); |
| 1108 | |
| 1109 | for (uint32_t i = 0; i < threadCount; i++) { |
| 1110 | expandBufAddObjectId(pReply, pThreadIds[i]); |
| 1111 | } |
| 1112 | free(pThreadIds); |
| 1113 | |
| 1114 | /* |
| 1115 | * TODO: finish support for child groups |
| 1116 | * |
| 1117 | * For now, just show that "main" is a child of "system". |
| 1118 | */ |
| 1119 | if (threadGroupId == Dbg::GetSystemThreadGroupId()) { |
| 1120 | expandBufAdd4BE(pReply, 1); |
| 1121 | expandBufAddObjectId(pReply, Dbg::GetMainThreadGroupId()); |
| 1122 | } else { |
| 1123 | expandBufAdd4BE(pReply, 0); |
| 1124 | } |
| 1125 | |
| 1126 | return ERR_NONE; |
| 1127 | } |
| 1128 | |
| 1129 | /* |
| 1130 | * Return the #of components in the array. |
| 1131 | */ |
| 1132 | static JdwpError handleAR_Length(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1133 | ObjectId arrayId = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1134 | VLOG(jdwp) << StringPrintf(" Req for length of array 0x%llx", arrayId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1135 | |
| 1136 | uint32_t arrayLength = Dbg::GetArrayLength(arrayId); |
| 1137 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1138 | VLOG(jdwp) << StringPrintf(" --> %d", arrayLength); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1139 | |
| 1140 | expandBufAdd4BE(pReply, arrayLength); |
| 1141 | |
| 1142 | return ERR_NONE; |
| 1143 | } |
| 1144 | |
| 1145 | /* |
| 1146 | * Return the values from an array. |
| 1147 | */ |
| 1148 | static JdwpError handleAR_GetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1149 | ObjectId arrayId = ReadObjectId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1150 | uint32_t firstIndex = Read4BE(&buf); |
| 1151 | uint32_t length = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1152 | |
| 1153 | uint8_t tag = Dbg::GetArrayElementTag(arrayId); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1154 | VLOG(jdwp) << StringPrintf(" Req for array values 0x%llx first=%d len=%d (elem tag=%c)", arrayId, firstIndex, length, tag); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1155 | |
| 1156 | expandBufAdd1(pReply, tag); |
| 1157 | expandBufAdd4BE(pReply, length); |
| 1158 | |
| 1159 | if (!Dbg::OutputArray(arrayId, firstIndex, length, pReply)) { |
| 1160 | return ERR_INVALID_LENGTH; |
| 1161 | } |
| 1162 | |
| 1163 | return ERR_NONE; |
| 1164 | } |
| 1165 | |
| 1166 | /* |
| 1167 | * Set values in an array. |
| 1168 | */ |
| 1169 | static JdwpError handleAR_SetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1170 | ObjectId arrayId = ReadObjectId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1171 | uint32_t firstIndex = Read4BE(&buf); |
| 1172 | uint32_t values = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1173 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1174 | VLOG(jdwp) << StringPrintf(" Req to set array values 0x%llx first=%d count=%d", arrayId, firstIndex, values); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1175 | |
| 1176 | if (!Dbg::SetArrayElements(arrayId, firstIndex, values, buf)) { |
| 1177 | return ERR_INVALID_LENGTH; |
| 1178 | } |
| 1179 | |
| 1180 | return ERR_NONE; |
| 1181 | } |
| 1182 | |
| 1183 | /* |
| 1184 | * Return the set of classes visible to a class loader. All classes which |
| 1185 | * have the class loader as a defining or initiating loader are returned. |
| 1186 | */ |
| 1187 | static JdwpError handleCLR_VisibleClasses(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1188 | ObjectId classLoaderObject; |
| 1189 | uint32_t numClasses = 0; |
| 1190 | RefTypeId* classRefBuf = NULL; |
| 1191 | int i; |
| 1192 | |
| 1193 | classLoaderObject = ReadObjectId(&buf); |
| 1194 | |
| 1195 | Dbg::GetVisibleClassList(classLoaderObject, &numClasses, &classRefBuf); |
| 1196 | |
| 1197 | expandBufAdd4BE(pReply, numClasses); |
| 1198 | for (i = 0; i < (int) numClasses; i++) { |
| 1199 | uint8_t refTypeTag = Dbg::GetClassObjectType(classRefBuf[i]); |
| 1200 | |
| 1201 | expandBufAdd1(pReply, refTypeTag); |
| 1202 | expandBufAddRefTypeId(pReply, classRefBuf[i]); |
| 1203 | } |
| 1204 | |
| 1205 | return ERR_NONE; |
| 1206 | } |
| 1207 | |
| 1208 | /* |
| 1209 | * Return a newly-allocated string in which all occurrences of '.' have |
| 1210 | * been changed to '/'. If we find a '/' in the original string, NULL |
| 1211 | * is returned to avoid ambiguity. |
| 1212 | */ |
| 1213 | char* dvmDotToSlash(const char* str) { |
| 1214 | char* newStr = strdup(str); |
| 1215 | char* cp = newStr; |
| 1216 | |
| 1217 | if (newStr == NULL) { |
| 1218 | return NULL; |
| 1219 | } |
| 1220 | |
| 1221 | while (*cp != '\0') { |
| 1222 | if (*cp == '/') { |
| 1223 | CHECK(false); |
| 1224 | return NULL; |
| 1225 | } |
| 1226 | if (*cp == '.') { |
| 1227 | *cp = '/'; |
| 1228 | } |
| 1229 | cp++; |
| 1230 | } |
| 1231 | |
| 1232 | return newStr; |
| 1233 | } |
| 1234 | |
| 1235 | /* |
| 1236 | * Set an event trigger. |
| 1237 | * |
| 1238 | * Reply with a requestID. |
| 1239 | */ |
| 1240 | static JdwpError handleER_Set(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1241 | const uint8_t* origBuf = buf; |
| 1242 | |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1243 | uint8_t eventKind = Read1(&buf); |
| 1244 | uint8_t suspendPolicy = Read1(&buf); |
| 1245 | uint32_t modifierCount = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1246 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1247 | VLOG(jdwp) << " Set(kind=" << JdwpEventKind(eventKind) |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1248 | << " suspend=" << JdwpSuspendPolicy(suspendPolicy) |
| 1249 | << " mods=" << modifierCount << ")"; |
| 1250 | |
| 1251 | CHECK_LT(modifierCount, 256U); /* reasonableness check */ |
| 1252 | |
| 1253 | JdwpEvent* pEvent = EventAlloc(modifierCount); |
| 1254 | pEvent->eventKind = static_cast<JdwpEventKind>(eventKind); |
| 1255 | pEvent->suspendPolicy = static_cast<JdwpSuspendPolicy>(suspendPolicy); |
| 1256 | pEvent->modCount = modifierCount; |
| 1257 | |
| 1258 | /* |
| 1259 | * Read modifiers. Ordering may be significant (see explanation of Count |
| 1260 | * mods in JDWP doc). |
| 1261 | */ |
| 1262 | for (uint32_t idx = 0; idx < modifierCount; idx++) { |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1263 | JdwpModKind modKind = static_cast<JdwpModKind>(Read1(&buf)); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1264 | |
| 1265 | pEvent->mods[idx].modKind = modKind; |
| 1266 | |
| 1267 | switch (modKind) { |
| 1268 | case MK_COUNT: /* report once, when "--count" reaches 0 */ |
| 1269 | { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1270 | uint32_t count = Read4BE(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1271 | VLOG(jdwp) << " Count: " << count; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1272 | if (count == 0) { |
| 1273 | return ERR_INVALID_COUNT; |
| 1274 | } |
| 1275 | pEvent->mods[idx].count.count = count; |
| 1276 | } |
| 1277 | break; |
| 1278 | case MK_CONDITIONAL: /* conditional on expression) */ |
| 1279 | { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1280 | uint32_t exprId = Read4BE(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1281 | VLOG(jdwp) << " Conditional: " << exprId; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1282 | pEvent->mods[idx].conditional.exprId = exprId; |
| 1283 | } |
| 1284 | break; |
| 1285 | case MK_THREAD_ONLY: /* only report events in specified thread */ |
| 1286 | { |
| 1287 | ObjectId threadId = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1288 | VLOG(jdwp) << StringPrintf(" ThreadOnly: %llx", threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1289 | pEvent->mods[idx].threadOnly.threadId = threadId; |
| 1290 | } |
| 1291 | break; |
| 1292 | case MK_CLASS_ONLY: /* for ClassPrepare, MethodEntry */ |
| 1293 | { |
| 1294 | RefTypeId clazzId = ReadRefTypeId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1295 | VLOG(jdwp) << StringPrintf(" ClassOnly: %llx (%s)", clazzId, Dbg::GetClassDescriptor(clazzId).c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1296 | pEvent->mods[idx].classOnly.refTypeId = clazzId; |
| 1297 | } |
| 1298 | break; |
| 1299 | case MK_CLASS_MATCH: /* restrict events to matching classes */ |
| 1300 | { |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1301 | std::string pattern(ReadNewUtf8String(&buf)); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1302 | VLOG(jdwp) << StringPrintf(" ClassMatch: '%s'", pattern.c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1303 | /* pattern is "java.foo.*", we want "java/foo/ *" */ |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1304 | pEvent->mods[idx].classMatch.classPattern = dvmDotToSlash(pattern.c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1305 | } |
| 1306 | break; |
| 1307 | case MK_CLASS_EXCLUDE: /* restrict events to non-matching classes */ |
| 1308 | { |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1309 | std::string pattern(ReadNewUtf8String(&buf)); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1310 | VLOG(jdwp) << StringPrintf(" ClassExclude: '%s'", pattern.c_str()); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1311 | pEvent->mods[idx].classExclude.classPattern = dvmDotToSlash(pattern.c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1312 | } |
| 1313 | break; |
| 1314 | case MK_LOCATION_ONLY: /* restrict certain events based on loc */ |
| 1315 | { |
| 1316 | JdwpLocation loc; |
| 1317 | |
| 1318 | jdwpReadLocation(&buf, &loc); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1319 | VLOG(jdwp) << StringPrintf(" LocationOnly: typeTag=%d classId=%llx methodId=%x idx=%llx", |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1320 | loc.typeTag, loc.classId, loc.methodId, loc.idx); |
| 1321 | pEvent->mods[idx].locationOnly.loc = loc; |
| 1322 | } |
| 1323 | break; |
| 1324 | case MK_EXCEPTION_ONLY: /* modifies EK_EXCEPTION events */ |
| 1325 | { |
| 1326 | RefTypeId exceptionOrNull; /* null == all exceptions */ |
| 1327 | uint8_t caught, uncaught; |
| 1328 | |
| 1329 | exceptionOrNull = ReadRefTypeId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1330 | caught = Read1(&buf); |
| 1331 | uncaught = Read1(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1332 | VLOG(jdwp) << StringPrintf(" ExceptionOnly: type=%llx(%s) caught=%d uncaught=%d", |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 1333 | exceptionOrNull, (exceptionOrNull == 0) ? "null" : Dbg::GetClassDescriptor(exceptionOrNull).c_str(), caught, uncaught); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1334 | |
| 1335 | pEvent->mods[idx].exceptionOnly.refTypeId = exceptionOrNull; |
| 1336 | pEvent->mods[idx].exceptionOnly.caught = caught; |
| 1337 | pEvent->mods[idx].exceptionOnly.uncaught = uncaught; |
| 1338 | } |
| 1339 | break; |
| 1340 | case MK_FIELD_ONLY: /* for field access/mod events */ |
| 1341 | { |
| 1342 | RefTypeId declaring = ReadRefTypeId(&buf); |
| 1343 | FieldId fieldId = ReadFieldId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1344 | VLOG(jdwp) << StringPrintf(" FieldOnly: %llx %x", declaring, fieldId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1345 | pEvent->mods[idx].fieldOnly.refTypeId = declaring; |
| 1346 | pEvent->mods[idx].fieldOnly.fieldId = fieldId; |
| 1347 | } |
| 1348 | break; |
| 1349 | case MK_STEP: /* for use with EK_SINGLE_STEP */ |
| 1350 | { |
| 1351 | ObjectId threadId; |
| 1352 | uint32_t size, depth; |
| 1353 | |
| 1354 | threadId = ReadObjectId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1355 | size = Read4BE(&buf); |
| 1356 | depth = Read4BE(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1357 | VLOG(jdwp) << StringPrintf(" Step: thread=%llx", threadId) |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1358 | << " size=" << JdwpStepSize(size) << " depth=" << JdwpStepDepth(depth); |
| 1359 | |
| 1360 | pEvent->mods[idx].step.threadId = threadId; |
| 1361 | pEvent->mods[idx].step.size = size; |
| 1362 | pEvent->mods[idx].step.depth = depth; |
| 1363 | } |
| 1364 | break; |
| 1365 | case MK_INSTANCE_ONLY: /* report events related to a specific obj */ |
| 1366 | { |
| 1367 | ObjectId instance = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1368 | VLOG(jdwp) << StringPrintf(" InstanceOnly: %llx", instance); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1369 | pEvent->mods[idx].instanceOnly.objectId = instance; |
| 1370 | } |
| 1371 | break; |
| 1372 | default: |
| 1373 | LOG(WARNING) << "GLITCH: unsupported modKind=" << modKind; |
| 1374 | break; |
| 1375 | } |
| 1376 | } |
| 1377 | |
| 1378 | /* |
| 1379 | * Make sure we consumed all data. It is possible that the remote side |
| 1380 | * has sent us bad stuff, but for now we blame ourselves. |
| 1381 | */ |
| 1382 | if (buf != origBuf + dataLen) { |
| 1383 | LOG(WARNING) << "GLITCH: dataLen is " << dataLen << ", we have consumed " << (buf - origBuf); |
| 1384 | } |
| 1385 | |
| 1386 | /* |
| 1387 | * We reply with an integer "requestID". |
| 1388 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 1389 | uint32_t requestId = state->NextEventSerial(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1390 | expandBufAdd4BE(pReply, requestId); |
| 1391 | |
| 1392 | pEvent->requestId = requestId; |
| 1393 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1394 | VLOG(jdwp) << StringPrintf(" --> event requestId=%#x", requestId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1395 | |
| 1396 | /* add it to the list */ |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 1397 | JdwpError err = state->RegisterEvent(pEvent); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1398 | if (err != ERR_NONE) { |
| 1399 | /* registration failed, probably because event is bogus */ |
| 1400 | EventFree(pEvent); |
| 1401 | LOG(WARNING) << "WARNING: event request rejected"; |
| 1402 | } |
| 1403 | return err; |
| 1404 | } |
| 1405 | |
| 1406 | /* |
| 1407 | * Clear an event. Failure to find an event with a matching ID is a no-op |
| 1408 | * and does not return an error. |
| 1409 | */ |
| 1410 | static JdwpError handleER_Clear(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1411 | uint8_t eventKind; |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1412 | eventKind = Read1(&buf); |
| 1413 | uint32_t requestId = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1414 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1415 | VLOG(jdwp) << StringPrintf(" Req to clear eventKind=%d requestId=%#x", eventKind, requestId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1416 | |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 1417 | state->UnregisterEventById(requestId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1418 | |
| 1419 | return ERR_NONE; |
| 1420 | } |
| 1421 | |
| 1422 | /* |
| 1423 | * Return the values of arguments and local variables. |
| 1424 | */ |
| 1425 | static JdwpError handleSF_GetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1426 | ObjectId threadId = ReadObjectId(&buf); |
| 1427 | FrameId frameId = ReadFrameId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1428 | uint32_t slots = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1429 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1430 | VLOG(jdwp) << StringPrintf(" Req for %d slots in threadId=%llx frameId=%llx", slots, threadId, frameId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1431 | |
| 1432 | expandBufAdd4BE(pReply, slots); /* "int values" */ |
| 1433 | for (uint32_t i = 0; i < slots; i++) { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1434 | uint32_t slot = Read4BE(&buf); |
Elliott Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 1435 | JDWP::JdwpTag reqSigByte = ReadTag(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1436 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1437 | VLOG(jdwp) << StringPrintf(" --> slot %d '%c'", slot, reqSigByte); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1438 | |
Elliott Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 1439 | size_t width = Dbg::GetTagWidth(reqSigByte); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1440 | uint8_t* ptr = expandBufAddSpace(pReply, width+1); |
| 1441 | Dbg::GetLocalValue(threadId, frameId, slot, reqSigByte, ptr, width); |
| 1442 | } |
| 1443 | |
| 1444 | return ERR_NONE; |
| 1445 | } |
| 1446 | |
| 1447 | /* |
| 1448 | * Set the values of arguments and local variables. |
| 1449 | */ |
| 1450 | static JdwpError handleSF_SetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1451 | ObjectId threadId = ReadObjectId(&buf); |
| 1452 | FrameId frameId = ReadFrameId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1453 | uint32_t slots = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1454 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1455 | VLOG(jdwp) << StringPrintf(" Req to set %d slots in threadId=%llx frameId=%llx", slots, threadId, frameId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1456 | |
| 1457 | for (uint32_t i = 0; i < slots; i++) { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1458 | uint32_t slot = Read4BE(&buf); |
Elliott Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 1459 | JDWP::JdwpTag sigByte = ReadTag(&buf); |
Elliott Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 1460 | size_t width = Dbg::GetTagWidth(sigByte); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1461 | uint64_t value = jdwpReadValue(&buf, width); |
| 1462 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1463 | VLOG(jdwp) << StringPrintf(" --> slot %d '%c' %llx", slot, sigByte, value); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1464 | Dbg::SetLocalValue(threadId, frameId, slot, sigByte, value, width); |
| 1465 | } |
| 1466 | |
| 1467 | return ERR_NONE; |
| 1468 | } |
| 1469 | |
| 1470 | /* |
| 1471 | * Returns the value of "this" for the specified frame. |
| 1472 | */ |
| 1473 | static JdwpError handleSF_ThisObject(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | d07986f | 2011-12-06 18:27:45 -0800 | [diff] [blame] | 1474 | ReadObjectId(&buf); // Skip thread id. |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1475 | FrameId frameId = ReadFrameId(&buf); |
| 1476 | |
| 1477 | ObjectId objectId; |
Elliott Hughes | d07986f | 2011-12-06 18:27:45 -0800 | [diff] [blame] | 1478 | if (!Dbg::GetThisObject(frameId, &objectId)) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1479 | return ERR_INVALID_FRAMEID; |
| 1480 | } |
| 1481 | |
| 1482 | uint8_t objectTag = Dbg::GetObjectTag(objectId); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1483 | VLOG(jdwp) << StringPrintf(" Req for 'this' in frame=%llx --> %llx '%c'", frameId, objectId, (char)objectTag); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1484 | |
| 1485 | expandBufAdd1(pReply, objectTag); |
| 1486 | expandBufAddObjectId(pReply, objectId); |
| 1487 | |
| 1488 | return ERR_NONE; |
| 1489 | } |
| 1490 | |
| 1491 | /* |
| 1492 | * Return the reference type reflected by this class object. |
| 1493 | * |
| 1494 | * This appears to be required because ReferenceTypeId values are NEVER |
| 1495 | * reused, whereas ClassIds can be recycled like any other object. (Either |
| 1496 | * that, or I have no idea what this is for.) |
| 1497 | */ |
| 1498 | static JdwpError handleCOR_ReflectedType(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1499 | RefTypeId classObjectId = ReadRefTypeId(&buf); |
| 1500 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1501 | VLOG(jdwp) << StringPrintf(" Req for refTypeId for class=%llx (%s)", classObjectId, Dbg::GetClassDescriptor(classObjectId).c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1502 | |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1503 | bool is_interface; |
| 1504 | if (!Dbg::IsInterface(classObjectId, is_interface)) { |
| 1505 | return ERR_INVALID_CLASS; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1506 | } |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1507 | |
| 1508 | expandBufAdd1(pReply, is_interface ? TT_INTERFACE : TT_CLASS); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1509 | expandBufAddRefTypeId(pReply, classObjectId); |
| 1510 | |
| 1511 | return ERR_NONE; |
| 1512 | } |
| 1513 | |
| 1514 | /* |
| 1515 | * Handle a DDM packet with a single chunk in it. |
| 1516 | */ |
| 1517 | static JdwpError handleDDM_Chunk(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1518 | uint8_t* replyBuf = NULL; |
| 1519 | int replyLen = -1; |
| 1520 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1521 | VLOG(jdwp) << StringPrintf(" Handling DDM packet (%.4s)", buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1522 | |
| 1523 | /* |
| 1524 | * On first DDM packet, notify all handlers that DDM is running. |
| 1525 | */ |
| 1526 | if (!state->ddmActive) { |
| 1527 | state->ddmActive = true; |
| 1528 | Dbg::DdmConnected(); |
| 1529 | } |
| 1530 | |
| 1531 | /* |
| 1532 | * If they want to send something back, we copy it into the buffer. |
| 1533 | * A no-copy approach would be nicer. |
| 1534 | * |
| 1535 | * TODO: consider altering the JDWP stuff to hold the packet header |
| 1536 | * in a separate buffer. That would allow us to writev() DDM traffic |
| 1537 | * instead of copying it into the expanding buffer. The reduction in |
| 1538 | * heap requirements is probably more valuable than the efficiency. |
| 1539 | */ |
| 1540 | if (Dbg::DdmHandlePacket(buf, dataLen, &replyBuf, &replyLen)) { |
| 1541 | CHECK(replyLen > 0 && replyLen < 1*1024*1024); |
| 1542 | memcpy(expandBufAddSpace(pReply, replyLen), replyBuf, replyLen); |
| 1543 | free(replyBuf); |
| 1544 | } |
| 1545 | return ERR_NONE; |
| 1546 | } |
| 1547 | |
| 1548 | /* |
| 1549 | * Handler map decl. |
| 1550 | */ |
| 1551 | typedef JdwpError (*JdwpRequestHandler)(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* reply); |
| 1552 | |
| 1553 | struct JdwpHandlerMap { |
| 1554 | uint8_t cmdSet; |
| 1555 | uint8_t cmd; |
| 1556 | JdwpRequestHandler func; |
| 1557 | const char* descr; |
| 1558 | }; |
| 1559 | |
| 1560 | /* |
| 1561 | * Map commands to functions. |
| 1562 | * |
| 1563 | * Command sets 0-63 are incoming requests, 64-127 are outbound requests, |
| 1564 | * and 128-256 are vendor-defined. |
| 1565 | */ |
| 1566 | static const JdwpHandlerMap gHandlerMap[] = { |
| 1567 | /* VirtualMachine command set (1) */ |
| 1568 | { 1, 1, handleVM_Version, "VirtualMachine.Version" }, |
| 1569 | { 1, 2, handleVM_ClassesBySignature, "VirtualMachine.ClassesBySignature" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1570 | { 1, 3, NULL, "VirtualMachine.AllClasses" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1571 | { 1, 4, handleVM_AllThreads, "VirtualMachine.AllThreads" }, |
| 1572 | { 1, 5, handleVM_TopLevelThreadGroups, "VirtualMachine.TopLevelThreadGroups" }, |
| 1573 | { 1, 6, handleVM_Dispose, "VirtualMachine.Dispose" }, |
| 1574 | { 1, 7, handleVM_IDSizes, "VirtualMachine.IDSizes" }, |
| 1575 | { 1, 8, handleVM_Suspend, "VirtualMachine.Suspend" }, |
| 1576 | { 1, 9, handleVM_Resume, "VirtualMachine.Resume" }, |
| 1577 | { 1, 10, handleVM_Exit, "VirtualMachine.Exit" }, |
| 1578 | { 1, 11, handleVM_CreateString, "VirtualMachine.CreateString" }, |
| 1579 | { 1, 12, handleVM_Capabilities, "VirtualMachine.Capabilities" }, |
| 1580 | { 1, 13, handleVM_ClassPaths, "VirtualMachine.ClassPaths" }, |
| 1581 | { 1, 14, HandleVM_DisposeObjects, "VirtualMachine.DisposeObjects" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1582 | { 1, 15, NULL, "VirtualMachine.HoldEvents" }, |
| 1583 | { 1, 16, NULL, "VirtualMachine.ReleaseEvents" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1584 | { 1, 17, handleVM_CapabilitiesNew, "VirtualMachine.CapabilitiesNew" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1585 | { 1, 18, NULL, "VirtualMachine.RedefineClasses" }, |
| 1586 | { 1, 19, NULL, "VirtualMachine.SetDefaultStratum" }, |
| 1587 | { 1, 20, handleVM_AllClassesWithGeneric, "VirtualMachine.AllClassesWithGeneric" }, |
| 1588 | { 1, 21, NULL, "VirtualMachine.InstanceCounts" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1589 | |
| 1590 | /* ReferenceType command set (2) */ |
| 1591 | { 2, 1, handleRT_Signature, "ReferenceType.Signature" }, |
| 1592 | { 2, 2, handleRT_ClassLoader, "ReferenceType.ClassLoader" }, |
| 1593 | { 2, 3, handleRT_Modifiers, "ReferenceType.Modifiers" }, |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1594 | { 2, 4, handleRT_Fields, "ReferenceType.Fields" }, |
| 1595 | { 2, 5, handleRT_Methods, "ReferenceType.Methods" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1596 | { 2, 6, handleRT_GetValues, "ReferenceType.GetValues" }, |
| 1597 | { 2, 7, handleRT_SourceFile, "ReferenceType.SourceFile" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1598 | { 2, 8, NULL, "ReferenceType.NestedTypes" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1599 | { 2, 9, handleRT_Status, "ReferenceType.Status" }, |
| 1600 | { 2, 10, handleRT_Interfaces, "ReferenceType.Interfaces" }, |
| 1601 | { 2, 11, handleRT_ClassObject, "ReferenceType.ClassObject" }, |
| 1602 | { 2, 12, handleRT_SourceDebugExtension, "ReferenceType.SourceDebugExtension" }, |
| 1603 | { 2, 13, handleRT_SignatureWithGeneric, "ReferenceType.SignatureWithGeneric" }, |
| 1604 | { 2, 14, handleRT_FieldsWithGeneric, "ReferenceType.FieldsWithGeneric" }, |
| 1605 | { 2, 15, handleRT_MethodsWithGeneric, "ReferenceType.MethodsWithGeneric" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1606 | { 2, 16, NULL, "ReferenceType.Instances" }, |
| 1607 | { 2, 17, NULL, "ReferenceType.ClassFileVersion" }, |
| 1608 | { 2, 18, NULL, "ReferenceType.ConstantPool" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1609 | |
| 1610 | /* ClassType command set (3) */ |
| 1611 | { 3, 1, handleCT_Superclass, "ClassType.Superclass" }, |
| 1612 | { 3, 2, handleCT_SetValues, "ClassType.SetValues" }, |
| 1613 | { 3, 3, handleCT_InvokeMethod, "ClassType.InvokeMethod" }, |
| 1614 | { 3, 4, handleCT_NewInstance, "ClassType.NewInstance" }, |
| 1615 | |
| 1616 | /* ArrayType command set (4) */ |
| 1617 | { 4, 1, handleAT_newInstance, "ArrayType.NewInstance" }, |
| 1618 | |
| 1619 | /* InterfaceType command set (5) */ |
| 1620 | |
| 1621 | /* Method command set (6) */ |
| 1622 | { 6, 1, handleM_LineTable, "Method.LineTable" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1623 | { 6, 2, NULL, "Method.VariableTable" }, |
| 1624 | { 6, 3, NULL, "Method.Bytecodes" }, |
| 1625 | { 6, 4, NULL, "Method.IsObsolete" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1626 | { 6, 5, handleM_VariableTableWithGeneric, "Method.VariableTableWithGeneric" }, |
| 1627 | |
| 1628 | /* Field command set (8) */ |
| 1629 | |
| 1630 | /* ObjectReference command set (9) */ |
| 1631 | { 9, 1, handleOR_ReferenceType, "ObjectReference.ReferenceType" }, |
| 1632 | { 9, 2, handleOR_GetValues, "ObjectReference.GetValues" }, |
| 1633 | { 9, 3, handleOR_SetValues, "ObjectReference.SetValues" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1634 | { 9, 4, NULL, "ObjectReference.UNUSED" }, |
| 1635 | { 9, 5, NULL, "ObjectReference.MonitorInfo" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1636 | { 9, 6, handleOR_InvokeMethod, "ObjectReference.InvokeMethod" }, |
| 1637 | { 9, 7, handleOR_DisableCollection, "ObjectReference.DisableCollection" }, |
| 1638 | { 9, 8, handleOR_EnableCollection, "ObjectReference.EnableCollection" }, |
| 1639 | { 9, 9, handleOR_IsCollected, "ObjectReference.IsCollected" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1640 | { 9, 10, NULL, "ObjectReference.ReferringObjects" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1641 | |
| 1642 | /* StringReference command set (10) */ |
| 1643 | { 10, 1, handleSR_Value, "StringReference.Value" }, |
| 1644 | |
| 1645 | /* ThreadReference command set (11) */ |
| 1646 | { 11, 1, handleTR_Name, "ThreadReference.Name" }, |
| 1647 | { 11, 2, handleTR_Suspend, "ThreadReference.Suspend" }, |
| 1648 | { 11, 3, handleTR_Resume, "ThreadReference.Resume" }, |
| 1649 | { 11, 4, handleTR_Status, "ThreadReference.Status" }, |
| 1650 | { 11, 5, handleTR_ThreadGroup, "ThreadReference.ThreadGroup" }, |
| 1651 | { 11, 6, handleTR_Frames, "ThreadReference.Frames" }, |
| 1652 | { 11, 7, handleTR_FrameCount, "ThreadReference.FrameCount" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1653 | { 11, 8, NULL, "ThreadReference.OwnedMonitors" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1654 | { 11, 9, handleTR_CurrentContendedMonitor, "ThreadReference.CurrentContendedMonitor" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1655 | { 11, 10, NULL, "ThreadReference.Stop" }, |
| 1656 | { 11, 11, NULL,"ThreadReference.Interrupt" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1657 | { 11, 12, handleTR_SuspendCount, "ThreadReference.SuspendCount" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1658 | { 11, 13, NULL, "ThreadReference.OwnedMonitorsStackDepthInfo" }, |
| 1659 | { 11, 14, NULL, "ThreadReference.ForceEarlyReturn" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1660 | |
| 1661 | /* ThreadGroupReference command set (12) */ |
| 1662 | { 12, 1, handleTGR_Name, "ThreadGroupReference.Name" }, |
| 1663 | { 12, 2, handleTGR_Parent, "ThreadGroupReference.Parent" }, |
| 1664 | { 12, 3, handleTGR_Children, "ThreadGroupReference.Children" }, |
| 1665 | |
| 1666 | /* ArrayReference command set (13) */ |
| 1667 | { 13, 1, handleAR_Length, "ArrayReference.Length" }, |
| 1668 | { 13, 2, handleAR_GetValues, "ArrayReference.GetValues" }, |
| 1669 | { 13, 3, handleAR_SetValues, "ArrayReference.SetValues" }, |
| 1670 | |
| 1671 | /* ClassLoaderReference command set (14) */ |
| 1672 | { 14, 1, handleCLR_VisibleClasses, "ClassLoaderReference.VisibleClasses" }, |
| 1673 | |
| 1674 | /* EventRequest command set (15) */ |
| 1675 | { 15, 1, handleER_Set, "EventRequest.Set" }, |
| 1676 | { 15, 2, handleER_Clear, "EventRequest.Clear" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1677 | { 15, 3, NULL, "EventRequest.ClearAllBreakpoints" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1678 | |
| 1679 | /* StackFrame command set (16) */ |
| 1680 | { 16, 1, handleSF_GetValues, "StackFrame.GetValues" }, |
| 1681 | { 16, 2, handleSF_SetValues, "StackFrame.SetValues" }, |
| 1682 | { 16, 3, handleSF_ThisObject, "StackFrame.ThisObject" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1683 | { 16, 4, NULL, "StackFrame.PopFrames" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1684 | |
| 1685 | /* ClassObjectReference command set (17) */ |
| 1686 | { 17, 1, handleCOR_ReflectedType,"ClassObjectReference.ReflectedType" }, |
| 1687 | |
| 1688 | /* Event command set (64) */ |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1689 | { 64, 100, NULL, "Event.Composite" }, // sent from VM to debugger, never received by VM |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1690 | |
| 1691 | { 199, 1, handleDDM_Chunk, "DDM.Chunk" }, |
| 1692 | }; |
| 1693 | |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1694 | static const char* GetCommandName(size_t cmdSet, size_t cmd) { |
| 1695 | for (int i = 0; i < (int) arraysize(gHandlerMap); i++) { |
| 1696 | if (gHandlerMap[i].cmdSet == cmdSet && gHandlerMap[i].cmd == cmd) { |
| 1697 | return gHandlerMap[i].descr; |
| 1698 | } |
| 1699 | } |
| 1700 | return "?UNKNOWN?"; |
| 1701 | } |
| 1702 | |
| 1703 | static std::string DescribeCommand(const JdwpReqHeader* pHeader, int dataLen) { |
| 1704 | std::string result; |
| 1705 | result += "REQ: "; |
| 1706 | result += GetCommandName(pHeader->cmdSet, pHeader->cmd); |
| 1707 | result += StringPrintf(" (dataLen=%d id=0x%06x)", dataLen, pHeader->id); |
| 1708 | return result; |
| 1709 | } |
| 1710 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1711 | /* |
| 1712 | * Process a request from the debugger. |
| 1713 | * |
| 1714 | * On entry, the JDWP thread is in VMWAIT. |
| 1715 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 1716 | void JdwpState::ProcessRequest(const JdwpReqHeader* pHeader, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1717 | JdwpError result = ERR_NONE; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1718 | |
| 1719 | if (pHeader->cmdSet != kJDWPDdmCmdSet) { |
| 1720 | /* |
| 1721 | * Activity from a debugger, not merely ddms. Mark us as having an |
| 1722 | * active debugger session, and zero out the last-activity timestamp |
| 1723 | * so waitForDebugger() doesn't return if we stall for a bit here. |
| 1724 | */ |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 1725 | Dbg::GoActive(); |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 1726 | QuasiAtomicSwap64(0, &lastActivityWhen); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1727 | } |
| 1728 | |
| 1729 | /* |
| 1730 | * If a debugger event has fired in another thread, wait until the |
| 1731 | * initiating thread has suspended itself before processing messages |
| 1732 | * from the debugger. Otherwise we (the JDWP thread) could be told to |
| 1733 | * resume the thread before it has suspended. |
| 1734 | * |
| 1735 | * We call with an argument of zero to wait for the current event |
| 1736 | * thread to finish, and then clear the block. Depending on the thread |
| 1737 | * suspend policy, this may allow events in other threads to fire, |
| 1738 | * but those events have no bearing on what the debugger has sent us |
| 1739 | * in the current request. |
| 1740 | * |
| 1741 | * Note that we MUST clear the event token before waking the event |
| 1742 | * thread up, or risk waiting for the thread to suspend after we've |
| 1743 | * told it to resume. |
| 1744 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 1745 | SetWaitForEventThread(0); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1746 | |
| 1747 | /* |
| 1748 | * Tell the VM that we're running and shouldn't be interrupted by GC. |
| 1749 | * Do this after anything that can stall indefinitely. |
| 1750 | */ |
| 1751 | Dbg::ThreadRunning(); |
| 1752 | |
| 1753 | expandBufAddSpace(pReply, kJDWPHeaderLen); |
| 1754 | |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1755 | size_t i; |
| 1756 | for (i = 0; i < arraysize(gHandlerMap); i++) { |
| 1757 | if (gHandlerMap[i].cmdSet == pHeader->cmdSet && gHandlerMap[i].cmd == pHeader->cmd && gHandlerMap[i].func != NULL) { |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1758 | VLOG(jdwp) << DescribeCommand(pHeader, dataLen); |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 1759 | result = (*gHandlerMap[i].func)(this, buf, dataLen, pReply); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1760 | break; |
| 1761 | } |
| 1762 | } |
| 1763 | if (i == arraysize(gHandlerMap)) { |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1764 | LOG(ERROR) << DescribeCommand(pHeader, dataLen); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1765 | if (dataLen > 0) { |
| 1766 | HexDump(buf, dataLen); |
| 1767 | } |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1768 | LOG(ERROR) << "command not implemented"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1769 | result = ERR_NOT_IMPLEMENTED; |
| 1770 | } |
| 1771 | |
| 1772 | /* |
| 1773 | * Set up the reply header. |
| 1774 | * |
| 1775 | * If we encountered an error, only send the header back. |
| 1776 | */ |
| 1777 | uint8_t* replyBuf = expandBufGetBuffer(pReply); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1778 | Set4BE(replyBuf + 4, pHeader->id); |
| 1779 | Set1(replyBuf + 8, kJDWPFlagReply); |
| 1780 | Set2BE(replyBuf + 9, result); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1781 | if (result == ERR_NONE) { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1782 | Set4BE(replyBuf + 0, expandBufGetLength(pReply)); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1783 | } else { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1784 | Set4BE(replyBuf + 0, kJDWPHeaderLen); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1785 | } |
| 1786 | |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1787 | size_t respLen = expandBufGetLength(pReply) - kJDWPHeaderLen; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1788 | if (false) { |
| 1789 | LOG(INFO) << "reply: dataLen=" << respLen << " err=" << result << (result != ERR_NONE ? " **FAILED**" : ""); |
| 1790 | if (respLen > 0) { |
| 1791 | HexDump(expandBufGetBuffer(pReply) + kJDWPHeaderLen, respLen); |
| 1792 | } |
| 1793 | } |
| 1794 | |
| 1795 | /* |
| 1796 | * Update last-activity timestamp. We really only need this during |
| 1797 | * the initial setup. Only update if this is a non-DDMS packet. |
| 1798 | */ |
| 1799 | if (pHeader->cmdSet != kJDWPDdmCmdSet) { |
Elliott Hughes | 7162ad9 | 2011-10-27 14:08:42 -0700 | [diff] [blame] | 1800 | QuasiAtomicSwap64(MilliTime(), &lastActivityWhen); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1801 | } |
| 1802 | |
| 1803 | /* tell the VM that GC is okay again */ |
| 1804 | Dbg::ThreadWaiting(); |
| 1805 | } |
| 1806 | |
| 1807 | } // namespace JDWP |
| 1808 | |
| 1809 | } // namespace art |