blob: a8eaa263c55dc933b24b3179dff70794fd8766b8 [file] [log] [blame]
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Elliott Hughes872d4ec2011-10-21 17:07:15 -070016
Elliott Hughes07ed66b2012-12-12 18:34:25 -080017#include "jdwp/jdwp_event.h"
18
19#include <stddef.h> /* for offsetof() */
Elliott Hughes872d4ec2011-10-21 17:07:15 -070020#include <stdlib.h>
21#include <string.h>
Elliott Hughes872d4ec2011-10-21 17:07:15 -070022#include <unistd.h>
23
Elliott Hughes07ed66b2012-12-12 18:34:25 -080024#include "base/logging.h"
Elliott Hughese222ee02012-12-13 14:41:43 -080025#include "base/stringprintf.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080026#include "debugger.h"
27#include "jdwp/jdwp_constants.h"
28#include "jdwp/jdwp_expand_buf.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080029#include "jdwp/jdwp_priv.h"
Sebastien Hertz6995c602014-09-09 12:10:13 +020030#include "jdwp/object_registry.h"
31#include "mirror/art_field-inl.h"
32#include "scoped_thread_state_change.h"
Ian Rogers693ff612013-02-01 10:56:12 -080033#include "thread-inl.h"
Elliott Hughes07ed66b2012-12-12 18:34:25 -080034
Elliott Hughes872d4ec2011-10-21 17:07:15 -070035/*
36General notes:
37
38The event add/remove stuff usually happens from the debugger thread,
39in response to requests from the debugger, but can also happen as the
40result of an event in an arbitrary thread (e.g. an event with a "count"
41mod expires). It's important to keep the event list locked when processing
42events.
43
44Event posting can happen from any thread. The JDWP thread will not usually
45post anything but VM start/death, but if a JDWP request causes a class
46to be loaded, the ClassPrepare event will come from the JDWP thread.
47
48
49We can have serialization issues when we post an event to the debugger.
50For example, a thread could send an "I hit a breakpoint and am suspending
51myself" message to the debugger. Before it manages to suspend itself, the
52debugger's response ("not interested, resume thread") arrives and is
53processed. We try to resume a thread that hasn't yet suspended.
54
55This means that, after posting an event to the debugger, we need to wait
56for the event thread to suspend itself (and, potentially, all other threads)
57before processing any additional requests from the debugger. While doing
58so we need to be aware that multiple threads may be hitting breakpoints
59or other events simultaneously, so we either need to wait for all of them
60or serialize the events with each other.
61
62The current mechanism works like this:
63 Event thread:
64 - If I'm going to suspend, grab the "I am posting an event" token. Wait
65 for it if it's not currently available.
66 - Post the event to the debugger.
67 - If appropriate, suspend others and then myself. As part of suspending
68 myself, release the "I am posting" token.
69 JDWP thread:
70 - When an event arrives, see if somebody is posting an event. If so,
71 sleep until we can acquire the "I am posting an event" token. Release
72 it immediately and continue processing -- the event we have already
73 received should not interfere with other events that haven't yet
74 been posted.
75
76Some care must be taken to avoid deadlock:
77
78 - thread A and thread B exit near-simultaneously, and post thread-death
79 events with a "suspend all" clause
80 - thread A gets the event token, thread B sits and waits for it
81 - thread A wants to suspend all other threads, but thread B is waiting
82 for the token and can't be suspended
83
84So we need to mark thread B in such a way that thread A doesn't wait for it.
85
86If we just bracket the "grab event token" call with a change to VMWAIT
87before sleeping, the switch back to RUNNING state when we get the token
88will cause thread B to suspend (remember, thread A's global suspend is
89still in force, even after it releases the token). Suspending while
90holding the event token is very bad, because it prevents the JDWP thread
91from processing incoming messages.
92
93We need to change to VMWAIT state at the *start* of posting an event,
94and stay there until we either finish posting the event or decide to
95put ourselves to sleep. That way we don't interfere with anyone else and
96don't allow anyone else to interfere with us.
97*/
98
99
100#define kJdwpEventCommandSet 64
101#define kJdwpCompositeCommand 100
102
103namespace art {
104
105namespace JDWP {
106
107/*
108 * Stuff to compare against when deciding if a mod matches. Only the
109 * values for mods valid for the event being evaluated will be filled in.
110 * The rest will be zeroed.
111 */
112struct ModBasket {
Sebastien Hertz6995c602014-09-09 12:10:13 +0200113 ModBasket() : pLoc(nullptr), thread(nullptr), locationClass(nullptr), exceptionClass(nullptr),
114 caught(false), field(nullptr), thisPtr(nullptr) { }
jeffhao162fd332013-01-08 16:21:01 -0800115
Sebastien Hertz6995c602014-09-09 12:10:13 +0200116 const EventLocation* pLoc; /* LocationOnly */
117 std::string className; /* ClassMatch/ClassExclude */
118 Thread* thread; /* ThreadOnly */
119 mirror::Class* locationClass; /* ClassOnly */
120 mirror::Class* exceptionClass; /* ExceptionOnly */
121 bool caught; /* ExceptionOnly */
122 mirror::ArtField* field; /* FieldOnly */
123 mirror::Object* thisPtr; /* InstanceOnly */
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700124 /* nothing for StepOnly -- handled differently */
125};
126
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100127static bool NeedsFullDeoptimization(JdwpEventKind eventKind) {
Sebastien Hertzf3928792014-11-17 19:00:37 +0100128 if (!Dbg::RequiresDeoptimization()) {
129 // We don't need deoptimization for debugging.
130 return false;
131 }
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100132 switch (eventKind) {
133 case EK_METHOD_ENTRY:
134 case EK_METHOD_EXIT:
135 case EK_METHOD_EXIT_WITH_RETURN_VALUE:
136 case EK_SINGLE_STEP:
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200137 case EK_FIELD_ACCESS:
138 case EK_FIELD_MODIFICATION:
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100139 return true;
140 default:
141 return false;
142 }
143}
144
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800145static uint32_t GetInstrumentationEventFor(JdwpEventKind eventKind) {
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200146 switch (eventKind) {
147 case EK_BREAKPOINT:
148 case EK_SINGLE_STEP:
149 return instrumentation::Instrumentation::kDexPcMoved;
150 case EK_EXCEPTION:
151 case EK_EXCEPTION_CATCH:
152 return instrumentation::Instrumentation::kExceptionCaught;
153 case EK_METHOD_ENTRY:
154 return instrumentation::Instrumentation::kMethodEntered;
155 case EK_METHOD_EXIT:
156 case EK_METHOD_EXIT_WITH_RETURN_VALUE:
157 return instrumentation::Instrumentation::kMethodExited;
158 case EK_FIELD_ACCESS:
159 return instrumentation::Instrumentation::kFieldRead;
160 case EK_FIELD_MODIFICATION:
161 return instrumentation::Instrumentation::kFieldWritten;
162 default:
163 return 0;
164 }
165}
166
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700167/*
168 * Add an event to the list. Ordering is not important.
169 *
170 * If something prevents the event from being registered, e.g. it's a
171 * single-step request on a thread that doesn't exist, the event will
172 * not be added to the list, and an appropriate error will be returned.
173 */
Elliott Hughes761928d2011-11-16 18:33:03 -0800174JdwpError JdwpState::RegisterEvent(JdwpEvent* pEvent) {
Sebastien Hertz7d955652014-10-22 10:57:10 +0200175 CHECK(pEvent != nullptr);
176 CHECK(pEvent->prev == nullptr);
177 CHECK(pEvent->next == nullptr);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700178
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200179 {
180 /*
181 * If one or more "break"-type mods are used, register them with
182 * the interpreter.
183 */
184 DeoptimizationRequest req;
185 for (int i = 0; i < pEvent->modCount; i++) {
186 const JdwpEventMod* pMod = &pEvent->mods[i];
187 if (pMod->modKind == MK_LOCATION_ONLY) {
Sebastien Hertz033aabf2014-10-08 13:54:55 +0200188 // Should only concern breakpoint, field access, field modification, step, and exception
189 // events.
190 // However breakpoint requires specific handling. Field access, field modification and step
191 // events need full deoptimization to be reported while exception event is reported during
192 // exception handling.
193 if (pEvent->eventKind == EK_BREAKPOINT) {
194 Dbg::WatchLocation(&pMod->locationOnly.loc, &req);
195 }
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200196 } else if (pMod->modKind == MK_STEP) {
197 /* should only be for EK_SINGLE_STEP; should only be one */
198 JdwpStepSize size = static_cast<JdwpStepSize>(pMod->step.size);
199 JdwpStepDepth depth = static_cast<JdwpStepDepth>(pMod->step.depth);
200 JdwpError status = Dbg::ConfigureStep(pMod->step.threadId, size, depth);
201 if (status != ERR_NONE) {
202 return status;
203 }
Elliott Hughes2435a572012-02-17 16:07:41 -0800204 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700205 }
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200206 if (NeedsFullDeoptimization(pEvent->eventKind)) {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700207 CHECK_EQ(req.GetKind(), DeoptimizationRequest::kNothing);
208 CHECK(req.Method() == nullptr);
209 req.SetKind(DeoptimizationRequest::kFullDeoptimization);
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200210 }
211 Dbg::RequestDeoptimization(req);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700212 }
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200213 uint32_t instrumentation_event = GetInstrumentationEventFor(pEvent->eventKind);
214 if (instrumentation_event != 0) {
215 DeoptimizationRequest req;
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700216 req.SetKind(DeoptimizationRequest::kRegisterForEvent);
217 req.SetInstrumentationEvent(instrumentation_event);
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200218 Dbg::RequestDeoptimization(req);
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100219 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700220
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100221 {
222 /*
223 * Add to list.
224 */
225 MutexLock mu(Thread::Current(), event_list_lock_);
Sebastien Hertz7d955652014-10-22 10:57:10 +0200226 if (event_list_ != nullptr) {
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100227 pEvent->next = event_list_;
228 event_list_->prev = pEvent;
229 }
230 event_list_ = pEvent;
231 ++event_list_size_;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700232 }
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100233
234 Dbg::ManageDeoptimization();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700235
236 return ERR_NONE;
237}
238
239/*
240 * Remove an event from the list. This will also remove the event from
241 * any optimization tables, e.g. breakpoints.
242 *
243 * Does not free the JdwpEvent.
244 *
245 * Grab the eventLock before calling here.
246 */
Elliott Hughes761928d2011-11-16 18:33:03 -0800247void JdwpState::UnregisterEvent(JdwpEvent* pEvent) {
Sebastien Hertz7d955652014-10-22 10:57:10 +0200248 if (pEvent->prev == nullptr) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700249 /* head of the list */
Elliott Hughesf8349362012-06-18 15:00:06 -0700250 CHECK(event_list_ == pEvent);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700251
Elliott Hughesf8349362012-06-18 15:00:06 -0700252 event_list_ = pEvent->next;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700253 } else {
254 pEvent->prev->next = pEvent->next;
255 }
256
Sebastien Hertz7d955652014-10-22 10:57:10 +0200257 if (pEvent->next != nullptr) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700258 pEvent->next->prev = pEvent->prev;
Sebastien Hertz7d955652014-10-22 10:57:10 +0200259 pEvent->next = nullptr;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700260 }
Sebastien Hertz7d955652014-10-22 10:57:10 +0200261 pEvent->prev = nullptr;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700262
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200263 {
264 /*
265 * Unhook us from the interpreter, if necessary.
266 */
267 DeoptimizationRequest req;
268 for (int i = 0; i < pEvent->modCount; i++) {
269 JdwpEventMod* pMod = &pEvent->mods[i];
270 if (pMod->modKind == MK_LOCATION_ONLY) {
Sebastien Hertz033aabf2014-10-08 13:54:55 +0200271 // Like in RegisterEvent, we need specific handling for breakpoint only.
272 if (pEvent->eventKind == EK_BREAKPOINT) {
273 Dbg::UnwatchLocation(&pMod->locationOnly.loc, &req);
274 }
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200275 }
276 if (pMod->modKind == MK_STEP) {
277 /* should only be for EK_SINGLE_STEP; should only be one */
278 Dbg::UnconfigureStep(pMod->step.threadId);
279 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700280 }
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200281 if (pEvent->eventKind == EK_SINGLE_STEP) {
282 // Special case for single-steps where we want to avoid the slow pattern deoptimize/undeoptimize
283 // loop between each single-step. In a IDE, this would happens each time the user click on the
284 // "single-step" button. Here we delay the full undeoptimization to the next resume
285 // (VM.Resume or ThreadReference.Resume) or the end of the debugging session (VM.Dispose or
286 // runtime shutdown).
287 // Therefore, in a singles-stepping sequence, only the first single-step will trigger a full
288 // deoptimization and only the last single-step will trigger a full undeoptimization.
289 Dbg::DelayFullUndeoptimization();
290 } else if (NeedsFullDeoptimization(pEvent->eventKind)) {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700291 CHECK_EQ(req.GetKind(), DeoptimizationRequest::kNothing);
292 CHECK(req.Method() == nullptr);
293 req.SetKind(DeoptimizationRequest::kFullUndeoptimization);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700294 }
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200295 Dbg::RequestDeoptimization(req);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700296 }
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200297 uint32_t instrumentation_event = GetInstrumentationEventFor(pEvent->eventKind);
298 if (instrumentation_event != 0) {
299 DeoptimizationRequest req;
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700300 req.SetKind(DeoptimizationRequest::kUnregisterForEvent);
301 req.SetInstrumentationEvent(instrumentation_event);
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200302 Dbg::RequestDeoptimization(req);
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100303 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700304
Elliott Hughesf8349362012-06-18 15:00:06 -0700305 --event_list_size_;
Sebastien Hertz7d955652014-10-22 10:57:10 +0200306 CHECK(event_list_size_ != 0 || event_list_ == nullptr);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700307}
308
309/*
310 * Remove the event with the given ID from the list.
311 *
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700312 */
Elliott Hughes761928d2011-11-16 18:33:03 -0800313void JdwpState::UnregisterEventById(uint32_t requestId) {
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100314 bool found = false;
315 {
316 MutexLock mu(Thread::Current(), event_list_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700317
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100318 for (JdwpEvent* pEvent = event_list_; pEvent != nullptr; pEvent = pEvent->next) {
319 if (pEvent->requestId == requestId) {
320 found = true;
321 UnregisterEvent(pEvent);
322 EventFree(pEvent);
323 break; /* there can be only one with a given ID */
324 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700325 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700326 }
327
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100328 if (found) {
329 Dbg::ManageDeoptimization();
330 } else {
Sebastien Hertzf272af42014-09-18 10:20:42 +0200331 // Failure to find the event isn't really an error. For instance, it looks like Eclipse will
332 // try to be extra careful and will explicitly remove one-off single-step events (using a
333 // 'count' event modifier of 1). So the event may have already been removed as part of the
334 // event notification (see JdwpState::CleanupMatchList).
335 VLOG(jdwp) << StringPrintf("No match when removing event reqId=0x%04x", requestId);
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100336 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700337}
338
339/*
340 * Remove all entries from the event list.
341 */
Elliott Hughes761928d2011-11-16 18:33:03 -0800342void JdwpState::UnregisterAll() {
Ian Rogers50b35e22012-10-04 10:09:15 -0700343 MutexLock mu(Thread::Current(), event_list_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700344
Elliott Hughesf8349362012-06-18 15:00:06 -0700345 JdwpEvent* pEvent = event_list_;
Sebastien Hertz7d955652014-10-22 10:57:10 +0200346 while (pEvent != nullptr) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700347 JdwpEvent* pNextEvent = pEvent->next;
348
Elliott Hughes761928d2011-11-16 18:33:03 -0800349 UnregisterEvent(pEvent);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700350 EventFree(pEvent);
351 pEvent = pNextEvent;
352 }
353
Sebastien Hertz7d955652014-10-22 10:57:10 +0200354 event_list_ = nullptr;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700355}
356
357/*
358 * Allocate a JdwpEvent struct with enough space to hold the specified
359 * number of mod records.
360 */
361JdwpEvent* EventAlloc(int numMods) {
362 JdwpEvent* newEvent;
363 int allocSize = offsetof(JdwpEvent, mods) + numMods * sizeof(newEvent->mods[0]);
364 newEvent = reinterpret_cast<JdwpEvent*>(malloc(allocSize));
365 memset(newEvent, 0, allocSize);
366 return newEvent;
367}
368
369/*
370 * Free a JdwpEvent.
371 *
372 * Do not call this until the event has been removed from the list.
373 */
374void EventFree(JdwpEvent* pEvent) {
Sebastien Hertz7d955652014-10-22 10:57:10 +0200375 if (pEvent == nullptr) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700376 return;
377 }
378
379 /* make sure it was removed from the list */
Sebastien Hertz7d955652014-10-22 10:57:10 +0200380 CHECK(pEvent->prev == nullptr);
381 CHECK(pEvent->next == nullptr);
Elliott Hughesf8349362012-06-18 15:00:06 -0700382 /* want to check state->event_list_ != pEvent */
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700383
384 /*
385 * Free any hairy bits in the mods.
386 */
387 for (int i = 0; i < pEvent->modCount; i++) {
388 if (pEvent->mods[i].modKind == MK_CLASS_MATCH) {
389 free(pEvent->mods[i].classMatch.classPattern);
Sebastien Hertz7d955652014-10-22 10:57:10 +0200390 pEvent->mods[i].classMatch.classPattern = nullptr;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700391 }
392 if (pEvent->mods[i].modKind == MK_CLASS_EXCLUDE) {
393 free(pEvent->mods[i].classExclude.classPattern);
Sebastien Hertz7d955652014-10-22 10:57:10 +0200394 pEvent->mods[i].classExclude.classPattern = nullptr;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700395 }
396 }
397
398 free(pEvent);
399}
400
401/*
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700402 * Run through the list and remove any entries with an expired "count" mod
Sebastien Hertz7d955652014-10-22 10:57:10 +0200403 * from the event list.
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700404 */
Sebastien Hertz7d955652014-10-22 10:57:10 +0200405void JdwpState::CleanupMatchList(const std::vector<JdwpEvent*>& match_list) {
406 for (JdwpEvent* pEvent : match_list) {
407 for (int i = 0; i < pEvent->modCount; ++i) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700408 if (pEvent->mods[i].modKind == MK_COUNT && pEvent->mods[i].count.count == 0) {
Sebastien Hertzbca0d3d2014-04-11 16:01:17 +0200409 VLOG(jdwp) << StringPrintf("##### Removing expired event (requestId=%#" PRIx32 ")",
410 pEvent->requestId);
Elliott Hughes761928d2011-11-16 18:33:03 -0800411 UnregisterEvent(pEvent);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700412 EventFree(pEvent);
413 break;
414 }
415 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700416 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700417}
418
419/*
420 * Match a string against a "restricted regular expression", which is just
421 * a string that may start or end with '*' (e.g. "*.Foo" or "java.*").
422 *
423 * ("Restricted name globbing" might have been a better term.)
424 */
Elliott Hughes761928d2011-11-16 18:33:03 -0800425static bool PatternMatch(const char* pattern, const std::string& target) {
Elliott Hughesa2155262011-11-16 16:26:58 -0800426 size_t patLen = strlen(pattern);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700427 if (pattern[0] == '*') {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700428 patLen--;
Elliott Hughesa2155262011-11-16 16:26:58 -0800429 if (target.size() < patLen) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700430 return false;
431 }
Elliott Hughesa2155262011-11-16 16:26:58 -0800432 return strcmp(pattern+1, target.c_str() + (target.size()-patLen)) == 0;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700433 } else if (pattern[patLen-1] == '*') {
Elliott Hughesa2155262011-11-16 16:26:58 -0800434 return strncmp(pattern, target.c_str(), patLen-1) == 0;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700435 } else {
Elliott Hughesa2155262011-11-16 16:26:58 -0800436 return strcmp(pattern, target.c_str()) == 0;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700437 }
438}
439
440/*
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700441 * See if the event's mods match up with the contents of "basket".
442 *
443 * If we find a Count mod before rejecting an event, we decrement it. We
444 * need to do this even if later mods cause us to ignore the event.
445 */
Sebastien Hertzbca0d3d2014-04-11 16:01:17 +0200446static bool ModsMatch(JdwpEvent* pEvent, const ModBasket& basket)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700447 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700448 JdwpEventMod* pMod = pEvent->mods;
449
450 for (int i = pEvent->modCount; i > 0; i--, pMod++) {
451 switch (pMod->modKind) {
452 case MK_COUNT:
453 CHECK_GT(pMod->count.count, 0);
454 pMod->count.count--;
Sebastien Hertz43207792014-04-15 16:03:27 +0200455 if (pMod->count.count > 0) {
456 return false;
457 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700458 break;
459 case MK_CONDITIONAL:
460 CHECK(false); // should not be getting these
461 break;
462 case MK_THREAD_ONLY:
Sebastien Hertz6995c602014-09-09 12:10:13 +0200463 if (!Dbg::MatchThread(pMod->threadOnly.threadId, basket.thread)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700464 return false;
465 }
466 break;
467 case MK_CLASS_ONLY:
Sebastien Hertz6995c602014-09-09 12:10:13 +0200468 if (!Dbg::MatchType(basket.locationClass, pMod->classOnly.refTypeId)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700469 return false;
470 }
471 break;
472 case MK_CLASS_MATCH:
Sebastien Hertzbca0d3d2014-04-11 16:01:17 +0200473 if (!PatternMatch(pMod->classMatch.classPattern, basket.className)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700474 return false;
475 }
476 break;
477 case MK_CLASS_EXCLUDE:
Sebastien Hertzbca0d3d2014-04-11 16:01:17 +0200478 if (PatternMatch(pMod->classMatch.classPattern, basket.className)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700479 return false;
480 }
481 break;
482 case MK_LOCATION_ONLY:
Sebastien Hertz6995c602014-09-09 12:10:13 +0200483 if (!Dbg::MatchLocation(pMod->locationOnly.loc, *basket.pLoc)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700484 return false;
485 }
486 break;
487 case MK_EXCEPTION_ONLY:
Sebastien Hertz6995c602014-09-09 12:10:13 +0200488 if (pMod->exceptionOnly.refTypeId != 0 &&
489 !Dbg::MatchType(basket.exceptionClass, pMod->exceptionOnly.refTypeId)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700490 return false;
491 }
Sebastien Hertz6995c602014-09-09 12:10:13 +0200492 if ((basket.caught && !pMod->exceptionOnly.caught) ||
493 (!basket.caught && !pMod->exceptionOnly.uncaught)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700494 return false;
495 }
496 break;
497 case MK_FIELD_ONLY:
Sebastien Hertz6995c602014-09-09 12:10:13 +0200498 if (!Dbg::MatchField(pMod->fieldOnly.refTypeId, pMod->fieldOnly.fieldId, basket.field)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700499 return false;
500 }
501 break;
502 case MK_STEP:
Sebastien Hertz6995c602014-09-09 12:10:13 +0200503 if (!Dbg::MatchThread(pMod->step.threadId, basket.thread)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700504 return false;
505 }
506 break;
507 case MK_INSTANCE_ONLY:
Sebastien Hertz6995c602014-09-09 12:10:13 +0200508 if (!Dbg::MatchInstance(pMod->instanceOnly.objectId, basket.thisPtr)) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700509 return false;
510 }
511 break;
512 default:
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800513 LOG(FATAL) << "unknown mod kind " << pMod->modKind;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700514 break;
515 }
516 }
517 return true;
518}
519
520/*
Sebastien Hertz7d955652014-10-22 10:57:10 +0200521 * Find all events of type "event_kind" with mods that match up with the
522 * rest of the arguments while holding the event list lock. This method
523 * is used by FindMatchingEvents below.
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700524 *
Sebastien Hertz7d955652014-10-22 10:57:10 +0200525 * Found events are appended to "match_list" so this may be called multiple times for grouped
526 * events.
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700527 *
528 * DO NOT call this multiple times for the same eventKind, as Count mods are
529 * decremented during the scan.
530 */
Sebastien Hertz7d955652014-10-22 10:57:10 +0200531void JdwpState::FindMatchingEventsLocked(JdwpEventKind event_kind, const ModBasket& basket,
532 std::vector<JdwpEvent*>* match_list) {
Sebastien Hertzbca0d3d2014-04-11 16:01:17 +0200533 for (JdwpEvent* pEvent = event_list_; pEvent != nullptr; pEvent = pEvent->next) {
Sebastien Hertz7d955652014-10-22 10:57:10 +0200534 if (pEvent->eventKind == event_kind && ModsMatch(pEvent, basket)) {
535 match_list->push_back(pEvent);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700536 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700537 }
538}
539
540/*
Sebastien Hertz7d955652014-10-22 10:57:10 +0200541 * Find all events of type "event_kind" with mods that match up with the
542 * rest of the arguments and return true if at least one event matches,
543 * false otherwise.
544 *
545 * Found events are appended to "match_list" so this may be called multiple
546 * times for grouped events.
547 *
548 * DO NOT call this multiple times for the same eventKind, as Count mods are
549 * decremented during the scan.
550 */
551bool JdwpState::FindMatchingEvents(JdwpEventKind event_kind, const ModBasket& basket,
552 std::vector<JdwpEvent*>* match_list) {
553 MutexLock mu(Thread::Current(), event_list_lock_);
554 match_list->reserve(event_list_size_);
555 FindMatchingEventsLocked(event_kind, basket, match_list);
556 return !match_list->empty();
557}
558
559/*
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700560 * Scan through the list of matches and determine the most severe
561 * suspension policy.
562 */
Sebastien Hertz7d955652014-10-22 10:57:10 +0200563static JdwpSuspendPolicy ScanSuspendPolicy(const std::vector<JdwpEvent*>& match_list) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700564 JdwpSuspendPolicy policy = SP_NONE;
565
Sebastien Hertz7d955652014-10-22 10:57:10 +0200566 for (JdwpEvent* pEvent : match_list) {
567 if (pEvent->suspend_policy > policy) {
568 policy = pEvent->suspend_policy;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700569 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700570 }
571
572 return policy;
573}
574
575/*
576 * Three possibilities:
577 * SP_NONE - do nothing
578 * SP_EVENT_THREAD - suspend ourselves
579 * SP_ALL - suspend everybody except JDWP support thread
580 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700581void JdwpState::SuspendByPolicy(JdwpSuspendPolicy suspend_policy, JDWP::ObjectId thread_self_id) {
Elliott Hughesf8349362012-06-18 15:00:06 -0700582 VLOG(jdwp) << "SuspendByPolicy(" << suspend_policy << ")";
583 if (suspend_policy == SP_NONE) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700584 return;
585 }
586
Elliott Hughesf8349362012-06-18 15:00:06 -0700587 if (suspend_policy == SP_ALL) {
Elliott Hughes475fc232011-10-25 15:00:35 -0700588 Dbg::SuspendVM();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700589 } else {
Elliott Hughesf8349362012-06-18 15:00:06 -0700590 CHECK_EQ(suspend_policy, SP_EVENT_THREAD);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700591 }
592
593 /* this is rare but possible -- see CLASS_PREPARE handling */
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700594 if (thread_self_id == debug_thread_id_) {
Elliott Hughes761928d2011-11-16 18:33:03 -0800595 LOG(INFO) << "NOTE: SuspendByPolicy not suspending JDWP thread";
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700596 return;
597 }
598
599 DebugInvokeReq* pReq = Dbg::GetInvokeReq();
600 while (true) {
601 pReq->ready = true;
602 Dbg::SuspendSelf();
603 pReq->ready = false;
604
605 /*
606 * The JDWP thread has told us (and possibly all other threads) to
607 * resume. See if it has left anything in our DebugInvokeReq mailbox.
608 */
Sebastien Hertzd38667a2013-11-25 15:43:54 +0100609 if (!pReq->invoke_needed) {
Elliott Hughes761928d2011-11-16 18:33:03 -0800610 /*LOGD("SuspendByPolicy: no invoke needed");*/
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700611 break;
612 }
613
614 /* grab this before posting/suspending again */
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700615 SetWaitForEventThread(thread_self_id);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700616
Elliott Hughesd07986f2011-12-06 18:27:45 -0800617 /* leave pReq->invoke_needed_ raised so we can check reentrancy */
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700618 Dbg::ExecuteMethod(pReq);
619
Elliott Hughes475fc232011-10-25 15:00:35 -0700620 pReq->error = ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700621 }
622}
623
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700624void JdwpState::SendRequestAndPossiblySuspend(ExpandBuf* pReq, JdwpSuspendPolicy suspend_policy,
625 ObjectId threadId) {
Sebastien Hertz7d955652014-10-22 10:57:10 +0200626 Thread* const self = Thread::Current();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700627 self->AssertThreadSuspensionIsAllowable();
Sebastien Hertz7d955652014-10-22 10:57:10 +0200628 CHECK(pReq != nullptr);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700629 /* send request and possibly suspend ourselves */
Sebastien Hertz7d955652014-10-22 10:57:10 +0200630 JDWP::ObjectId thread_self_id = Dbg::GetThreadSelfId();
631 self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSend);
632 if (suspend_policy != SP_NONE) {
633 SetWaitForEventThread(threadId);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700634 }
Sebastien Hertz7d955652014-10-22 10:57:10 +0200635 EventFinish(pReq);
636 SuspendByPolicy(suspend_policy, thread_self_id);
637 self->TransitionFromSuspendedToRunnable();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700638}
639
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700640/*
641 * Determine if there is a method invocation in progress in the current
642 * thread.
643 *
Elliott Hughes475fc232011-10-25 15:00:35 -0700644 * We look at the "invoke_needed" flag in the per-thread DebugInvokeReq
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700645 * state. If set, we're in the process of invoking a method.
646 */
Elliott Hughes761928d2011-11-16 18:33:03 -0800647bool JdwpState::InvokeInProgress() {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700648 DebugInvokeReq* pReq = Dbg::GetInvokeReq();
Sebastien Hertzd38667a2013-11-25 15:43:54 +0100649 return pReq->invoke_needed;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700650}
651
652/*
653 * We need the JDWP thread to hold off on doing stuff while we post an
654 * event and then suspend ourselves.
655 *
656 * Call this with a threadId of zero if you just want to wait for the
657 * current thread operation to complete.
658 *
659 * This could go to sleep waiting for another thread, so it's important
660 * that the thread be marked as VMWAIT before calling here.
661 */
Elliott Hughes376a7a02011-10-24 18:35:55 -0700662void JdwpState::SetWaitForEventThread(ObjectId threadId) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700663 bool waited = false;
664
665 /* this is held for very brief periods; contention is unlikely */
Ian Rogers81d425b2012-09-27 16:03:43 -0700666 Thread* self = Thread::Current();
667 MutexLock mu(self, event_thread_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700668
669 /*
670 * If another thread is already doing stuff, wait for it. This can
671 * go to sleep indefinitely.
672 */
Elliott Hughesa21039c2012-06-21 12:09:25 -0700673 while (event_thread_id_ != 0) {
Ian Rogersd9e4e0c2014-01-23 20:11:40 -0800674 VLOG(jdwp) << StringPrintf("event in progress (%#" PRIx64 "), %#" PRIx64 " sleeping",
675 event_thread_id_, threadId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700676 waited = true;
Ian Rogersc604d732012-10-14 16:09:54 -0700677 event_thread_cond_.Wait(self);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700678 }
679
680 if (waited || threadId != 0) {
Ian Rogersd9e4e0c2014-01-23 20:11:40 -0800681 VLOG(jdwp) << StringPrintf("event token grabbed (%#" PRIx64 ")", threadId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700682 }
683 if (threadId != 0) {
Elliott Hughesa21039c2012-06-21 12:09:25 -0700684 event_thread_id_ = threadId;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700685 }
686}
687
688/*
689 * Clear the threadId and signal anybody waiting.
690 */
Elliott Hughes376a7a02011-10-24 18:35:55 -0700691void JdwpState::ClearWaitForEventThread() {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700692 /*
693 * Grab the mutex. Don't try to go in/out of VMWAIT mode, as this
694 * function is called by dvmSuspendSelf(), and the transition back
695 * to RUNNING would confuse it.
696 */
Ian Rogersc604d732012-10-14 16:09:54 -0700697 Thread* self = Thread::Current();
698 MutexLock mu(self, event_thread_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700699
Elliott Hughesa21039c2012-06-21 12:09:25 -0700700 CHECK_NE(event_thread_id_, 0U);
Ian Rogersd9e4e0c2014-01-23 20:11:40 -0800701 VLOG(jdwp) << StringPrintf("cleared event token (%#" PRIx64 ")", event_thread_id_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700702
Elliott Hughesa21039c2012-06-21 12:09:25 -0700703 event_thread_id_ = 0;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700704
Ian Rogersc604d732012-10-14 16:09:54 -0700705 event_thread_cond_.Signal(self);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700706}
707
708
709/*
710 * Prep an event. Allocates storage for the message and leaves space for
711 * the header.
712 */
713static ExpandBuf* eventPrep() {
714 ExpandBuf* pReq = expandBufAlloc();
715 expandBufAddSpace(pReq, kJDWPHeaderLen);
716 return pReq;
717}
718
719/*
720 * Write the header into the buffer and send the packet off to the debugger.
721 *
722 * Takes ownership of "pReq" (currently discards it).
723 */
Elliott Hughes761928d2011-11-16 18:33:03 -0800724void JdwpState::EventFinish(ExpandBuf* pReq) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700725 uint8_t* buf = expandBufGetBuffer(pReq);
726
Elliott Hughesf7c3b662011-10-27 12:04:56 -0700727 Set4BE(buf, expandBufGetLength(pReq));
Sebastien Hertz7d955652014-10-22 10:57:10 +0200728 Set4BE(buf + 4, NextRequestSerial());
729 Set1(buf + 8, 0); /* flags */
730 Set1(buf + 9, kJdwpEventCommandSet);
731 Set1(buf + 10, kJdwpCompositeCommand);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700732
Sebastien Hertz99660e12014-02-19 15:04:42 +0100733 // Prevents from interleaving commands and events. Otherwise we could end up in sending an event
734 // before sending the reply of the command being processed and would lead to bad synchronization
735 // between the debugger and the debuggee.
736 WaitForProcessingRequest();
737
Elliott Hughes761928d2011-11-16 18:33:03 -0800738 SendRequest(pReq);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700739
740 expandBufFree(pReq);
741}
742
743
744/*
745 * Tell the debugger that we have finished initializing. This is always
746 * sent, even if the debugger hasn't requested it.
747 *
748 * This should be sent "before the main thread is started and before
749 * any application code has been executed". The thread ID in the message
750 * must be for the main thread.
751 */
Sebastien Hertz7d955652014-10-22 10:57:10 +0200752void JdwpState::PostVMStart() {
753 JdwpSuspendPolicy suspend_policy = (options_->suspend) ? SP_ALL : SP_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700754 ObjectId threadId = Dbg::GetThreadSelfId();
755
Sebastien Hertz7d955652014-10-22 10:57:10 +0200756 VLOG(jdwp) << "EVENT: " << EK_VM_START;
757 VLOG(jdwp) << " suspend_policy=" << suspend_policy;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700758
Elliott Hughes761928d2011-11-16 18:33:03 -0800759 ExpandBuf* pReq = eventPrep();
Sebastien Hertz7d955652014-10-22 10:57:10 +0200760 expandBufAdd1(pReq, suspend_policy);
761 expandBufAdd4BE(pReq, 1);
762 expandBufAdd1(pReq, EK_VM_START);
763 expandBufAdd4BE(pReq, 0); /* requestId */
764 expandBufAddObjectId(pReq, threadId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700765
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100766 Dbg::ManageDeoptimization();
767
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700768 /* send request and possibly suspend ourselves */
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700769 SendRequestAndPossiblySuspend(pReq, suspend_policy, threadId);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700770}
771
Sebastien Hertz7d955652014-10-22 10:57:10 +0200772static void LogMatchingEventsAndThread(const std::vector<JdwpEvent*> match_list,
Sebastien Hertz6995c602014-09-09 12:10:13 +0200773 ObjectId thread_id)
Sebastien Hertzbca0d3d2014-04-11 16:01:17 +0200774 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Sebastien Hertz7d955652014-10-22 10:57:10 +0200775 for (size_t i = 0, e = match_list.size(); i < e; ++i) {
Sebastien Hertzbca0d3d2014-04-11 16:01:17 +0200776 JdwpEvent* pEvent = match_list[i];
777 VLOG(jdwp) << "EVENT #" << i << ": " << pEvent->eventKind
778 << StringPrintf(" (requestId=%#" PRIx32 ")", pEvent->requestId);
779 }
780 std::string thread_name;
Sebastien Hertz6995c602014-09-09 12:10:13 +0200781 JdwpError error = Dbg::GetThreadName(thread_id, &thread_name);
Sebastien Hertzbca0d3d2014-04-11 16:01:17 +0200782 if (error != JDWP::ERR_NONE) {
783 thread_name = "<unknown>";
784 }
Sebastien Hertz6995c602014-09-09 12:10:13 +0200785 VLOG(jdwp) << StringPrintf(" thread=%#" PRIx64, thread_id) << " " << thread_name;
786}
787
788static void SetJdwpLocationFromEventLocation(const JDWP::EventLocation* event_location,
789 JDWP::JdwpLocation* jdwp_location)
790 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
791 DCHECK(event_location != nullptr);
792 DCHECK(jdwp_location != nullptr);
793 Dbg::SetJdwpLocation(jdwp_location, event_location->method, event_location->dex_pc);
Sebastien Hertzbca0d3d2014-04-11 16:01:17 +0200794}
795
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700796/*
797 * A location of interest has been reached. This handles:
798 * Breakpoint
799 * SingleStep
800 * MethodEntry
801 * MethodExit
802 * These four types must be grouped together in a single response. The
803 * "eventFlags" indicates the type of event(s) that have happened.
804 *
805 * Valid mods:
806 * Count, ThreadOnly, ClassOnly, ClassMatch, ClassExclude, InstanceOnly
807 * LocationOnly (for breakpoint/step only)
808 * Step (for step only)
809 *
810 * Interesting test cases:
811 * - Put a breakpoint on a native method. Eclipse creates METHOD_ENTRY
812 * and METHOD_EXIT events with a ClassOnly mod on the method's class.
813 * - Use "run to line". Eclipse creates a BREAKPOINT with Count=1.
814 * - Single-step to a line with a breakpoint. Should get a single
815 * event message with both events in it.
816 */
Sebastien Hertz7d955652014-10-22 10:57:10 +0200817void JdwpState::PostLocationEvent(const EventLocation* pLoc, mirror::Object* thisPtr,
Sebastien Hertz6995c602014-09-09 12:10:13 +0200818 int eventFlags, const JValue* returnValue) {
819 DCHECK(pLoc != nullptr);
820 DCHECK(pLoc->method != nullptr);
821 DCHECK_EQ(pLoc->method->IsStatic(), thisPtr == nullptr);
822
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700823 ModBasket basket;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700824 basket.pLoc = pLoc;
Sebastien Hertz6995c602014-09-09 12:10:13 +0200825 basket.locationClass = pLoc->method->GetDeclaringClass();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700826 basket.thisPtr = thisPtr;
Sebastien Hertz6995c602014-09-09 12:10:13 +0200827 basket.thread = Thread::Current();
828 basket.className = Dbg::GetClassName(basket.locationClass);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700829
830 /*
831 * On rare occasions we may need to execute interpreted code in the VM
832 * while handling a request from the debugger. Don't fire breakpoints
833 * while doing so. (I don't think we currently do this at all, so
834 * this is mostly paranoia.)
835 */
Sebastien Hertz6995c602014-09-09 12:10:13 +0200836 if (basket.thread == GetDebugThread()) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800837 VLOG(jdwp) << "Ignoring location event in JDWP thread";
Sebastien Hertz7d955652014-10-22 10:57:10 +0200838 return;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700839 }
840
841 /*
842 * The debugger variable display tab may invoke the interpreter to format
843 * complex objects. We want to ignore breakpoints and method entry/exit
844 * traps while working on behalf of the debugger.
845 *
846 * If we don't ignore them, the VM will get hung up, because we'll
847 * suspend on a breakpoint while the debugger is still waiting for its
848 * method invocation to complete.
849 */
Elliott Hughes761928d2011-11-16 18:33:03 -0800850 if (InvokeInProgress()) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800851 VLOG(jdwp) << "Not checking breakpoints during invoke (" << basket.className << ")";
Sebastien Hertz7d955652014-10-22 10:57:10 +0200852 return;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700853 }
854
Sebastien Hertz7d955652014-10-22 10:57:10 +0200855 std::vector<JdwpEvent*> match_list;
Elliott Hughes761928d2011-11-16 18:33:03 -0800856 {
Sebastien Hertz7d955652014-10-22 10:57:10 +0200857 // We use the locked version because we have multiple possible match events.
858 MutexLock mu(Thread::Current(), event_list_lock_);
859 match_list.reserve(event_list_size_);
860 if ((eventFlags & Dbg::kBreakpoint) != 0) {
861 FindMatchingEventsLocked(EK_BREAKPOINT, basket, &match_list);
Elliott Hughes761928d2011-11-16 18:33:03 -0800862 }
Sebastien Hertz7d955652014-10-22 10:57:10 +0200863 if ((eventFlags & Dbg::kSingleStep) != 0) {
864 FindMatchingEventsLocked(EK_SINGLE_STEP, basket, &match_list);
Elliott Hughes761928d2011-11-16 18:33:03 -0800865 }
Sebastien Hertz7d955652014-10-22 10:57:10 +0200866 if ((eventFlags & Dbg::kMethodEntry) != 0) {
867 FindMatchingEventsLocked(EK_METHOD_ENTRY, basket, &match_list);
Sebastien Hertz6995c602014-09-09 12:10:13 +0200868 }
Sebastien Hertz7d955652014-10-22 10:57:10 +0200869 if ((eventFlags & Dbg::kMethodExit) != 0) {
870 FindMatchingEventsLocked(EK_METHOD_EXIT, basket, &match_list);
871 FindMatchingEventsLocked(EK_METHOD_EXIT_WITH_RETURN_VALUE, basket, &match_list);
872 }
873 }
874 if (match_list.empty()) {
875 // No matching event.
876 return;
877 }
878 JdwpSuspendPolicy suspend_policy = ScanSuspendPolicy(match_list);
879
880 ObjectId thread_id = Dbg::GetThreadId(basket.thread);
881 JDWP::JdwpLocation jdwp_location;
882 SetJdwpLocationFromEventLocation(pLoc, &jdwp_location);
883
884 if (VLOG_IS_ON(jdwp)) {
885 LogMatchingEventsAndThread(match_list, thread_id);
886 VLOG(jdwp) << " location=" << jdwp_location;
887 VLOG(jdwp) << " suspend_policy=" << suspend_policy;
888 }
889
890 ExpandBuf* pReq = eventPrep();
891 expandBufAdd1(pReq, suspend_policy);
892 expandBufAdd4BE(pReq, match_list.size());
893
894 for (const JdwpEvent* pEvent : match_list) {
895 expandBufAdd1(pReq, pEvent->eventKind);
896 expandBufAdd4BE(pReq, pEvent->requestId);
897 expandBufAddObjectId(pReq, thread_id);
898 expandBufAddLocation(pReq, jdwp_location);
899 if (pEvent->eventKind == EK_METHOD_EXIT_WITH_RETURN_VALUE) {
900 Dbg::OutputMethodReturnValue(jdwp_location.method_id, returnValue, pReq);
901 }
902 }
903
904 {
905 MutexLock mu(Thread::Current(), event_list_lock_);
906 CleanupMatchList(match_list);
Elliott Hughes761928d2011-11-16 18:33:03 -0800907 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700908
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100909 Dbg::ManageDeoptimization();
910
Sebastien Hertz6995c602014-09-09 12:10:13 +0200911 SendRequestAndPossiblySuspend(pReq, suspend_policy, thread_id);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700912}
913
Sebastien Hertz7d955652014-10-22 10:57:10 +0200914void JdwpState::PostFieldEvent(const EventLocation* pLoc, mirror::ArtField* field,
Sebastien Hertz6995c602014-09-09 12:10:13 +0200915 mirror::Object* this_object, const JValue* fieldValue,
916 bool is_modification) {
917 DCHECK(pLoc != nullptr);
918 DCHECK(field != nullptr);
919 DCHECK_EQ(fieldValue != nullptr, is_modification);
920 DCHECK_EQ(field->IsStatic(), this_object == nullptr);
921
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200922 ModBasket basket;
923 basket.pLoc = pLoc;
Sebastien Hertz6995c602014-09-09 12:10:13 +0200924 basket.locationClass = pLoc->method->GetDeclaringClass();
925 basket.thisPtr = this_object;
926 basket.thread = Thread::Current();
927 basket.className = Dbg::GetClassName(basket.locationClass);
928 basket.field = field;
Sebastien Hertzbca0d3d2014-04-11 16:01:17 +0200929
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200930 if (InvokeInProgress()) {
931 VLOG(jdwp) << "Not posting field event during invoke";
Sebastien Hertz7d955652014-10-22 10:57:10 +0200932 return;
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200933 }
934
Sebastien Hertz7d955652014-10-22 10:57:10 +0200935 std::vector<JdwpEvent*> match_list;
936 const JdwpEventKind match_kind = (is_modification) ? EK_FIELD_MODIFICATION : EK_FIELD_ACCESS;
937 if (!FindMatchingEvents(match_kind, basket, &match_list)) {
938 // No matching event.
939 return;
940 }
941
942 JdwpSuspendPolicy suspend_policy = ScanSuspendPolicy(match_list);
943 ObjectId thread_id = Dbg::GetThreadId(basket.thread);
944 ObjectRegistry* registry = Dbg::GetObjectRegistry();
945 ObjectId instance_id = registry->Add(basket.thisPtr);
946 RefTypeId field_type_id = registry->AddRefType(field->GetDeclaringClass());
947 FieldId field_id = Dbg::ToFieldId(field);
948 JDWP::JdwpLocation jdwp_location;
949 SetJdwpLocationFromEventLocation(pLoc, &jdwp_location);
950
951 if (VLOG_IS_ON(jdwp)) {
952 LogMatchingEventsAndThread(match_list, thread_id);
953 VLOG(jdwp) << " location=" << jdwp_location;
954 VLOG(jdwp) << StringPrintf(" this=%#" PRIx64, instance_id);
955 VLOG(jdwp) << StringPrintf(" type=%#" PRIx64, field_type_id) << " "
956 << Dbg::GetClassName(field_id);
957 VLOG(jdwp) << StringPrintf(" field=%#" PRIx32, field_id) << " "
958 << Dbg::GetFieldName(field_id);
959 VLOG(jdwp) << " suspend_policy=" << suspend_policy;
960 }
961
962 ExpandBuf* pReq = eventPrep();
963 expandBufAdd1(pReq, suspend_policy);
964 expandBufAdd4BE(pReq, match_list.size());
965
966 // Get field's reference type tag.
967 JDWP::JdwpTypeTag type_tag = Dbg::GetTypeTag(field->GetDeclaringClass());
968
969 // Get instance type tag.
970 uint8_t tag;
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200971 {
Sebastien Hertz7d955652014-10-22 10:57:10 +0200972 ScopedObjectAccessUnchecked soa(Thread::Current());
973 tag = Dbg::TagFromObject(soa, basket.thisPtr);
974 }
975
976 for (const JdwpEvent* pEvent : match_list) {
977 expandBufAdd1(pReq, pEvent->eventKind);
978 expandBufAdd4BE(pReq, pEvent->requestId);
979 expandBufAddObjectId(pReq, thread_id);
980 expandBufAddLocation(pReq, jdwp_location);
981 expandBufAdd1(pReq, type_tag);
982 expandBufAddRefTypeId(pReq, field_type_id);
983 expandBufAddFieldId(pReq, field_id);
984 expandBufAdd1(pReq, tag);
985 expandBufAddObjectId(pReq, instance_id);
986 if (is_modification) {
987 Dbg::OutputFieldValue(field_id, fieldValue, pReq);
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200988 }
Sebastien Hertz7d955652014-10-22 10:57:10 +0200989 }
Sebastien Hertzbca0d3d2014-04-11 16:01:17 +0200990
Sebastien Hertz7d955652014-10-22 10:57:10 +0200991 {
992 MutexLock mu(Thread::Current(), event_list_lock_);
993 CleanupMatchList(match_list);
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200994 }
995
996 Dbg::ManageDeoptimization();
997
Sebastien Hertz6995c602014-09-09 12:10:13 +0200998 SendRequestAndPossiblySuspend(pReq, suspend_policy, thread_id);
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200999}
1000
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001001/*
1002 * A thread is starting or stopping.
1003 *
1004 * Valid mods:
1005 * Count, ThreadOnly
1006 */
Sebastien Hertz7d955652014-10-22 10:57:10 +02001007void JdwpState::PostThreadChange(Thread* thread, bool start) {
Sebastien Hertz6995c602014-09-09 12:10:13 +02001008 CHECK_EQ(thread, Thread::Current());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001009
1010 /*
1011 * I don't think this can happen.
1012 */
Elliott Hughes761928d2011-11-16 18:33:03 -08001013 if (InvokeInProgress()) {
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001014 LOG(WARNING) << "Not posting thread change during invoke";
Sebastien Hertz7d955652014-10-22 10:57:10 +02001015 return;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001016 }
1017
Sebastien Hertz107e7572014-12-18 11:13:15 +01001018 // We need the java.lang.Thread object associated to the starting/ending
1019 // thread to get its JDWP id. Therefore we can't report event if there
1020 // is no Java peer. This happens when the runtime shuts down and re-attaches
1021 // the current thread without creating a Java peer.
1022 if (thread->GetPeer() == nullptr) {
1023 return;
1024 }
1025
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001026 ModBasket basket;
Sebastien Hertz6995c602014-09-09 12:10:13 +02001027 basket.thread = thread;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001028
Sebastien Hertz7d955652014-10-22 10:57:10 +02001029 std::vector<JdwpEvent*> match_list;
1030 const JdwpEventKind match_kind = (start) ? EK_THREAD_START : EK_THREAD_DEATH;
1031 if (!FindMatchingEvents(match_kind, basket, &match_list)) {
1032 // No matching event.
1033 return;
1034 }
1035
1036 JdwpSuspendPolicy suspend_policy = ScanSuspendPolicy(match_list);
1037 ObjectId thread_id = Dbg::GetThreadId(basket.thread);
1038
1039 if (VLOG_IS_ON(jdwp)) {
1040 LogMatchingEventsAndThread(match_list, thread_id);
1041 VLOG(jdwp) << " suspend_policy=" << suspend_policy;
1042 }
1043
1044 ExpandBuf* pReq = eventPrep();
1045 expandBufAdd1(pReq, suspend_policy);
1046 expandBufAdd4BE(pReq, match_list.size());
1047
1048 for (const JdwpEvent* pEvent : match_list) {
1049 expandBufAdd1(pReq, pEvent->eventKind);
1050 expandBufAdd4BE(pReq, pEvent->requestId);
1051 expandBufAdd8BE(pReq, thread_id);
1052 }
1053
Elliott Hughes234ab152011-10-26 14:02:26 -07001054 {
Sebastien Hertz7d955652014-10-22 10:57:10 +02001055 MutexLock mu(Thread::Current(), event_list_lock_);
1056 CleanupMatchList(match_list);
Elliott Hughes234ab152011-10-26 14:02:26 -07001057 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001058
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01001059 Dbg::ManageDeoptimization();
1060
Sebastien Hertz6995c602014-09-09 12:10:13 +02001061 SendRequestAndPossiblySuspend(pReq, suspend_policy, thread_id);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001062}
1063
1064/*
1065 * Send a polite "VM is dying" message to the debugger.
1066 *
1067 * Skips the usual "event token" stuff.
1068 */
Elliott Hughes376a7a02011-10-24 18:35:55 -07001069bool JdwpState::PostVMDeath() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001070 VLOG(jdwp) << "EVENT: " << EK_VM_DEATH;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001071
1072 ExpandBuf* pReq = eventPrep();
1073 expandBufAdd1(pReq, SP_NONE);
1074 expandBufAdd4BE(pReq, 1);
1075
1076 expandBufAdd1(pReq, EK_VM_DEATH);
1077 expandBufAdd4BE(pReq, 0);
Elliott Hughes761928d2011-11-16 18:33:03 -08001078 EventFinish(pReq);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001079 return true;
1080}
1081
1082/*
1083 * An exception has been thrown. It may or may not have been caught.
1084 *
1085 * Valid mods:
1086 * Count, ThreadOnly, ClassOnly, ClassMatch, ClassExclude, LocationOnly,
1087 * ExceptionOnly, InstanceOnly
1088 *
1089 * The "exceptionId" has not been added to the GC-visible object registry,
1090 * because there's a pretty good chance that we're not going to send it
1091 * up the debugger.
1092 */
Sebastien Hertz7d955652014-10-22 10:57:10 +02001093void JdwpState::PostException(const EventLocation* pThrowLoc, mirror::Throwable* exception_object,
Sebastien Hertz6995c602014-09-09 12:10:13 +02001094 const EventLocation* pCatchLoc, mirror::Object* thisPtr) {
1095 DCHECK(exception_object != nullptr);
1096 DCHECK(pThrowLoc != nullptr);
1097 DCHECK(pCatchLoc != nullptr);
Sebastien Hertza9aa0ff2014-09-19 12:07:51 +02001098 if (pThrowLoc->method != nullptr) {
1099 DCHECK_EQ(pThrowLoc->method->IsStatic(), thisPtr == nullptr);
1100 } else {
1101 VLOG(jdwp) << "Unexpected: exception event with empty throw location";
1102 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001103
Sebastien Hertz6995c602014-09-09 12:10:13 +02001104 ModBasket basket;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001105 basket.pLoc = pThrowLoc;
Sebastien Hertza9aa0ff2014-09-19 12:07:51 +02001106 if (pThrowLoc->method != nullptr) {
1107 basket.locationClass = pThrowLoc->method->GetDeclaringClass();
1108 } else {
1109 basket.locationClass = nullptr;
1110 }
Sebastien Hertz6995c602014-09-09 12:10:13 +02001111 basket.thread = Thread::Current();
1112 basket.className = Dbg::GetClassName(basket.locationClass);
1113 basket.exceptionClass = exception_object->GetClass();
1114 basket.caught = (pCatchLoc->method != 0);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001115 basket.thisPtr = thisPtr;
1116
1117 /* don't try to post an exception caused by the debugger */
Elliott Hughes761928d2011-11-16 18:33:03 -08001118 if (InvokeInProgress()) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001119 VLOG(jdwp) << "Not posting exception hit during invoke (" << basket.className << ")";
Sebastien Hertz7d955652014-10-22 10:57:10 +02001120 return;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001121 }
1122
Sebastien Hertz7d955652014-10-22 10:57:10 +02001123 std::vector<JdwpEvent*> match_list;
1124 if (!FindMatchingEvents(EK_EXCEPTION, basket, &match_list)) {
1125 // No matching event.
1126 return;
1127 }
1128
1129 JdwpSuspendPolicy suspend_policy = ScanSuspendPolicy(match_list);
1130 ObjectId thread_id = Dbg::GetThreadId(basket.thread);
1131 ObjectRegistry* registry = Dbg::GetObjectRegistry();
1132 ObjectId exceptionId = registry->Add(exception_object);
1133 JDWP::JdwpLocation jdwp_throw_location;
1134 JDWP::JdwpLocation jdwp_catch_location;
1135 SetJdwpLocationFromEventLocation(pThrowLoc, &jdwp_throw_location);
1136 SetJdwpLocationFromEventLocation(pCatchLoc, &jdwp_catch_location);
1137
1138 if (VLOG_IS_ON(jdwp)) {
1139 std::string exceptionClassName(PrettyDescriptor(exception_object->GetClass()));
1140
1141 LogMatchingEventsAndThread(match_list, thread_id);
1142 VLOG(jdwp) << " throwLocation=" << jdwp_throw_location;
1143 if (jdwp_catch_location.class_id == 0) {
1144 VLOG(jdwp) << " catchLocation=uncaught";
1145 } else {
1146 VLOG(jdwp) << " catchLocation=" << jdwp_catch_location;
1147 }
1148 VLOG(jdwp) << StringPrintf(" exception=%#" PRIx64, exceptionId) << " "
1149 << exceptionClassName;
1150 VLOG(jdwp) << " suspend_policy=" << suspend_policy;
1151 }
1152
1153 ExpandBuf* pReq = eventPrep();
1154 expandBufAdd1(pReq, suspend_policy);
1155 expandBufAdd4BE(pReq, match_list.size());
1156
1157 for (const JdwpEvent* pEvent : match_list) {
1158 expandBufAdd1(pReq, pEvent->eventKind);
1159 expandBufAdd4BE(pReq, pEvent->requestId);
1160 expandBufAddObjectId(pReq, thread_id);
1161 expandBufAddLocation(pReq, jdwp_throw_location);
1162 expandBufAdd1(pReq, JT_OBJECT);
1163 expandBufAddObjectId(pReq, exceptionId);
1164 expandBufAddLocation(pReq, jdwp_catch_location);
1165 }
1166
Elliott Hughes761928d2011-11-16 18:33:03 -08001167 {
Sebastien Hertz7d955652014-10-22 10:57:10 +02001168 MutexLock mu(Thread::Current(), event_list_lock_);
1169 CleanupMatchList(match_list);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001170 }
1171
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01001172 Dbg::ManageDeoptimization();
1173
Sebastien Hertz6995c602014-09-09 12:10:13 +02001174 SendRequestAndPossiblySuspend(pReq, suspend_policy, thread_id);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001175}
1176
1177/*
1178 * Announce that a class has been loaded.
1179 *
1180 * Valid mods:
1181 * Count, ThreadOnly, ClassOnly, ClassMatch, ClassExclude
1182 */
Sebastien Hertz7d955652014-10-22 10:57:10 +02001183void JdwpState::PostClassPrepare(mirror::Class* klass) {
Sebastien Hertz6995c602014-09-09 12:10:13 +02001184 DCHECK(klass != nullptr);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001185
Sebastien Hertz6995c602014-09-09 12:10:13 +02001186 ModBasket basket;
1187 basket.locationClass = klass;
1188 basket.thread = Thread::Current();
1189 basket.className = Dbg::GetClassName(basket.locationClass);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001190
1191 /* suppress class prep caused by debugger */
Elliott Hughes761928d2011-11-16 18:33:03 -08001192 if (InvokeInProgress()) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001193 VLOG(jdwp) << "Not posting class prep caused by invoke (" << basket.className << ")";
Sebastien Hertz7d955652014-10-22 10:57:10 +02001194 return;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001195 }
1196
Sebastien Hertz7d955652014-10-22 10:57:10 +02001197 std::vector<JdwpEvent*> match_list;
1198 if (!FindMatchingEvents(EK_CLASS_PREPARE, basket, &match_list)) {
1199 // No matching event.
1200 return;
1201 }
1202
1203 JdwpSuspendPolicy suspend_policy = ScanSuspendPolicy(match_list);
1204 ObjectId thread_id = Dbg::GetThreadId(basket.thread);
1205 ObjectRegistry* registry = Dbg::GetObjectRegistry();
1206 RefTypeId class_id = registry->AddRefType(basket.locationClass);
1207
1208 // OLD-TODO - we currently always send both "verified" and "prepared" since
1209 // debuggers seem to like that. There might be some advantage to honesty,
1210 // since the class may not yet be verified.
1211 int status = JDWP::CS_VERIFIED | JDWP::CS_PREPARED;
1212 JDWP::JdwpTypeTag tag = Dbg::GetTypeTag(basket.locationClass);
1213 std::string temp;
1214 std::string signature(basket.locationClass->GetDescriptor(&temp));
1215
1216 if (VLOG_IS_ON(jdwp)) {
1217 LogMatchingEventsAndThread(match_list, thread_id);
1218 VLOG(jdwp) << StringPrintf(" type=%#" PRIx64, class_id) << " " << signature;
1219 VLOG(jdwp) << " suspend_policy=" << suspend_policy;
1220 }
1221
1222 if (thread_id == debug_thread_id_) {
1223 /*
1224 * JDWP says that, for a class prep in the debugger thread, we
1225 * should set thread to null and if any threads were supposed
1226 * to be suspended then we suspend all other threads.
1227 */
1228 VLOG(jdwp) << " NOTE: class prepare in debugger thread!";
1229 thread_id = 0;
1230 if (suspend_policy == SP_EVENT_THREAD) {
1231 suspend_policy = SP_ALL;
1232 }
1233 }
1234
1235 ExpandBuf* pReq = eventPrep();
1236 expandBufAdd1(pReq, suspend_policy);
1237 expandBufAdd4BE(pReq, match_list.size());
1238
1239 for (const JdwpEvent* pEvent : match_list) {
1240 expandBufAdd1(pReq, pEvent->eventKind);
1241 expandBufAdd4BE(pReq, pEvent->requestId);
1242 expandBufAddObjectId(pReq, thread_id);
1243 expandBufAdd1(pReq, tag);
1244 expandBufAddRefTypeId(pReq, class_id);
1245 expandBufAddUtf8String(pReq, signature);
1246 expandBufAdd4BE(pReq, status);
1247 }
1248
Elliott Hughes761928d2011-11-16 18:33:03 -08001249 {
Sebastien Hertz7d955652014-10-22 10:57:10 +02001250 MutexLock mu(Thread::Current(), event_list_lock_);
1251 CleanupMatchList(match_list);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001252 }
1253
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01001254 Dbg::ManageDeoptimization();
1255
Sebastien Hertz6995c602014-09-09 12:10:13 +02001256 SendRequestAndPossiblySuspend(pReq, suspend_policy, thread_id);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001257}
1258
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001259/*
Mathieu Chartierad466ad2015-01-08 16:28:08 -08001260 * Setup the header for a chunk of DDM data.
1261 */
1262void JdwpState::SetupChunkHeader(uint32_t type, size_t data_len, size_t header_size,
1263 uint8_t* out_header) {
1264 CHECK_EQ(header_size, static_cast<size_t>(kJDWPHeaderLen + 8));
1265 /* form the header (JDWP plus DDMS) */
1266 Set4BE(out_header, header_size + data_len);
1267 Set4BE(out_header + 4, NextRequestSerial());
1268 Set1(out_header + 8, 0); /* flags */
1269 Set1(out_header + 9, kJDWPDdmCmdSet);
1270 Set1(out_header + 10, kJDWPDdmCmd);
1271 Set4BE(out_header + 11, type);
1272 Set4BE(out_header + 15, data_len);
1273}
1274
1275/*
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001276 * Send up a chunk of DDM data.
1277 *
1278 * While this takes the form of a JDWP "event", it doesn't interact with
1279 * other debugger traffic, and can't suspend the VM, so we skip all of
1280 * the fun event token gymnastics.
1281 */
Elliott Hughescccd84f2011-12-05 16:51:54 -08001282void JdwpState::DdmSendChunkV(uint32_t type, const iovec* iov, int iov_count) {
Mathieu Chartierad466ad2015-01-08 16:28:08 -08001283 uint8_t header[kJDWPHeaderLen + 8] = { 0 };
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001284 size_t dataLen = 0;
1285
Sebastien Hertz7d955652014-10-22 10:57:10 +02001286 CHECK(iov != nullptr);
Elliott Hughescccd84f2011-12-05 16:51:54 -08001287 CHECK_GT(iov_count, 0);
1288 CHECK_LT(iov_count, 10);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001289
1290 /*
1291 * "Wrap" the contents of the iovec with a JDWP/DDMS header. We do
1292 * this by creating a new copy of the vector with space for the header.
1293 */
Brian Carlstromf5293522013-07-19 00:24:00 -07001294 std::vector<iovec> wrapiov;
1295 wrapiov.push_back(iovec());
Elliott Hughescccd84f2011-12-05 16:51:54 -08001296 for (int i = 0; i < iov_count; i++) {
Brian Carlstromf5293522013-07-19 00:24:00 -07001297 wrapiov.push_back(iov[i]);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001298 dataLen += iov[i].iov_len;
1299 }
1300
Mathieu Chartierad466ad2015-01-08 16:28:08 -08001301 SetupChunkHeader(type, dataLen, sizeof(header), header);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001302
1303 wrapiov[0].iov_base = header;
1304 wrapiov[0].iov_len = sizeof(header);
1305
Ian Rogers15bf2d32012-08-28 17:33:04 -07001306 // Try to avoid blocking GC during a send, but only safe when not using mutexes at a lower-level
1307 // than mutator for lock ordering reasons.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001308 Thread* self = Thread::Current();
Ian Rogers62d6c772013-02-27 08:32:07 -08001309 bool safe_to_release_mutator_lock_over_send = !Locks::mutator_lock_->IsExclusiveHeld(self);
1310 if (safe_to_release_mutator_lock_over_send) {
Brian Carlstrom38f85e42013-07-18 14:45:22 -07001311 for (size_t i = 0; i < kMutatorLock; ++i) {
Sebastien Hertz7d955652014-10-22 10:57:10 +02001312 if (self->GetHeldMutex(static_cast<LockLevel>(i)) != nullptr) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001313 safe_to_release_mutator_lock_over_send = false;
1314 break;
1315 }
Ian Rogers15bf2d32012-08-28 17:33:04 -07001316 }
1317 }
1318 if (safe_to_release_mutator_lock_over_send) {
1319 // Change state to waiting to allow GC, ... while we're sending.
1320 self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSend);
Brian Carlstromf5293522013-07-19 00:24:00 -07001321 SendBufferedRequest(type, wrapiov);
Ian Rogers15bf2d32012-08-28 17:33:04 -07001322 self->TransitionFromSuspendedToRunnable();
1323 } else {
1324 // Send and possibly block GC...
Brian Carlstromf5293522013-07-19 00:24:00 -07001325 SendBufferedRequest(type, wrapiov);
Ian Rogers15bf2d32012-08-28 17:33:04 -07001326 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001327}
1328
1329} // namespace JDWP
1330
1331} // namespace art