jdwp_handler.cc revision e6c143fae8ec487704b3d0d28914cda3d6d19e88 
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#include <stdlib.h>
18#include <string.h>
19#include <unistd.h>
20#include <memory>
21#include <string>
22
23#include "atomic.h"
24#include "base/hex_dump.h"
25#include "base/logging.h"
26#include "base/macros.h"
27#include "base/stringprintf.h"
28#include "debugger.h"
29#include "jdwp/jdwp_constants.h"
30#include "jdwp/jdwp_event.h"
31#include "jdwp/jdwp_expand_buf.h"
32#include "jdwp/jdwp_priv.h"
33#include "runtime.h"
34#include "thread-inl.h"
35
36namespace art {
37
38namespace JDWP {
39
40std::string DescribeField(const FieldId& field_id) {
41  return StringPrintf("%#x (%s)", field_id, Dbg::GetFieldName(field_id).c_str());
42}
43
44std::string DescribeMethod(const MethodId& method_id) {
45  return StringPrintf("%#x (%s)", method_id, Dbg::GetMethodName(method_id).c_str());
46}
47
48std::string DescribeRefTypeId(const RefTypeId& ref_type_id) {
49  std::string signature("unknown");
50  Dbg::GetSignature(ref_type_id, &signature);
51  return StringPrintf("%#" PRIx64 " (%s)", ref_type_id, signature.c_str());
52}
53
54// Helper function: write a variable-width value into the output input buffer.
55static void WriteValue(ExpandBuf* pReply, int width, uint64_t value) {
56  switch (width) {
57  case 1:     expandBufAdd1(pReply, value); break;
58  case 2:     expandBufAdd2BE(pReply, value); break;
59  case 4:     expandBufAdd4BE(pReply, value); break;
60  case 8:     expandBufAdd8BE(pReply, value); break;
61  default:    LOG(FATAL) << width; break;
62  }
63}
64
65static JdwpError WriteTaggedObject(ExpandBuf* reply, ObjectId object_id)
66    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
67  uint8_t tag;
68  JdwpError rc = Dbg::GetObjectTag(object_id, &tag);
69  if (rc == ERR_NONE) {
70    expandBufAdd1(reply, tag);
71    expandBufAddObjectId(reply, object_id);
72  }
73  return rc;
74}
75
76static JdwpError WriteTaggedObjectList(ExpandBuf* reply, const std::vector<ObjectId>& objects)
77    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
78  expandBufAdd4BE(reply, objects.size());
79  for (size_t i = 0; i < objects.size(); ++i) {
80    JdwpError rc = WriteTaggedObject(reply, objects[i]);
81    if (rc != ERR_NONE) {
82      return rc;
83    }
84  }
85  return ERR_NONE;
86}
87
88/*
89 * Common code for *_InvokeMethod requests.
90 *
91 * If "is_constructor" is set, this returns "object_id" rather than the
92 * expected-to-be-void return value of the called function.
93 */
94static JdwpError FinishInvoke(JdwpState*, Request* request, ExpandBuf* pReply,
95                              ObjectId thread_id, ObjectId object_id,
96                              RefTypeId class_id, MethodId method_id, bool is_constructor)
97    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
98  CHECK(!is_constructor || object_id != 0);
99
100  int32_t arg_count = request->ReadSigned32("argument count");
101
102  VLOG(jdwp) << StringPrintf("    --> thread_id=%#" PRIx64 " object_id=%#" PRIx64,
103                             thread_id, object_id);
104  VLOG(jdwp) << StringPrintf("        class_id=%#" PRIx64 " method_id=%x %s.%s", class_id,
105                             method_id, Dbg::GetClassName(class_id).c_str(),
106                             Dbg::GetMethodName(method_id).c_str());
107  VLOG(jdwp) << StringPrintf("        %d args:", arg_count);
108
109  std::unique_ptr<JdwpTag[]> argTypes(arg_count > 0 ? new JdwpTag[arg_count] : nullptr);
110  std::unique_ptr<uint64_t[]> argValues(arg_count > 0 ? new uint64_t[arg_count] : nullptr);
111  for (int32_t i = 0; i < arg_count; ++i) {
112    argTypes[i] = request->ReadTag();
113    size_t width = Dbg::GetTagWidth(argTypes[i]);
114    argValues[i] = request->ReadValue(width);
115    VLOG(jdwp) << "          " << argTypes[i] << StringPrintf("(%zd): %#" PRIx64, width,
116                                                              argValues[i]);
117  }
118
119  uint32_t options = request->ReadUnsigned32("InvokeOptions bit flags");
120  VLOG(jdwp) << StringPrintf("        options=0x%04x%s%s", options,
121                             (options & INVOKE_SINGLE_THREADED) ? " (SINGLE_THREADED)" : "",
122                             (options & INVOKE_NONVIRTUAL) ? " (NONVIRTUAL)" : "");
123
124  JdwpTag resultTag;
125  uint64_t resultValue;
126  ObjectId exceptObjId;
127  JdwpError err = Dbg::InvokeMethod(thread_id, object_id, class_id, method_id, arg_count,
128                                    argValues.get(), argTypes.get(), options, &resultTag,
129                                    &resultValue, &exceptObjId);
130  if (err != ERR_NONE) {
131    return err;
132  }
133
134  if (err == ERR_NONE) {
135    if (is_constructor) {
136      // If we invoked a constructor (which actually returns void), return the receiver,
137      // unless we threw, in which case we return NULL.
138      resultTag = JT_OBJECT;
139      resultValue = (exceptObjId == 0) ? object_id : 0;
140    }
141
142    size_t width = Dbg::GetTagWidth(resultTag);
143    expandBufAdd1(pReply, resultTag);
144    if (width != 0) {
145      WriteValue(pReply, width, resultValue);
146    }
147    expandBufAdd1(pReply, JT_OBJECT);
148    expandBufAddObjectId(pReply, exceptObjId);
149
150    VLOG(jdwp) << "  --> returned " << resultTag
151        << StringPrintf(" %#" PRIx64 " (except=%#" PRIx64 ")", resultValue, exceptObjId);
152
153    /* show detailed debug output */
154    if (resultTag == JT_STRING && exceptObjId == 0) {
155      if (resultValue != 0) {
156        if (VLOG_IS_ON(jdwp)) {
157          std::string result_string;
158          JDWP::JdwpError error = Dbg::StringToUtf8(resultValue, &result_string);
159          CHECK_EQ(error, JDWP::ERR_NONE);
160          VLOG(jdwp) << "      string '" << result_string << "'";
161        }
162      } else {
163        VLOG(jdwp) << "      string (null)";
164      }
165    }
166  }
167
168  return err;
169}
170
171static JdwpError VM_Version(JdwpState*, Request*, ExpandBuf* pReply)
172    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
173  // Text information on runtime version.
174  std::string version(StringPrintf("Android Runtime %s", Runtime::Current()->GetVersion()));
175  expandBufAddUtf8String(pReply, version);
176
177  // JDWP version numbers, major and minor.
178  expandBufAdd4BE(pReply, 1);
179  expandBufAdd4BE(pReply, 6);
180
181  // "java.version".
182  expandBufAddUtf8String(pReply, "1.6.0");
183
184  // "java.vm.name".
185  expandBufAddUtf8String(pReply, "Dalvik");
186
187  return ERR_NONE;
188}
189
190/*
191 * Given a class JNI signature (e.g. "Ljava/lang/Error;"), return the
192 * referenceTypeID.  We need to send back more than one if the class has
193 * been loaded by multiple class loaders.
194 */
195static JdwpError VM_ClassesBySignature(JdwpState*, Request* request, ExpandBuf* pReply)
196    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
197  std::string classDescriptor(request->ReadUtf8String());
198
199  std::vector<RefTypeId> ids;
200  Dbg::FindLoadedClassBySignature(classDescriptor.c_str(), &ids);
201
202  expandBufAdd4BE(pReply, ids.size());
203
204  for (size_t i = 0; i < ids.size(); ++i) {
205    // Get class vs. interface and status flags.
206    JDWP::JdwpTypeTag type_tag;
207    uint32_t class_status;
208    JDWP::JdwpError status = Dbg::GetClassInfo(ids[i], &type_tag, &class_status, nullptr);
209    if (status != ERR_NONE) {
210      return status;
211    }
212
213    expandBufAdd1(pReply, type_tag);
214    expandBufAddRefTypeId(pReply, ids[i]);
215    expandBufAdd4BE(pReply, class_status);
216  }
217
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 */
227static JdwpError VM_AllThreads(JdwpState*, Request*, ExpandBuf* pReply)
228    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
229  std::vector<ObjectId> thread_ids;
230  Dbg::GetThreads(nullptr /* all thread groups */, &thread_ids);
231
232  expandBufAdd4BE(pReply, thread_ids.size());
233  for (uint32_t i = 0; i < thread_ids.size(); ++i) {
234    expandBufAddObjectId(pReply, thread_ids[i]);
235  }
236
237  return ERR_NONE;
238}
239
240/*
241 * List all thread groups that do not have a parent.
242 */
243static JdwpError VM_TopLevelThreadGroups(JdwpState*, Request*, ExpandBuf* pReply)
244    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
245  /*
246   * TODO: maintain a list of parentless thread groups in the VM.
247   *
248   * For now, just return "system".  Application threads are created
249   * in "main", which is a child of "system".
250   */
251  uint32_t groups = 1;
252  expandBufAdd4BE(pReply, groups);
253  ObjectId thread_group_id = Dbg::GetSystemThreadGroupId();
254  expandBufAddObjectId(pReply, thread_group_id);
255
256  return ERR_NONE;
257}
258
259/*
260 * Respond with the sizes of the basic debugger types.
261 *
262 * All IDs are 8 bytes.
263 */
264static JdwpError VM_IDSizes(JdwpState*, Request*, ExpandBuf* pReply)
265    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
266  expandBufAdd4BE(pReply, sizeof(FieldId));
267  expandBufAdd4BE(pReply, sizeof(MethodId));
268  expandBufAdd4BE(pReply, sizeof(ObjectId));
269  expandBufAdd4BE(pReply, sizeof(RefTypeId));
270  expandBufAdd4BE(pReply, sizeof(FrameId));
271  return ERR_NONE;
272}
273
274static JdwpError VM_Dispose(JdwpState*, Request*, ExpandBuf*)
275    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
276  Dbg::Disposed();
277  return ERR_NONE;
278}
279
280/*
281 * Suspend the execution of the application running in the VM (i.e. suspend
282 * all threads).
283 *
284 * This needs to increment the "suspend count" on all threads.
285 */
286static JdwpError VM_Suspend(JdwpState*, Request*, ExpandBuf*)
287    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
288  Thread* self = Thread::Current();
289  self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSuspension);
290  Dbg::SuspendVM();
291  self->TransitionFromSuspendedToRunnable();
292  return ERR_NONE;
293}
294
295/*
296 * Resume execution.  Decrements the "suspend count" of all threads.
297 */
298static JdwpError VM_Resume(JdwpState*, Request*, ExpandBuf*)
299    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
300  Dbg::ProcessDelayedFullUndeoptimizations();
301  Dbg::ResumeVM();
302  return ERR_NONE;
303}
304
305static JdwpError VM_Exit(JdwpState* state, Request* request, ExpandBuf*)
306    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
307  uint32_t exit_status = request->ReadUnsigned32("exit_status");
308  state->ExitAfterReplying(exit_status);
309  return ERR_NONE;
310}
311
312/*
313 * Create a new string in the VM and return its ID.
314 *
315 * (Ctrl-Shift-I in Eclipse on an array of objects causes it to create the
316 * string "java.util.Arrays".)
317 */
318static JdwpError VM_CreateString(JdwpState*, Request* request, ExpandBuf* pReply)
319    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
320  std::string str(request->ReadUtf8String());
321  ObjectId stringId = Dbg::CreateString(str);
322  if (stringId == 0) {
323    return ERR_OUT_OF_MEMORY;
324  }
325  expandBufAddObjectId(pReply, stringId);
326  return ERR_NONE;
327}
328
329static JdwpError VM_ClassPaths(JdwpState*, Request*, ExpandBuf* pReply)
330    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
331  expandBufAddUtf8String(pReply, "/");
332
333  std::vector<std::string> class_path;
334  Split(Runtime::Current()->GetClassPathString(), ':', &class_path);
335  expandBufAdd4BE(pReply, class_path.size());
336  for (const std::string& str : class_path) {
337    expandBufAddUtf8String(pReply, str);
338  }
339
340  std::vector<std::string> boot_class_path;
341  Split(Runtime::Current()->GetBootClassPathString(), ':', &boot_class_path);
342  expandBufAdd4BE(pReply, boot_class_path.size());
343  for (const std::string& str : boot_class_path) {
344    expandBufAddUtf8String(pReply, str);
345  }
346
347  return ERR_NONE;
348}
349
350static JdwpError VM_DisposeObjects(JdwpState*, Request* request, ExpandBuf*)
351    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
352  size_t object_count = request->ReadUnsigned32("object_count");
353  for (size_t i = 0; i < object_count; ++i) {
354    ObjectId object_id = request->ReadObjectId();
355    uint32_t reference_count = request->ReadUnsigned32("reference_count");
356    Dbg::DisposeObject(object_id, reference_count);
357  }
358  return ERR_NONE;
359}
360
361static JdwpError VM_Capabilities(JdwpState*, Request*, ExpandBuf* reply)
362    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
363  expandBufAdd1(reply, true);    // canWatchFieldModification
364  expandBufAdd1(reply, true);    // canWatchFieldAccess
365  expandBufAdd1(reply, true);    // canGetBytecodes
366  expandBufAdd1(reply, true);    // canGetSyntheticAttribute
367  expandBufAdd1(reply, true);    // canGetOwnedMonitorInfo
368  expandBufAdd1(reply, true);    // canGetCurrentContendedMonitor
369  expandBufAdd1(reply, true);    // canGetMonitorInfo
370  return ERR_NONE;
371}
372
373static JdwpError VM_CapabilitiesNew(JdwpState*, Request* request, ExpandBuf* reply)
374    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
375  // The first few capabilities are the same as those reported by the older call.
376  VM_Capabilities(nullptr, request, reply);
377
378  expandBufAdd1(reply, false);   // canRedefineClasses
379  expandBufAdd1(reply, false);   // canAddMethod
380  expandBufAdd1(reply, false);   // canUnrestrictedlyRedefineClasses
381  expandBufAdd1(reply, false);   // canPopFrames
382  expandBufAdd1(reply, true);    // canUseInstanceFilters
383  expandBufAdd1(reply, false);   // canGetSourceDebugExtension
384  expandBufAdd1(reply, false);   // canRequestVMDeathEvent
385  expandBufAdd1(reply, false);   // canSetDefaultStratum
386  expandBufAdd1(reply, true);    // 1.6: canGetInstanceInfo
387  expandBufAdd1(reply, false);   // 1.6: canRequestMonitorEvents
388  expandBufAdd1(reply, true);    // 1.6: canGetMonitorFrameInfo
389  expandBufAdd1(reply, false);   // 1.6: canUseSourceNameFilters
390  expandBufAdd1(reply, false);   // 1.6: canGetConstantPool
391  expandBufAdd1(reply, false);   // 1.6: canForceEarlyReturn
392
393  // Fill in reserved22 through reserved32; note count started at 1.
394  for (size_t i = 22; i <= 32; ++i) {
395    expandBufAdd1(reply, false);
396  }
397  return ERR_NONE;
398}
399
400static JdwpError VM_AllClassesImpl(ExpandBuf* pReply, bool descriptor_and_status, bool generic)
401    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
402  std::vector<JDWP::RefTypeId> classes;
403  Dbg::GetClassList(&classes);
404
405  expandBufAdd4BE(pReply, classes.size());
406
407  for (size_t i = 0; i < classes.size(); ++i) {
408    static const char genericSignature[1] = "";
409    JDWP::JdwpTypeTag type_tag;
410    std::string descriptor;
411    uint32_t class_status;
412    JDWP::JdwpError status = Dbg::GetClassInfo(classes[i], &type_tag, &class_status, &descriptor);
413    if (status != ERR_NONE) {
414      return status;
415    }
416
417    expandBufAdd1(pReply, type_tag);
418    expandBufAddRefTypeId(pReply, classes[i]);
419    if (descriptor_and_status) {
420      expandBufAddUtf8String(pReply, descriptor);
421      if (generic) {
422        expandBufAddUtf8String(pReply, genericSignature);
423      }
424      expandBufAdd4BE(pReply, class_status);
425    }
426  }
427
428  return ERR_NONE;
429}
430
431static JdwpError VM_AllClasses(JdwpState*, Request*, ExpandBuf* pReply)
432    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
433  return VM_AllClassesImpl(pReply, true, false);
434}
435
436static JdwpError VM_AllClassesWithGeneric(JdwpState*, Request*, ExpandBuf* pReply)
437    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
438  return VM_AllClassesImpl(pReply, true, true);
439}
440
441static JdwpError VM_InstanceCounts(JdwpState*, Request* request, ExpandBuf* pReply)
442    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
443  int32_t class_count = request->ReadSigned32("class count");
444  if (class_count < 0) {
445    return ERR_ILLEGAL_ARGUMENT;
446  }
447  std::vector<RefTypeId> class_ids;
448  for (int32_t i = 0; i < class_count; ++i) {
449    class_ids.push_back(request->ReadRefTypeId());
450  }
451
452  std::vector<uint64_t> counts;
453  JdwpError rc = Dbg::GetInstanceCounts(class_ids, &counts);
454  if (rc != ERR_NONE) {
455    return rc;
456  }
457
458  expandBufAdd4BE(pReply, counts.size());
459  for (size_t i = 0; i < counts.size(); ++i) {
460    expandBufAdd8BE(pReply, counts[i]);
461  }
462  return ERR_NONE;
463}
464
465static JdwpError RT_Modifiers(JdwpState*, Request* request, ExpandBuf* pReply)
466    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
467  RefTypeId refTypeId = request->ReadRefTypeId();
468  return Dbg::GetModifiers(refTypeId, pReply);
469}
470
471/*
472 * Get values from static fields in a reference type.
473 */
474static JdwpError RT_GetValues(JdwpState*, Request* request, ExpandBuf* pReply)
475    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
476  RefTypeId refTypeId = request->ReadRefTypeId();
477  int32_t field_count = request->ReadSigned32("field count");
478  expandBufAdd4BE(pReply, field_count);
479  for (int32_t i = 0; i < field_count; ++i) {
480    FieldId fieldId = request->ReadFieldId();
481    JdwpError status = Dbg::GetStaticFieldValue(refTypeId, fieldId, pReply);
482    if (status != ERR_NONE) {
483      return status;
484    }
485  }
486  return ERR_NONE;
487}
488
489/*
490 * Get the name of the source file in which a reference type was declared.
491 */
492static JdwpError RT_SourceFile(JdwpState*, Request* request, ExpandBuf* pReply)
493    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
494  RefTypeId refTypeId = request->ReadRefTypeId();
495  std::string source_file;
496  JdwpError status = Dbg::GetSourceFile(refTypeId, &source_file);
497  if (status != ERR_NONE) {
498    return status;
499  }
500  expandBufAddUtf8String(pReply, source_file);
501  return ERR_NONE;
502}
503
504/*
505 * Return the current status of the reference type.
506 */
507static JdwpError RT_Status(JdwpState*, Request* request, ExpandBuf* pReply)
508    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
509  RefTypeId refTypeId = request->ReadRefTypeId();
510  JDWP::JdwpTypeTag type_tag;
511  uint32_t class_status;
512  JDWP::JdwpError status = Dbg::GetClassInfo(refTypeId, &type_tag, &class_status, nullptr);
513  if (status != ERR_NONE) {
514    return status;
515  }
516  expandBufAdd4BE(pReply, class_status);
517  return ERR_NONE;
518}
519
520/*
521 * Return interfaces implemented directly by this class.
522 */
523static JdwpError RT_Interfaces(JdwpState*, Request* request, ExpandBuf* pReply)
524    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
525  RefTypeId refTypeId = request->ReadRefTypeId();
526  return Dbg::OutputDeclaredInterfaces(refTypeId, pReply);
527}
528
529/*
530 * Return the class object corresponding to this type.
531 */
532static JdwpError RT_ClassObject(JdwpState*, Request* request, ExpandBuf* pReply)
533    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
534  RefTypeId refTypeId = request->ReadRefTypeId();
535  ObjectId class_object_id;
536  JdwpError status = Dbg::GetClassObject(refTypeId, &class_object_id);
537  if (status != ERR_NONE) {
538    return status;
539  }
540  VLOG(jdwp) << StringPrintf("    --> ObjectId %#" PRIx64, class_object_id);
541  expandBufAddObjectId(pReply, class_object_id);
542  return ERR_NONE;
543}
544
545/*
546 * Returns the value of the SourceDebugExtension attribute.
547 *
548 * JDB seems interested, but DEX files don't currently support this.
549 */
550static JdwpError RT_SourceDebugExtension(JdwpState*, Request*, ExpandBuf*)
551    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
552  /* referenceTypeId in, string out */
553  return ERR_ABSENT_INFORMATION;
554}
555
556static JdwpError RT_Signature(JdwpState*, Request* request, ExpandBuf* pReply, bool with_generic)
557    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
558  RefTypeId refTypeId = request->ReadRefTypeId();
559
560  std::string signature;
561  JdwpError status = Dbg::GetSignature(refTypeId, &signature);
562  if (status != ERR_NONE) {
563    return status;
564  }
565  expandBufAddUtf8String(pReply, signature);
566  if (with_generic) {
567    expandBufAddUtf8String(pReply, "");
568  }
569  return ERR_NONE;
570}
571
572static JdwpError RT_Signature(JdwpState* state, Request* request, ExpandBuf* pReply)
573    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
574  return RT_Signature(state, request, pReply, false);
575}
576
577static JdwpError RT_SignatureWithGeneric(JdwpState* state, Request* request, ExpandBuf* pReply)
578    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
579  return RT_Signature(state, request, pReply, true);
580}
581
582/*
583 * Return the instance of java.lang.ClassLoader that loaded the specified
584 * reference type, or null if it was loaded by the system loader.
585 */
586static JdwpError RT_ClassLoader(JdwpState*, Request* request, ExpandBuf* pReply)
587    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
588  RefTypeId refTypeId = request->ReadRefTypeId();
589  return Dbg::GetClassLoader(refTypeId, pReply);
590}
591
592/*
593 * Given a referenceTypeId, return a block of stuff that describes the
594 * fields declared by a class.
595 */
596static JdwpError RT_FieldsWithGeneric(JdwpState*, Request* request, ExpandBuf* pReply)
597    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
598  RefTypeId refTypeId = request->ReadRefTypeId();
599  return Dbg::OutputDeclaredFields(refTypeId, true, pReply);
600}
601
602// Obsolete equivalent of FieldsWithGeneric, without the generic type information.
603static JdwpError RT_Fields(JdwpState*, Request* request, ExpandBuf* pReply)
604    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
605  RefTypeId refTypeId = request->ReadRefTypeId();
606  return Dbg::OutputDeclaredFields(refTypeId, false, pReply);
607}
608
609/*
610 * Given a referenceTypeID, return a block of goodies describing the
611 * methods declared by a class.
612 */
613static JdwpError RT_MethodsWithGeneric(JdwpState*, Request* request, ExpandBuf* pReply)
614    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
615  RefTypeId refTypeId = request->ReadRefTypeId();
616  return Dbg::OutputDeclaredMethods(refTypeId, true, pReply);
617}
618
619// Obsolete equivalent of MethodsWithGeneric, without the generic type information.
620static JdwpError RT_Methods(JdwpState*, Request* request, ExpandBuf* pReply)
621    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
622  RefTypeId refTypeId = request->ReadRefTypeId();
623  return Dbg::OutputDeclaredMethods(refTypeId, false, pReply);
624}
625
626static JdwpError RT_Instances(JdwpState*, Request* request, ExpandBuf* reply)
627    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
628  RefTypeId class_id = request->ReadRefTypeId();
629  int32_t max_count = request->ReadSigned32("max count");
630  if (max_count < 0) {
631    return ERR_ILLEGAL_ARGUMENT;
632  }
633
634  std::vector<ObjectId> instances;
635  JdwpError rc = Dbg::GetInstances(class_id, max_count, &instances);
636  if (rc != ERR_NONE) {
637    return rc;
638  }
639
640  return WriteTaggedObjectList(reply, instances);
641}
642
643/*
644 * Return the immediate superclass of a class.
645 */
646static JdwpError CT_Superclass(JdwpState*, Request* request, ExpandBuf* pReply)
647    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
648  RefTypeId class_id = request->ReadRefTypeId();
649  RefTypeId superClassId;
650  JdwpError status = Dbg::GetSuperclass(class_id, &superClassId);
651  if (status != ERR_NONE) {
652    return status;
653  }
654  expandBufAddRefTypeId(pReply, superClassId);
655  return ERR_NONE;
656}
657
658/*
659 * Set static class values.
660 */
661static JdwpError CT_SetValues(JdwpState* , Request* request, ExpandBuf*)
662    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
663  RefTypeId class_id = request->ReadRefTypeId();
664  int32_t values_count = request->ReadSigned32("values count");
665
666  UNUSED(class_id);
667
668  for (int32_t i = 0; i < values_count; ++i) {
669    FieldId fieldId = request->ReadFieldId();
670    JDWP::JdwpTag fieldTag = Dbg::GetStaticFieldBasicTag(fieldId);
671    size_t width = Dbg::GetTagWidth(fieldTag);
672    uint64_t value = request->ReadValue(width);
673
674    VLOG(jdwp) << "    --> field=" << fieldId << " tag=" << fieldTag << " --> " << value;
675    JdwpError status = Dbg::SetStaticFieldValue(fieldId, value, width);
676    if (status != ERR_NONE) {
677      return status;
678    }
679  }
680
681  return ERR_NONE;
682}
683
684/*
685 * Invoke a static method.
686 *
687 * Example: Eclipse sometimes uses java/lang/Class.forName(String s) on
688 * values in the "variables" display.
689 */
690static JdwpError CT_InvokeMethod(JdwpState* state, Request* request, ExpandBuf* pReply)
691    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
692  RefTypeId class_id = request->ReadRefTypeId();
693  ObjectId thread_id = request->ReadThreadId();
694  MethodId method_id = request->ReadMethodId();
695
696  return FinishInvoke(state, request, pReply, thread_id, 0, class_id, method_id, false);
697}
698
699/*
700 * Create a new object of the requested type, and invoke the specified
701 * constructor.
702 *
703 * Example: in IntelliJ, create a watch on "new String(myByteArray)" to
704 * see the contents of a byte[] as a string.
705 */
706static JdwpError CT_NewInstance(JdwpState* state, Request* request, ExpandBuf* pReply)
707    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
708  RefTypeId class_id = request->ReadRefTypeId();
709  ObjectId thread_id = request->ReadThreadId();
710  MethodId method_id = request->ReadMethodId();
711
712  ObjectId object_id;
713  JdwpError status = Dbg::CreateObject(class_id, &object_id);
714  if (status != ERR_NONE) {
715    return status;
716  }
717  if (object_id == 0) {
718    return ERR_OUT_OF_MEMORY;
719  }
720  return FinishInvoke(state, request, pReply, thread_id, object_id, class_id, method_id, true);
721}
722
723/*
724 * Create a new array object of the requested type and length.
725 */
726static JdwpError AT_newInstance(JdwpState*, Request* request, ExpandBuf* pReply)
727    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
728  RefTypeId arrayTypeId = request->ReadRefTypeId();
729  int32_t length = request->ReadSigned32("length");
730
731  ObjectId object_id;
732  JdwpError status = Dbg::CreateArrayObject(arrayTypeId, length, &object_id);
733  if (status != ERR_NONE) {
734    return status;
735  }
736  if (object_id == 0) {
737    return ERR_OUT_OF_MEMORY;
738  }
739  expandBufAdd1(pReply, JT_ARRAY);
740  expandBufAddObjectId(pReply, object_id);
741  return ERR_NONE;
742}
743
744/*
745 * Return line number information for the method, if present.
746 */
747static JdwpError M_LineTable(JdwpState*, Request* request, ExpandBuf* pReply)
748    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
749  RefTypeId refTypeId = request->ReadRefTypeId();
750  MethodId method_id = request->ReadMethodId();
751
752  Dbg::OutputLineTable(refTypeId, method_id, pReply);
753
754  return ERR_NONE;
755}
756
757static JdwpError M_VariableTable(JdwpState*, Request* request, ExpandBuf* pReply,
758                                 bool generic)
759    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
760  RefTypeId class_id = request->ReadRefTypeId();
761  MethodId method_id = request->ReadMethodId();
762
763  // We could return ERR_ABSENT_INFORMATION here if the DEX file was built without local variable
764  // information. That will cause Eclipse to make a best-effort attempt at displaying local
765  // variables anonymously. However, the attempt isn't very good, so we're probably better off just
766  // not showing anything.
767  Dbg::OutputVariableTable(class_id, method_id, generic, pReply);
768  return ERR_NONE;
769}
770
771static JdwpError M_VariableTable(JdwpState* state, Request* request, ExpandBuf* pReply)
772    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
773  return M_VariableTable(state, request, pReply, false);
774}
775
776static JdwpError M_VariableTableWithGeneric(JdwpState* state, Request* request, ExpandBuf* pReply)
777    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
778  return M_VariableTable(state, request, pReply, true);
779}
780
781static JdwpError M_Bytecodes(JdwpState*, Request* request, ExpandBuf* reply)
782    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
783  RefTypeId class_id = request->ReadRefTypeId();
784  MethodId method_id = request->ReadMethodId();
785
786  std::vector<uint8_t> bytecodes;
787  JdwpError rc = Dbg::GetBytecodes(class_id, method_id, &bytecodes);
788  if (rc != ERR_NONE) {
789    return rc;
790  }
791
792  expandBufAdd4BE(reply, bytecodes.size());
793  for (size_t i = 0; i < bytecodes.size(); ++i) {
794    expandBufAdd1(reply, bytecodes[i]);
795  }
796
797  return ERR_NONE;
798}
799
800/*
801 * Given an object reference, return the runtime type of the object
802 * (class or array).
803 *
804 * This can get called on different things, e.g. thread_id gets
805 * passed in here.
806 */
807static JdwpError OR_ReferenceType(JdwpState*, Request* request, ExpandBuf* pReply)
808    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
809  ObjectId object_id = request->ReadObjectId();
810  return Dbg::GetReferenceType(object_id, pReply);
811}
812
813/*
814 * Get values from the fields of an object.
815 */
816static JdwpError OR_GetValues(JdwpState*, Request* request, ExpandBuf* pReply)
817    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
818  ObjectId object_id = request->ReadObjectId();
819  int32_t field_count = request->ReadSigned32("field count");
820
821  expandBufAdd4BE(pReply, field_count);
822  for (int32_t i = 0; i < field_count; ++i) {
823    FieldId fieldId = request->ReadFieldId();
824    JdwpError status = Dbg::GetFieldValue(object_id, fieldId, pReply);
825    if (status != ERR_NONE) {
826      return status;
827    }
828  }
829
830  return ERR_NONE;
831}
832
833/*
834 * Set values in the fields of an object.
835 */
836static JdwpError OR_SetValues(JdwpState*, Request* request, ExpandBuf*)
837    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
838  ObjectId object_id = request->ReadObjectId();
839  int32_t field_count = request->ReadSigned32("field count");
840
841  for (int32_t i = 0; i < field_count; ++i) {
842    FieldId fieldId = request->ReadFieldId();
843
844    JDWP::JdwpTag fieldTag = Dbg::GetFieldBasicTag(fieldId);
845    size_t width = Dbg::GetTagWidth(fieldTag);
846    uint64_t value = request->ReadValue(width);
847
848    VLOG(jdwp) << "    --> fieldId=" << fieldId << " tag=" << fieldTag << "(" << width << ") value=" << value;
849    JdwpError status = Dbg::SetFieldValue(object_id, fieldId, value, width);
850    if (status != ERR_NONE) {
851      return status;
852    }
853  }
854
855  return ERR_NONE;
856}
857
858static JdwpError OR_MonitorInfo(JdwpState*, Request* request, ExpandBuf* reply)
859    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
860  ObjectId object_id = request->ReadObjectId();
861  return Dbg::GetMonitorInfo(object_id, reply);
862}
863
864/*
865 * Invoke an instance method.  The invocation must occur in the specified
866 * thread, which must have been suspended by an event.
867 *
868 * The call is synchronous.  All threads in the VM are resumed, unless the
869 * SINGLE_THREADED flag is set.
870 *
871 * If you ask Eclipse to "inspect" an object (or ask JDB to "print" an
872 * object), it will try to invoke the object's toString() function.  This
873 * feature becomes crucial when examining ArrayLists with Eclipse.
874 */
875static JdwpError OR_InvokeMethod(JdwpState* state, Request* request, ExpandBuf* pReply)
876    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
877  ObjectId object_id = request->ReadObjectId();
878  ObjectId thread_id = request->ReadThreadId();
879  RefTypeId class_id = request->ReadRefTypeId();
880  MethodId method_id = request->ReadMethodId();
881
882  return FinishInvoke(state, request, pReply, thread_id, object_id, class_id, method_id, false);
883}
884
885static JdwpError OR_DisableCollection(JdwpState*, Request* request, ExpandBuf*)
886    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
887  ObjectId object_id = request->ReadObjectId();
888  return Dbg::DisableCollection(object_id);
889}
890
891static JdwpError OR_EnableCollection(JdwpState*, Request* request, ExpandBuf*)
892    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
893  ObjectId object_id = request->ReadObjectId();
894  return Dbg::EnableCollection(object_id);
895}
896
897static JdwpError OR_IsCollected(JdwpState*, Request* request, ExpandBuf* pReply)
898    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
899  ObjectId object_id = request->ReadObjectId();
900  bool is_collected;
901  JdwpError rc = Dbg::IsCollected(object_id, &is_collected);
902  expandBufAdd1(pReply, is_collected ? 1 : 0);
903  return rc;
904}
905
906static JdwpError OR_ReferringObjects(JdwpState*, Request* request, ExpandBuf* reply)
907    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
908  ObjectId object_id = request->ReadObjectId();
909  int32_t max_count = request->ReadSigned32("max count");
910  if (max_count < 0) {
911    return ERR_ILLEGAL_ARGUMENT;
912  }
913
914  std::vector<ObjectId> referring_objects;
915  JdwpError rc = Dbg::GetReferringObjects(object_id, max_count, &referring_objects);
916  if (rc != ERR_NONE) {
917    return rc;
918  }
919
920  return WriteTaggedObjectList(reply, referring_objects);
921}
922
923/*
924 * Return the string value in a string object.
925 */
926static JdwpError SR_Value(JdwpState*, Request* request, ExpandBuf* pReply)
927    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
928  ObjectId stringObject = request->ReadObjectId();
929  std::string str;
930  JDWP::JdwpError error = Dbg::StringToUtf8(stringObject, &str);
931  if (error != JDWP::ERR_NONE) {
932    return error;
933  }
934
935  VLOG(jdwp) << StringPrintf("    --> %s", PrintableString(str.c_str()).c_str());
936
937  expandBufAddUtf8String(pReply, str);
938
939  return ERR_NONE;
940}
941
942/*
943 * Return a thread's name.
944 */
945static JdwpError TR_Name(JdwpState*, Request* request, ExpandBuf* pReply)
946    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
947  ObjectId thread_id = request->ReadThreadId();
948
949  std::string name;
950  JdwpError error = Dbg::GetThreadName(thread_id, &name);
951  if (error != ERR_NONE) {
952    return error;
953  }
954  VLOG(jdwp) << StringPrintf("  Name of thread %#" PRIx64 " is \"%s\"", thread_id, name.c_str());
955  expandBufAddUtf8String(pReply, name);
956
957  return ERR_NONE;
958}
959
960/*
961 * Suspend the specified thread.
962 *
963 * It's supposed to remain suspended even if interpreted code wants to
964 * resume it; only the JDI is allowed to resume it.
965 */
966static JdwpError TR_Suspend(JdwpState*, Request* request, ExpandBuf*)
967    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
968  ObjectId thread_id = request->ReadThreadId();
969
970  if (thread_id == Dbg::GetThreadSelfId()) {
971    LOG(INFO) << "  Warning: ignoring request to suspend self";
972    return ERR_THREAD_NOT_SUSPENDED;
973  }
974
975  Thread* self = Thread::Current();
976  self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSend);
977  JdwpError result = Dbg::SuspendThread(thread_id);
978  self->TransitionFromSuspendedToRunnable();
979  return result;
980}
981
982/*
983 * Resume the specified thread.
984 */
985static JdwpError TR_Resume(JdwpState*, Request* request, ExpandBuf*)
986    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
987  ObjectId thread_id = request->ReadThreadId();
988
989  if (thread_id == Dbg::GetThreadSelfId()) {
990    LOG(INFO) << "  Warning: ignoring request to resume self";
991    return ERR_NONE;
992  }
993
994  Dbg::ProcessDelayedFullUndeoptimizations();
995
996  Dbg::ResumeThread(thread_id);
997  return ERR_NONE;
998}
999
1000/*
1001 * Return status of specified thread.
1002 */
1003static JdwpError TR_Status(JdwpState*, Request* request, ExpandBuf* pReply)
1004    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1005  ObjectId thread_id = request->ReadThreadId();
1006
1007  JDWP::JdwpThreadStatus threadStatus;
1008  JDWP::JdwpSuspendStatus suspendStatus;
1009  JdwpError error = Dbg::GetThreadStatus(thread_id, &threadStatus, &suspendStatus);
1010  if (error != ERR_NONE) {
1011    return error;
1012  }
1013
1014  VLOG(jdwp) << "    --> " << threadStatus << ", " << suspendStatus;
1015
1016  expandBufAdd4BE(pReply, threadStatus);
1017  expandBufAdd4BE(pReply, suspendStatus);
1018
1019  return ERR_NONE;
1020}
1021
1022/*
1023 * Return the thread group that the specified thread is a member of.
1024 */
1025static JdwpError TR_ThreadGroup(JdwpState*, Request* request, ExpandBuf* pReply)
1026    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1027  ObjectId thread_id = request->ReadThreadId();
1028  return Dbg::GetThreadGroup(thread_id, pReply);
1029}
1030
1031/*
1032 * Return the current call stack of a suspended thread.
1033 *
1034 * If the thread isn't suspended, the error code isn't defined, but should
1035 * be THREAD_NOT_SUSPENDED.
1036 */
1037static JdwpError TR_Frames(JdwpState*, Request* request, ExpandBuf* pReply)
1038    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1039  ObjectId thread_id = request->ReadThreadId();
1040  uint32_t start_frame = request->ReadUnsigned32("start frame");
1041  uint32_t length = request->ReadUnsigned32("length");
1042
1043  size_t actual_frame_count;
1044  JdwpError error = Dbg::GetThreadFrameCount(thread_id, &actual_frame_count);
1045  if (error != ERR_NONE) {
1046    return error;
1047  }
1048
1049  if (actual_frame_count <= 0) {
1050    return ERR_THREAD_NOT_SUSPENDED;  // 0 means no managed frames (which means "in native").
1051  }
1052
1053  if (start_frame > actual_frame_count) {
1054    return ERR_INVALID_INDEX;
1055  }
1056  if (length == static_cast<uint32_t>(-1)) {
1057    length = actual_frame_count - start_frame;
1058  }
1059  if (start_frame + length > actual_frame_count) {
1060    return ERR_INVALID_LENGTH;
1061  }
1062
1063  return Dbg::GetThreadFrames(thread_id, start_frame, length, pReply);
1064}
1065
1066/*
1067 * Returns the #of frames on the specified thread, which must be suspended.
1068 */
1069static JdwpError TR_FrameCount(JdwpState*, Request* request, ExpandBuf* pReply)
1070    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1071  ObjectId thread_id = request->ReadThreadId();
1072
1073  size_t frame_count;
1074  JdwpError rc = Dbg::GetThreadFrameCount(thread_id, &frame_count);
1075  if (rc != ERR_NONE) {
1076    return rc;
1077  }
1078  expandBufAdd4BE(pReply, static_cast<uint32_t>(frame_count));
1079
1080  return ERR_NONE;
1081}
1082
1083static JdwpError TR_OwnedMonitors(Request* request, ExpandBuf* reply, bool with_stack_depths)
1084    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1085  ObjectId thread_id = request->ReadThreadId();
1086
1087  std::vector<ObjectId> monitors;
1088  std::vector<uint32_t> stack_depths;
1089  JdwpError rc = Dbg::GetOwnedMonitors(thread_id, &monitors, &stack_depths);
1090  if (rc != ERR_NONE) {
1091    return rc;
1092  }
1093
1094  expandBufAdd4BE(reply, monitors.size());
1095  for (size_t i = 0; i < monitors.size(); ++i) {
1096    rc = WriteTaggedObject(reply, monitors[i]);
1097    if (rc != ERR_NONE) {
1098      return rc;
1099    }
1100    if (with_stack_depths) {
1101      expandBufAdd4BE(reply, stack_depths[i]);
1102    }
1103  }
1104  return ERR_NONE;
1105}
1106
1107static JdwpError TR_OwnedMonitors(JdwpState*, Request* request, ExpandBuf* reply)
1108    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1109  return TR_OwnedMonitors(request, reply, false);
1110}
1111
1112static JdwpError TR_OwnedMonitorsStackDepthInfo(JdwpState*, Request* request, ExpandBuf* reply)
1113    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1114  return TR_OwnedMonitors(request, reply, true);
1115}
1116
1117static JdwpError TR_CurrentContendedMonitor(JdwpState*, Request* request, ExpandBuf* reply)
1118    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1119  ObjectId thread_id = request->ReadThreadId();
1120
1121  ObjectId contended_monitor;
1122  JdwpError rc = Dbg::GetContendedMonitor(thread_id, &contended_monitor);
1123  if (rc != ERR_NONE) {
1124    return rc;
1125  }
1126  return WriteTaggedObject(reply, contended_monitor);
1127}
1128
1129static JdwpError TR_Interrupt(JdwpState*, Request* request, ExpandBuf* reply)
1130    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1131  UNUSED(reply);
1132  ObjectId thread_id = request->ReadThreadId();
1133  return Dbg::Interrupt(thread_id);
1134}
1135
1136/*
1137 * Return the debug suspend count for the specified thread.
1138 *
1139 * (The thread *might* still be running -- it might not have examined
1140 * its suspend count recently.)
1141 */
1142static JdwpError TR_DebugSuspendCount(JdwpState*, Request* request, ExpandBuf* pReply)
1143    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1144  ObjectId thread_id = request->ReadThreadId();
1145  return Dbg::GetThreadDebugSuspendCount(thread_id, pReply);
1146}
1147
1148/*
1149 * Return the name of a thread group.
1150 *
1151 * The Eclipse debugger recognizes "main" and "system" as special.
1152 */
1153static JdwpError TGR_Name(JdwpState*, Request* request, ExpandBuf* pReply)
1154    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1155  ObjectId thread_group_id = request->ReadThreadGroupId();
1156  return Dbg::GetThreadGroupName(thread_group_id, pReply);
1157}
1158
1159/*
1160 * Returns the thread group -- if any -- that contains the specified
1161 * thread group.
1162 */
1163static JdwpError TGR_Parent(JdwpState*, Request* request, ExpandBuf* pReply)
1164    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1165  ObjectId thread_group_id = request->ReadThreadGroupId();
1166  return Dbg::GetThreadGroupParent(thread_group_id, pReply);
1167}
1168
1169/*
1170 * Return the active threads and thread groups that are part of the
1171 * specified thread group.
1172 */
1173static JdwpError TGR_Children(JdwpState*, Request* request, ExpandBuf* pReply)
1174    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1175  ObjectId thread_group_id = request->ReadThreadGroupId();
1176  return Dbg::GetThreadGroupChildren(thread_group_id, pReply);
1177}
1178
1179/*
1180 * Return the #of components in the array.
1181 */
1182static JdwpError AR_Length(JdwpState*, Request* request, ExpandBuf* pReply)
1183    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1184  ObjectId array_id = request->ReadArrayId();
1185
1186  int32_t length;
1187  JdwpError status = Dbg::GetArrayLength(array_id, &length);
1188  if (status != ERR_NONE) {
1189    return status;
1190  }
1191  VLOG(jdwp) << "    --> " << length;
1192
1193  expandBufAdd4BE(pReply, length);
1194
1195  return ERR_NONE;
1196}
1197
1198/*
1199 * Return the values from an array.
1200 */
1201static JdwpError AR_GetValues(JdwpState*, Request* request, ExpandBuf* pReply)
1202    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1203  ObjectId array_id = request->ReadArrayId();
1204  uint32_t offset = request->ReadUnsigned32("offset");
1205  uint32_t length = request->ReadUnsigned32("length");
1206  return Dbg::OutputArray(array_id, offset, length, pReply);
1207}
1208
1209/*
1210 * Set values in an array.
1211 */
1212static JdwpError AR_SetValues(JdwpState*, Request* request, ExpandBuf*)
1213    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1214  ObjectId array_id = request->ReadArrayId();
1215  uint32_t offset = request->ReadUnsigned32("offset");
1216  uint32_t count = request->ReadUnsigned32("count");
1217  return Dbg::SetArrayElements(array_id, offset, count, request);
1218}
1219
1220static JdwpError CLR_VisibleClasses(JdwpState*, Request* request, ExpandBuf* pReply)
1221    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1222  request->ReadObjectId();  // classLoaderObject
1223  // TODO: we should only return classes which have the given class loader as a defining or
1224  // initiating loader. The former would be easy; the latter is hard, because we don't have
1225  // any such notion.
1226  return VM_AllClassesImpl(pReply, false, false);
1227}
1228
1229/*
1230 * Set an event trigger.
1231 *
1232 * Reply with a requestID.
1233 */
1234static JdwpError ER_Set(JdwpState* state, Request* request, ExpandBuf* pReply)
1235    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1236  JdwpEventKind event_kind = request->ReadEnum1<JdwpEventKind>("event kind");
1237  JdwpSuspendPolicy suspend_policy = request->ReadEnum1<JdwpSuspendPolicy>("suspend policy");
1238  int32_t modifier_count = request->ReadSigned32("modifier count");
1239
1240  CHECK_LT(modifier_count, 256);    /* reasonableness check */
1241
1242  JdwpEvent* pEvent = EventAlloc(modifier_count);
1243  pEvent->eventKind = event_kind;
1244  pEvent->suspend_policy = suspend_policy;
1245  pEvent->modCount = modifier_count;
1246
1247  /*
1248   * Read modifiers.  Ordering may be significant (see explanation of Count
1249   * mods in JDWP doc).
1250   */
1251  for (int32_t i = 0; i < modifier_count; ++i) {
1252    JdwpEventMod& mod = pEvent->mods[i];
1253    mod.modKind = request->ReadModKind();
1254    switch (mod.modKind) {
1255    case MK_COUNT:
1256      {
1257        // Report once, when "--count" reaches 0.
1258        uint32_t count = request->ReadUnsigned32("count");
1259        if (count == 0) {
1260          return ERR_INVALID_COUNT;
1261        }
1262        mod.count.count = count;
1263      }
1264      break;
1265    case MK_CONDITIONAL:
1266      {
1267        // Conditional on expression.
1268        uint32_t exprId = request->ReadUnsigned32("expr id");
1269        mod.conditional.exprId = exprId;
1270      }
1271      break;
1272    case MK_THREAD_ONLY:
1273      {
1274        // Only report events in specified thread.
1275        ObjectId thread_id = request->ReadThreadId();
1276        mod.threadOnly.threadId = thread_id;
1277      }
1278      break;
1279    case MK_CLASS_ONLY:
1280      {
1281        // For ClassPrepare, MethodEntry.
1282        RefTypeId class_id = request->ReadRefTypeId();
1283        mod.classOnly.refTypeId = class_id;
1284      }
1285      break;
1286    case MK_CLASS_MATCH:
1287      {
1288        // Restrict events to matching classes.
1289        // pattern is "java.foo.*", we want "java/foo/*".
1290        std::string pattern(request->ReadUtf8String());
1291        std::replace(pattern.begin(), pattern.end(), '.', '/');
1292        mod.classMatch.classPattern = strdup(pattern.c_str());
1293      }
1294      break;
1295    case MK_CLASS_EXCLUDE:
1296      {
1297        // Restrict events to non-matching classes.
1298        // pattern is "java.foo.*", we want "java/foo/*".
1299        std::string pattern(request->ReadUtf8String());
1300        std::replace(pattern.begin(), pattern.end(), '.', '/');
1301        mod.classExclude.classPattern = strdup(pattern.c_str());
1302      }
1303      break;
1304    case MK_LOCATION_ONLY:
1305      {
1306        // Restrict certain events based on location.
1307        JdwpLocation location = request->ReadLocation();
1308        mod.locationOnly.loc = location;
1309      }
1310      break;
1311    case MK_EXCEPTION_ONLY:
1312      {
1313        // Modifies EK_EXCEPTION events,
1314        mod.exceptionOnly.refTypeId = request->ReadRefTypeId();  // null => all exceptions.
1315        mod.exceptionOnly.caught = request->ReadEnum1<uint8_t>("caught");
1316        mod.exceptionOnly.uncaught = request->ReadEnum1<uint8_t>("uncaught");
1317      }
1318      break;
1319    case MK_FIELD_ONLY:
1320      {
1321        // For field access/modification events.
1322        RefTypeId declaring = request->ReadRefTypeId();
1323        FieldId fieldId = request->ReadFieldId();
1324        mod.fieldOnly.refTypeId = declaring;
1325        mod.fieldOnly.fieldId = fieldId;
1326      }
1327      break;
1328    case MK_STEP:
1329      {
1330        // For use with EK_SINGLE_STEP.
1331        ObjectId thread_id = request->ReadThreadId();
1332        uint32_t size = request->ReadUnsigned32("step size");
1333        uint32_t depth = request->ReadUnsigned32("step depth");
1334        VLOG(jdwp) << StringPrintf("    Step: thread=%#" PRIx64, thread_id)
1335                     << " size=" << JdwpStepSize(size) << " depth=" << JdwpStepDepth(depth);
1336
1337        mod.step.threadId = thread_id;
1338        mod.step.size = size;
1339        mod.step.depth = depth;
1340      }
1341      break;
1342    case MK_INSTANCE_ONLY:
1343      {
1344        // Report events related to a specific object.
1345        ObjectId instance = request->ReadObjectId();
1346        mod.instanceOnly.objectId = instance;
1347      }
1348      break;
1349    default:
1350      LOG(WARNING) << "Unsupported modifier " << mod.modKind << " for event " << pEvent->eventKind;
1351      // Free allocated event to avoid leak before leaving.
1352      EventFree(pEvent);
1353      return JDWP::ERR_NOT_IMPLEMENTED;
1354    }
1355  }
1356
1357  /*
1358   * We reply with an integer "requestID".
1359   */
1360  uint32_t requestId = state->NextEventSerial();
1361  expandBufAdd4BE(pReply, requestId);
1362
1363  pEvent->requestId = requestId;
1364
1365  VLOG(jdwp) << StringPrintf("    --> event requestId=%#x", requestId);
1366
1367  /* add it to the list */
1368  JdwpError err = state->RegisterEvent(pEvent);
1369  if (err != ERR_NONE) {
1370    /* registration failed, probably because event is bogus */
1371    EventFree(pEvent);
1372    LOG(WARNING) << "WARNING: event request rejected";
1373  }
1374  return err;
1375}
1376
1377static JdwpError ER_Clear(JdwpState* state, Request* request, ExpandBuf*)
1378    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1379  request->ReadEnum1<JdwpEventKind>("event kind");
1380  uint32_t requestId = request->ReadUnsigned32("request id");
1381
1382  // Failure to find an event with a matching ID is a no-op
1383  // and does not return an error.
1384  state->UnregisterEventById(requestId);
1385  return ERR_NONE;
1386}
1387
1388/*
1389 * Return the values of arguments and local variables.
1390 */
1391static JdwpError SF_GetValues(JdwpState*, Request* request, ExpandBuf* pReply)
1392    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1393  return Dbg::GetLocalValues(request, pReply);
1394}
1395
1396/*
1397 * Set the values of arguments and local variables.
1398 */
1399static JdwpError SF_SetValues(JdwpState*, Request* request, ExpandBuf*)
1400    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1401  return Dbg::SetLocalValues(request);
1402}
1403
1404static JdwpError SF_ThisObject(JdwpState*, Request* request, ExpandBuf* reply)
1405    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1406  ObjectId thread_id = request->ReadThreadId();
1407  FrameId frame_id = request->ReadFrameId();
1408
1409  ObjectId object_id;
1410  JdwpError rc = Dbg::GetThisObject(thread_id, frame_id, &object_id);
1411  if (rc != ERR_NONE) {
1412    return rc;
1413  }
1414
1415  return WriteTaggedObject(reply, object_id);
1416}
1417
1418/*
1419 * Return the reference type reflected by this class object.
1420 *
1421 * This appears to be required because ReferenceTypeId values are NEVER
1422 * reused, whereas ClassIds can be recycled like any other object.  (Either
1423 * that, or I have no idea what this is for.)
1424 */
1425static JdwpError COR_ReflectedType(JdwpState*, Request* request, ExpandBuf* pReply)
1426    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1427  RefTypeId class_object_id = request->ReadRefTypeId();
1428  return Dbg::GetReflectedType(class_object_id, pReply);
1429}
1430
1431/*
1432 * Handle a DDM packet with a single chunk in it.
1433 */
1434static JdwpError DDM_Chunk(JdwpState* state, Request* request, ExpandBuf* pReply)
1435    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1436  state->NotifyDdmsActive();
1437  uint8_t* replyBuf = nullptr;
1438  int replyLen = -1;
1439  if (Dbg::DdmHandlePacket(request, &replyBuf, &replyLen)) {
1440    // If they want to send something back, we copy it into the buffer.
1441    // TODO: consider altering the JDWP stuff to hold the packet header
1442    // in a separate buffer.  That would allow us to writev() DDM traffic
1443    // instead of copying it into the expanding buffer.  The reduction in
1444    // heap requirements is probably more valuable than the efficiency.
1445    CHECK_GT(replyLen, 0);
1446    memcpy(expandBufAddSpace(pReply, replyLen), replyBuf, replyLen);
1447    free(replyBuf);
1448  }
1449  return ERR_NONE;
1450}
1451
1452/*
1453 * Handler map decl.
1454 */
1455typedef JdwpError (*JdwpRequestHandler)(JdwpState* state, Request* request, ExpandBuf* reply);
1456
1457struct JdwpHandlerMap {
1458  uint8_t cmdSet;
1459  uint8_t cmd;
1460  JdwpRequestHandler func;
1461  const char* name;
1462};
1463
1464/*
1465 * Map commands to functions.
1466 *
1467 * Command sets 0-63 are incoming requests, 64-127 are outbound requests,
1468 * and 128-256 are vendor-defined.
1469 */
1470static const JdwpHandlerMap gHandlers[] = {
1471  /* VirtualMachine command set (1) */
1472  { 1,    1,  VM_Version,               "VirtualMachine.Version" },
1473  { 1,    2,  VM_ClassesBySignature,    "VirtualMachine.ClassesBySignature" },
1474  { 1,    3,  VM_AllClasses,            "VirtualMachine.AllClasses" },
1475  { 1,    4,  VM_AllThreads,            "VirtualMachine.AllThreads" },
1476  { 1,    5,  VM_TopLevelThreadGroups,  "VirtualMachine.TopLevelThreadGroups" },
1477  { 1,    6,  VM_Dispose,               "VirtualMachine.Dispose" },
1478  { 1,    7,  VM_IDSizes,               "VirtualMachine.IDSizes" },
1479  { 1,    8,  VM_Suspend,               "VirtualMachine.Suspend" },
1480  { 1,    9,  VM_Resume,                "VirtualMachine.Resume" },
1481  { 1,    10, VM_Exit,                  "VirtualMachine.Exit" },
1482  { 1,    11, VM_CreateString,          "VirtualMachine.CreateString" },
1483  { 1,    12, VM_Capabilities,          "VirtualMachine.Capabilities" },
1484  { 1,    13, VM_ClassPaths,            "VirtualMachine.ClassPaths" },
1485  { 1,    14, VM_DisposeObjects,        "VirtualMachine.DisposeObjects" },
1486  { 1,    15, nullptr,                  "VirtualMachine.HoldEvents" },
1487  { 1,    16, nullptr,                  "VirtualMachine.ReleaseEvents" },
1488  { 1,    17, VM_CapabilitiesNew,       "VirtualMachine.CapabilitiesNew" },
1489  { 1,    18, nullptr,                  "VirtualMachine.RedefineClasses" },
1490  { 1,    19, nullptr,                  "VirtualMachine.SetDefaultStratum" },
1491  { 1,    20, VM_AllClassesWithGeneric, "VirtualMachine.AllClassesWithGeneric" },
1492  { 1,    21, VM_InstanceCounts,        "VirtualMachine.InstanceCounts" },
1493
1494  /* ReferenceType command set (2) */
1495  { 2,    1,  RT_Signature,            "ReferenceType.Signature" },
1496  { 2,    2,  RT_ClassLoader,          "ReferenceType.ClassLoader" },
1497  { 2,    3,  RT_Modifiers,            "ReferenceType.Modifiers" },
1498  { 2,    4,  RT_Fields,               "ReferenceType.Fields" },
1499  { 2,    5,  RT_Methods,              "ReferenceType.Methods" },
1500  { 2,    6,  RT_GetValues,            "ReferenceType.GetValues" },
1501  { 2,    7,  RT_SourceFile,           "ReferenceType.SourceFile" },
1502  { 2,    8,  nullptr,                 "ReferenceType.NestedTypes" },
1503  { 2,    9,  RT_Status,               "ReferenceType.Status" },
1504  { 2,    10, RT_Interfaces,           "ReferenceType.Interfaces" },
1505  { 2,    11, RT_ClassObject,          "ReferenceType.ClassObject" },
1506  { 2,    12, RT_SourceDebugExtension, "ReferenceType.SourceDebugExtension" },
1507  { 2,    13, RT_SignatureWithGeneric, "ReferenceType.SignatureWithGeneric" },
1508  { 2,    14, RT_FieldsWithGeneric,    "ReferenceType.FieldsWithGeneric" },
1509  { 2,    15, RT_MethodsWithGeneric,   "ReferenceType.MethodsWithGeneric" },
1510  { 2,    16, RT_Instances,            "ReferenceType.Instances" },
1511  { 2,    17, nullptr,                 "ReferenceType.ClassFileVersion" },
1512  { 2,    18, nullptr,                 "ReferenceType.ConstantPool" },
1513
1514  /* ClassType command set (3) */
1515  { 3,    1,  CT_Superclass,    "ClassType.Superclass" },
1516  { 3,    2,  CT_SetValues,     "ClassType.SetValues" },
1517  { 3,    3,  CT_InvokeMethod,  "ClassType.InvokeMethod" },
1518  { 3,    4,  CT_NewInstance,   "ClassType.NewInstance" },
1519
1520  /* ArrayType command set (4) */
1521  { 4,    1,  AT_newInstance,   "ArrayType.NewInstance" },
1522
1523  /* InterfaceType command set (5) */
1524
1525  /* Method command set (6) */
1526  { 6,    1,  M_LineTable,                "Method.LineTable" },
1527  { 6,    2,  M_VariableTable,            "Method.VariableTable" },
1528  { 6,    3,  M_Bytecodes,                "Method.Bytecodes" },
1529  { 6,    4,  nullptr,                    "Method.IsObsolete" },
1530  { 6,    5,  M_VariableTableWithGeneric, "Method.VariableTableWithGeneric" },
1531
1532  /* Field command set (8) */
1533
1534  /* ObjectReference command set (9) */
1535  { 9,    1,  OR_ReferenceType,     "ObjectReference.ReferenceType" },
1536  { 9,    2,  OR_GetValues,         "ObjectReference.GetValues" },
1537  { 9,    3,  OR_SetValues,         "ObjectReference.SetValues" },
1538  { 9,    4,  nullptr,              "ObjectReference.UNUSED" },
1539  { 9,    5,  OR_MonitorInfo,       "ObjectReference.MonitorInfo" },
1540  { 9,    6,  OR_InvokeMethod,      "ObjectReference.InvokeMethod" },
1541  { 9,    7,  OR_DisableCollection, "ObjectReference.DisableCollection" },
1542  { 9,    8,  OR_EnableCollection,  "ObjectReference.EnableCollection" },
1543  { 9,    9,  OR_IsCollected,       "ObjectReference.IsCollected" },
1544  { 9,    10, OR_ReferringObjects,  "ObjectReference.ReferringObjects" },
1545
1546  /* StringReference command set (10) */
1547  { 10,   1,  SR_Value,         "StringReference.Value" },
1548
1549  /* ThreadReference command set (11) */
1550  { 11,   1,  TR_Name,                        "ThreadReference.Name" },
1551  { 11,   2,  TR_Suspend,                     "ThreadReference.Suspend" },
1552  { 11,   3,  TR_Resume,                      "ThreadReference.Resume" },
1553  { 11,   4,  TR_Status,                      "ThreadReference.Status" },
1554  { 11,   5,  TR_ThreadGroup,                 "ThreadReference.ThreadGroup" },
1555  { 11,   6,  TR_Frames,                      "ThreadReference.Frames" },
1556  { 11,   7,  TR_FrameCount,                  "ThreadReference.FrameCount" },
1557  { 11,   8,  TR_OwnedMonitors,               "ThreadReference.OwnedMonitors" },
1558  { 11,   9,  TR_CurrentContendedMonitor,     "ThreadReference.CurrentContendedMonitor" },
1559  { 11,   10, nullptr,                        "ThreadReference.Stop" },
1560  { 11,   11, TR_Interrupt,                   "ThreadReference.Interrupt" },
1561  { 11,   12, TR_DebugSuspendCount,           "ThreadReference.SuspendCount" },
1562  { 11,   13, TR_OwnedMonitorsStackDepthInfo, "ThreadReference.OwnedMonitorsStackDepthInfo" },
1563  { 11,   14, nullptr,                        "ThreadReference.ForceEarlyReturn" },
1564
1565  /* ThreadGroupReference command set (12) */
1566  { 12,   1,  TGR_Name,         "ThreadGroupReference.Name" },
1567  { 12,   2,  TGR_Parent,       "ThreadGroupReference.Parent" },
1568  { 12,   3,  TGR_Children,     "ThreadGroupReference.Children" },
1569
1570  /* ArrayReference command set (13) */
1571  { 13,   1,  AR_Length,        "ArrayReference.Length" },
1572  { 13,   2,  AR_GetValues,     "ArrayReference.GetValues" },
1573  { 13,   3,  AR_SetValues,     "ArrayReference.SetValues" },
1574
1575  /* ClassLoaderReference command set (14) */
1576  { 14,   1,  CLR_VisibleClasses, "ClassLoaderReference.VisibleClasses" },
1577
1578  /* EventRequest command set (15) */
1579  { 15,   1,  ER_Set,           "EventRequest.Set" },
1580  { 15,   2,  ER_Clear,         "EventRequest.Clear" },
1581  { 15,   3,  nullptr,          "EventRequest.ClearAllBreakpoints" },
1582
1583  /* StackFrame command set (16) */
1584  { 16,   1,  SF_GetValues,     "StackFrame.GetValues" },
1585  { 16,   2,  SF_SetValues,     "StackFrame.SetValues" },
1586  { 16,   3,  SF_ThisObject,    "StackFrame.ThisObject" },
1587  { 16,   4,  nullptr,          "StackFrame.PopFrames" },
1588
1589  /* ClassObjectReference command set (17) */
1590  { 17,   1,  COR_ReflectedType, "ClassObjectReference.ReflectedType" },
1591
1592  /* Event command set (64) */
1593  { 64, 100,  nullptr, "Event.Composite" },  // sent from VM to debugger, never received by VM
1594
1595  { 199,  1,  DDM_Chunk,        "DDM.Chunk" },
1596};
1597
1598static const char* GetCommandName(Request* request) {
1599  for (size_t i = 0; i < arraysize(gHandlers); ++i) {
1600    if (gHandlers[i].cmdSet == request->GetCommandSet() &&
1601        gHandlers[i].cmd == request->GetCommand()) {
1602      return gHandlers[i].name;
1603    }
1604  }
1605  return "?UNKNOWN?";
1606}
1607
1608static std::string DescribeCommand(Request* request) {
1609  std::string result;
1610  result += "REQUEST: ";
1611  result += GetCommandName(request);
1612  result += StringPrintf(" (length=%zu id=0x%06x)", request->GetLength(), request->GetId());
1613  return result;
1614}
1615
1616/*
1617 * Process a request from the debugger.
1618 *
1619 * On entry, the JDWP thread is in VMWAIT.
1620 */
1621size_t JdwpState::ProcessRequest(Request* request, ExpandBuf* pReply) {
1622  JdwpError result = ERR_NONE;
1623
1624  if (request->GetCommandSet() != kJDWPDdmCmdSet) {
1625    /*
1626     * Activity from a debugger, not merely ddms.  Mark us as having an
1627     * active debugger session, and zero out the last-activity timestamp
1628     * so waitForDebugger() doesn't return if we stall for a bit here.
1629     */
1630    Dbg::GoActive();
1631    last_activity_time_ms_.StoreSequentiallyConsistent(0);
1632  }
1633
1634  /*
1635   * If a debugger event has fired in another thread, wait until the
1636   * initiating thread has suspended itself before processing messages
1637   * from the debugger.  Otherwise we (the JDWP thread) could be told to
1638   * resume the thread before it has suspended.
1639   *
1640   * We call with an argument of zero to wait for the current event
1641   * thread to finish, and then clear the block.  Depending on the thread
1642   * suspend policy, this may allow events in other threads to fire,
1643   * but those events have no bearing on what the debugger has sent us
1644   * in the current request->
1645   *
1646   * Note that we MUST clear the event token before waking the event
1647   * thread up, or risk waiting for the thread to suspend after we've
1648   * told it to resume.
1649   */
1650  SetWaitForEventThread(0);
1651
1652  /*
1653   * We do not want events to be sent while we process a request-> Indicate the JDWP thread starts
1654   * to process a request so other threads wait for it to finish before sending an event.
1655   */
1656  StartProcessingRequest();
1657
1658  /*
1659   * Tell the VM that we're running and shouldn't be interrupted by GC.
1660   * Do this after anything that can stall indefinitely.
1661   */
1662  Thread* self = Thread::Current();
1663  ThreadState old_state = self->TransitionFromSuspendedToRunnable();
1664
1665  expandBufAddSpace(pReply, kJDWPHeaderLen);
1666
1667  size_t i;
1668  for (i = 0; i < arraysize(gHandlers); ++i) {
1669    if (gHandlers[i].cmdSet == request->GetCommandSet() &&
1670        gHandlers[i].cmd == request->GetCommand() &&
1671        gHandlers[i].func != nullptr) {
1672      VLOG(jdwp) << DescribeCommand(request);
1673      result = (*gHandlers[i].func)(this, request, pReply);
1674      if (result == ERR_NONE) {
1675        request->CheckConsumed();
1676      }
1677      break;
1678    }
1679  }
1680  if (i == arraysize(gHandlers)) {
1681    LOG(ERROR) << "Command not implemented: " << DescribeCommand(request);
1682    LOG(ERROR) << HexDump(request->data(), request->size(), false, "");
1683    result = ERR_NOT_IMPLEMENTED;
1684  }
1685
1686  /*
1687   * Set up the reply header.
1688   *
1689   * If we encountered an error, only send the header back.
1690   */
1691  uint8_t* replyBuf = expandBufGetBuffer(pReply);
1692  size_t replyLength = (result == ERR_NONE) ? expandBufGetLength(pReply) : kJDWPHeaderLen;
1693  Set4BE(replyBuf + 0, replyLength);
1694  Set4BE(replyBuf + 4, request->GetId());
1695  Set1(replyBuf + 8, kJDWPFlagReply);
1696  Set2BE(replyBuf + 9, result);
1697
1698  CHECK_GT(expandBufGetLength(pReply), 0U) << GetCommandName(request) << " " << request->GetId();
1699
1700  size_t respLen = expandBufGetLength(pReply) - kJDWPHeaderLen;
1701  VLOG(jdwp) << "REPLY: " << GetCommandName(request) << " " << result << " (length=" << respLen << ")";
1702  if (false) {
1703    VLOG(jdwp) << HexDump(expandBufGetBuffer(pReply) + kJDWPHeaderLen, respLen, false, "");
1704  }
1705
1706  VLOG(jdwp) << "----------";
1707
1708  /*
1709   * Update last-activity timestamp.  We really only need this during
1710   * the initial setup.  Only update if this is a non-DDMS packet.
1711   */
1712  if (request->GetCommandSet() != kJDWPDdmCmdSet) {
1713    last_activity_time_ms_.StoreSequentiallyConsistent(MilliTime());
1714  }
1715
1716  /* tell the VM that GC is okay again */
1717  self->TransitionFromRunnableToSuspended(old_state);
1718
1719  return replyLength;
1720}
1721
1722/*
1723 * Indicates a request is about to be processed. If a thread wants to send an event in the meantime,
1724 * it will need to wait until we processed this request (see EndProcessingRequest).
1725 */
1726void JdwpState::StartProcessingRequest() {
1727  Thread* self = Thread::Current();
1728  CHECK_EQ(self, GetDebugThread()) << "Requests are only processed by debug thread";
1729  MutexLock mu(self, process_request_lock_);
1730  CHECK_EQ(processing_request_, false);
1731  processing_request_ = true;
1732}
1733
1734/*
1735 * Indicates a request has been processed (and we sent its reply). All threads waiting for us (see
1736 * WaitForProcessingRequest) are waken up so they can send events again.
1737 */
1738void JdwpState::EndProcessingRequest() {
1739  Thread* self = Thread::Current();
1740  CHECK_EQ(self, GetDebugThread()) << "Requests are only processed by debug thread";
1741  MutexLock mu(self, process_request_lock_);
1742  CHECK_EQ(processing_request_, true);
1743  processing_request_ = false;
1744  process_request_cond_.Broadcast(self);
1745}
1746
1747/*
1748 * Waits for any request being processed so we do not send an event in the meantime.
1749 */
1750void JdwpState::WaitForProcessingRequest() {
1751  Thread* self = Thread::Current();
1752  CHECK_NE(self, GetDebugThread()) << "Events should not be posted by debug thread";
1753  MutexLock mu(self, process_request_lock_);
1754  bool waited = false;
1755  while (processing_request_) {
1756    VLOG(jdwp) << StringPrintf("wait for processing request");
1757    waited = true;
1758    process_request_cond_.Wait(self);
1759  }
1760  if (waited) {
1761    VLOG(jdwp) << StringPrintf("finished waiting for processing request");
1762  }
1763  CHECK_EQ(processing_request_, false);
1764}
1765
1766}  // namespace JDWP
1767
1768}  // namespace art
1769