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 "jdwp/jdwp_event.h"
18
19 #include <stddef.h> /* for offsetof() */
20 #include <stdlib.h>
21 #include <string.h>
22 #include <unistd.h>
23
24 #include "base/logging.h"
25 #include "base/stringprintf.h"
26 #include "debugger.h"
27 #include "jdwp/jdwp_constants.h"
28 #include "jdwp/jdwp_expand_buf.h"
29 #include "jdwp/jdwp_priv.h"
30 #include "thread-inl.h"
31
32 /*
33 General notes:
34
35 The event add/remove stuff usually happens from the debugger thread,
36 in response to requests from the debugger, but can also happen as the
37 result of an event in an arbitrary thread (e.g. an event with a "count"
38 mod expires). It's important to keep the event list locked when processing
39 events.
40
41 Event posting can happen from any thread. The JDWP thread will not usually
42 post anything but VM start/death, but if a JDWP request causes a class
43 to be loaded, the ClassPrepare event will come from the JDWP thread.
44
45
46 We can have serialization issues when we post an event to the debugger.
47 For example, a thread could send an "I hit a breakpoint and am suspending
48 myself" message to the debugger. Before it manages to suspend itself, the
49 debugger's response ("not interested, resume thread") arrives and is
50 processed. We try to resume a thread that hasn't yet suspended.
51
52 This means that, after posting an event to the debugger, we need to wait
53 for the event thread to suspend itself (and, potentially, all other threads)
54 before processing any additional requests from the debugger. While doing
55 so we need to be aware that multiple threads may be hitting breakpoints
56 or other events simultaneously, so we either need to wait for all of them
57 or serialize the events with each other.
58
59 The current mechanism works like this:
60 Event thread:
61 - If I'm going to suspend, grab the "I am posting an event" token. Wait
62 for it if it's not currently available.
63 - Post the event to the debugger.
64 - If appropriate, suspend others and then myself. As part of suspending
65 myself, release the "I am posting" token.
66 JDWP thread:
67 - When an event arrives, see if somebody is posting an event. If so,
68 sleep until we can acquire the "I am posting an event" token. Release
69 it immediately and continue processing -- the event we have already
70 received should not interfere with other events that haven't yet
71 been posted.
72
73 Some care must be taken to avoid deadlock:
74
75 - thread A and thread B exit near-simultaneously, and post thread-death
76 events with a "suspend all" clause
77 - thread A gets the event token, thread B sits and waits for it
78 - thread A wants to suspend all other threads, but thread B is waiting
79 for the token and can't be suspended
80
81 So we need to mark thread B in such a way that thread A doesn't wait for it.
82
83 If we just bracket the "grab event token" call with a change to VMWAIT
84 before sleeping, the switch back to RUNNING state when we get the token
85 will cause thread B to suspend (remember, thread A's global suspend is
86 still in force, even after it releases the token). Suspending while
87 holding the event token is very bad, because it prevents the JDWP thread
88 from processing incoming messages.
89
90 We need to change to VMWAIT state at the *start* of posting an event,
91 and stay there until we either finish posting the event or decide to
92 put ourselves to sleep. That way we don't interfere with anyone else and
93 don't allow anyone else to interfere with us.
94 */
95
96
97 #define kJdwpEventCommandSet 64
98 #define kJdwpCompositeCommand 100
99
100 namespace art {
101
102 namespace JDWP {
103
104 /*
105 * Stuff to compare against when deciding if a mod matches. Only the
106 * values for mods valid for the event being evaluated will be filled in.
107 * The rest will be zeroed.
108 */
109 struct ModBasket {
ModBasketart::JDWP::ModBasket110 ModBasket() : pLoc(NULL), threadId(0), classId(0), excepClassId(0),
111 caught(false), field(0), thisPtr(0) { }
112
113 const JdwpLocation* pLoc; /* LocationOnly */
114 std::string className; /* ClassMatch/ClassExclude */
115 ObjectId threadId; /* ThreadOnly */
116 RefTypeId classId; /* ClassOnly */
117 RefTypeId excepClassId; /* ExceptionOnly */
118 bool caught; /* ExceptionOnly */
119 FieldId field; /* FieldOnly */
120 ObjectId thisPtr; /* InstanceOnly */
121 /* nothing for StepOnly -- handled differently */
122 };
123
124 /*
125 * Dump an event to the log file.
126 */
dumpEvent(const JdwpEvent * pEvent)127 static void dumpEvent(const JdwpEvent* pEvent) {
128 LOG(INFO) << StringPrintf("Event id=0x%4x %p (prev=%p next=%p):", pEvent->requestId, pEvent, pEvent->prev, pEvent->next);
129 LOG(INFO) << " kind=" << pEvent->eventKind << " susp=" << pEvent->suspend_policy << " modCount=" << pEvent->modCount;
130
131 for (int i = 0; i < pEvent->modCount; i++) {
132 const JdwpEventMod* pMod = &pEvent->mods[i];
133 LOG(INFO) << " " << pMod->modKind;
134 /* TODO - show details */
135 }
136 }
137
138 /*
139 * Add an event to the list. Ordering is not important.
140 *
141 * If something prevents the event from being registered, e.g. it's a
142 * single-step request on a thread that doesn't exist, the event will
143 * not be added to the list, and an appropriate error will be returned.
144 */
RegisterEvent(JdwpEvent * pEvent)145 JdwpError JdwpState::RegisterEvent(JdwpEvent* pEvent) {
146 CHECK(pEvent != NULL);
147 CHECK(pEvent->prev == NULL);
148 CHECK(pEvent->next == NULL);
149
150 /*
151 * If one or more "break"-type mods are used, register them with
152 * the interpreter.
153 */
154 for (int i = 0; i < pEvent->modCount; i++) {
155 const JdwpEventMod* pMod = &pEvent->mods[i];
156 if (pMod->modKind == MK_LOCATION_ONLY) {
157 /* should only be for Breakpoint, Step, and Exception */
158 Dbg::WatchLocation(&pMod->locationOnly.loc);
159 } else if (pMod->modKind == MK_STEP) {
160 /* should only be for EK_SINGLE_STEP; should only be one */
161 JdwpStepSize size = static_cast<JdwpStepSize>(pMod->step.size);
162 JdwpStepDepth depth = static_cast<JdwpStepDepth>(pMod->step.depth);
163 JdwpError status = Dbg::ConfigureStep(pMod->step.threadId, size, depth);
164 if (status != ERR_NONE) {
165 return status;
166 }
167 } else if (pMod->modKind == MK_FIELD_ONLY) {
168 /* should be for EK_FIELD_ACCESS or EK_FIELD_MODIFICATION */
169 dumpEvent(pEvent); /* TODO - need for field watches */
170 }
171 }
172
173 /*
174 * Add to list.
175 */
176 MutexLock mu(Thread::Current(), event_list_lock_);
177 if (event_list_ != NULL) {
178 pEvent->next = event_list_;
179 event_list_->prev = pEvent;
180 }
181 event_list_ = pEvent;
182 ++event_list_size_;
183
184 return ERR_NONE;
185 }
186
187 /*
188 * Remove an event from the list. This will also remove the event from
189 * any optimization tables, e.g. breakpoints.
190 *
191 * Does not free the JdwpEvent.
192 *
193 * Grab the eventLock before calling here.
194 */
UnregisterEvent(JdwpEvent * pEvent)195 void JdwpState::UnregisterEvent(JdwpEvent* pEvent) {
196 if (pEvent->prev == NULL) {
197 /* head of the list */
198 CHECK(event_list_ == pEvent);
199
200 event_list_ = pEvent->next;
201 } else {
202 pEvent->prev->next = pEvent->next;
203 }
204
205 if (pEvent->next != NULL) {
206 pEvent->next->prev = pEvent->prev;
207 pEvent->next = NULL;
208 }
209 pEvent->prev = NULL;
210
211 /*
212 * Unhook us from the interpreter, if necessary.
213 */
214 for (int i = 0; i < pEvent->modCount; i++) {
215 JdwpEventMod* pMod = &pEvent->mods[i];
216 if (pMod->modKind == MK_LOCATION_ONLY) {
217 /* should only be for Breakpoint, Step, and Exception */
218 Dbg::UnwatchLocation(&pMod->locationOnly.loc);
219 }
220 if (pMod->modKind == MK_STEP) {
221 /* should only be for EK_SINGLE_STEP; should only be one */
222 Dbg::UnconfigureStep(pMod->step.threadId);
223 }
224 }
225
226 --event_list_size_;
227 CHECK(event_list_size_ != 0 || event_list_ == NULL);
228 }
229
230 /*
231 * Remove the event with the given ID from the list.
232 *
233 * Failure to find the event isn't really an error, but it is a little
234 * weird. (It looks like Eclipse will try to be extra careful and will
235 * explicitly remove one-off single-step events.)
236 */
UnregisterEventById(uint32_t requestId)237 void JdwpState::UnregisterEventById(uint32_t requestId) {
238 MutexLock mu(Thread::Current(), event_list_lock_);
239
240 JdwpEvent* pEvent = event_list_;
241 while (pEvent != NULL) {
242 if (pEvent->requestId == requestId) {
243 UnregisterEvent(pEvent);
244 EventFree(pEvent);
245 return; /* there can be only one with a given ID */
246 }
247
248 pEvent = pEvent->next;
249 }
250
251 // ALOGD("Odd: no match when removing event reqId=0x%04x", requestId);
252 }
253
254 /*
255 * Remove all entries from the event list.
256 */
UnregisterAll()257 void JdwpState::UnregisterAll() {
258 MutexLock mu(Thread::Current(), event_list_lock_);
259
260 JdwpEvent* pEvent = event_list_;
261 while (pEvent != NULL) {
262 JdwpEvent* pNextEvent = pEvent->next;
263
264 UnregisterEvent(pEvent);
265 EventFree(pEvent);
266 pEvent = pNextEvent;
267 }
268
269 event_list_ = NULL;
270 }
271
272 /*
273 * Allocate a JdwpEvent struct with enough space to hold the specified
274 * number of mod records.
275 */
EventAlloc(int numMods)276 JdwpEvent* EventAlloc(int numMods) {
277 JdwpEvent* newEvent;
278 int allocSize = offsetof(JdwpEvent, mods) + numMods * sizeof(newEvent->mods[0]);
279 newEvent = reinterpret_cast<JdwpEvent*>(malloc(allocSize));
280 memset(newEvent, 0, allocSize);
281 return newEvent;
282 }
283
284 /*
285 * Free a JdwpEvent.
286 *
287 * Do not call this until the event has been removed from the list.
288 */
EventFree(JdwpEvent * pEvent)289 void EventFree(JdwpEvent* pEvent) {
290 if (pEvent == NULL) {
291 return;
292 }
293
294 /* make sure it was removed from the list */
295 CHECK(pEvent->prev == NULL);
296 CHECK(pEvent->next == NULL);
297 /* want to check state->event_list_ != pEvent */
298
299 /*
300 * Free any hairy bits in the mods.
301 */
302 for (int i = 0; i < pEvent->modCount; i++) {
303 if (pEvent->mods[i].modKind == MK_CLASS_MATCH) {
304 free(pEvent->mods[i].classMatch.classPattern);
305 pEvent->mods[i].classMatch.classPattern = NULL;
306 }
307 if (pEvent->mods[i].modKind == MK_CLASS_EXCLUDE) {
308 free(pEvent->mods[i].classExclude.classPattern);
309 pEvent->mods[i].classExclude.classPattern = NULL;
310 }
311 }
312
313 free(pEvent);
314 }
315
316 /*
317 * Allocate storage for matching events. To keep things simple we
318 * use an array with enough storage for the entire list.
319 *
320 * The state->eventLock should be held before calling.
321 */
AllocMatchList(size_t event_count)322 static JdwpEvent** AllocMatchList(size_t event_count) {
323 return new JdwpEvent*[event_count];
324 }
325
326 /*
327 * Run through the list and remove any entries with an expired "count" mod
328 * from the event list, then free the match list.
329 */
CleanupMatchList(JdwpEvent ** match_list,int match_count)330 void JdwpState::CleanupMatchList(JdwpEvent** match_list, int match_count) {
331 JdwpEvent** ppEvent = match_list;
332
333 while (match_count--) {
334 JdwpEvent* pEvent = *ppEvent;
335
336 for (int i = 0; i < pEvent->modCount; i++) {
337 if (pEvent->mods[i].modKind == MK_COUNT && pEvent->mods[i].count.count == 0) {
338 VLOG(jdwp) << "##### Removing expired event";
339 UnregisterEvent(pEvent);
340 EventFree(pEvent);
341 break;
342 }
343 }
344
345 ppEvent++;
346 }
347
348 delete[] match_list;
349 }
350
351 /*
352 * Match a string against a "restricted regular expression", which is just
353 * a string that may start or end with '*' (e.g. "*.Foo" or "java.*").
354 *
355 * ("Restricted name globbing" might have been a better term.)
356 */
PatternMatch(const char * pattern,const std::string & target)357 static bool PatternMatch(const char* pattern, const std::string& target) {
358 size_t patLen = strlen(pattern);
359 if (pattern[0] == '*') {
360 patLen--;
361 if (target.size() < patLen) {
362 return false;
363 }
364 return strcmp(pattern+1, target.c_str() + (target.size()-patLen)) == 0;
365 } else if (pattern[patLen-1] == '*') {
366 return strncmp(pattern, target.c_str(), patLen-1) == 0;
367 } else {
368 return strcmp(pattern, target.c_str()) == 0;
369 }
370 }
371
372 /*
373 * See if the event's mods match up with the contents of "basket".
374 *
375 * If we find a Count mod before rejecting an event, we decrement it. We
376 * need to do this even if later mods cause us to ignore the event.
377 */
ModsMatch(JdwpEvent * pEvent,ModBasket * basket)378 static bool ModsMatch(JdwpEvent* pEvent, ModBasket* basket)
379 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
380 JdwpEventMod* pMod = pEvent->mods;
381
382 for (int i = pEvent->modCount; i > 0; i--, pMod++) {
383 switch (pMod->modKind) {
384 case MK_COUNT:
385 CHECK_GT(pMod->count.count, 0);
386 pMod->count.count--;
387 break;
388 case MK_CONDITIONAL:
389 CHECK(false); // should not be getting these
390 break;
391 case MK_THREAD_ONLY:
392 if (pMod->threadOnly.threadId != basket->threadId) {
393 return false;
394 }
395 break;
396 case MK_CLASS_ONLY:
397 if (!Dbg::MatchType(basket->classId, pMod->classOnly.refTypeId)) {
398 return false;
399 }
400 break;
401 case MK_CLASS_MATCH:
402 if (!PatternMatch(pMod->classMatch.classPattern, basket->className)) {
403 return false;
404 }
405 break;
406 case MK_CLASS_EXCLUDE:
407 if (PatternMatch(pMod->classMatch.classPattern, basket->className)) {
408 return false;
409 }
410 break;
411 case MK_LOCATION_ONLY:
412 if (pMod->locationOnly.loc != *basket->pLoc) {
413 return false;
414 }
415 break;
416 case MK_EXCEPTION_ONLY:
417 if (pMod->exceptionOnly.refTypeId != 0 && !Dbg::MatchType(basket->excepClassId, pMod->exceptionOnly.refTypeId)) {
418 return false;
419 }
420 if ((basket->caught && !pMod->exceptionOnly.caught) || (!basket->caught && !pMod->exceptionOnly.uncaught)) {
421 return false;
422 }
423 break;
424 case MK_FIELD_ONLY:
425 if (!Dbg::MatchType(basket->classId, pMod->fieldOnly.refTypeId) || pMod->fieldOnly.fieldId != basket->field) {
426 return false;
427 }
428 break;
429 case MK_STEP:
430 if (pMod->step.threadId != basket->threadId) {
431 return false;
432 }
433 break;
434 case MK_INSTANCE_ONLY:
435 if (pMod->instanceOnly.objectId != basket->thisPtr) {
436 return false;
437 }
438 break;
439 default:
440 LOG(FATAL) << "unknown mod kind " << pMod->modKind;
441 break;
442 }
443 }
444 return true;
445 }
446
447 /*
448 * Find all events of type "eventKind" with mods that match up with the
449 * rest of the arguments.
450 *
451 * Found events are appended to "match_list", and "*pMatchCount" is advanced,
452 * so this may be called multiple times for grouped events.
453 *
454 * DO NOT call this multiple times for the same eventKind, as Count mods are
455 * decremented during the scan.
456 */
FindMatchingEvents(JdwpEventKind eventKind,ModBasket * basket,JdwpEvent ** match_list,int * pMatchCount)457 void JdwpState::FindMatchingEvents(JdwpEventKind eventKind, ModBasket* basket,
458 JdwpEvent** match_list, int* pMatchCount) {
459 /* start after the existing entries */
460 match_list += *pMatchCount;
461
462 JdwpEvent* pEvent = event_list_;
463 while (pEvent != NULL) {
464 if (pEvent->eventKind == eventKind && ModsMatch(pEvent, basket)) {
465 *match_list++ = pEvent;
466 (*pMatchCount)++;
467 }
468
469 pEvent = pEvent->next;
470 }
471 }
472
473 /*
474 * Scan through the list of matches and determine the most severe
475 * suspension policy.
476 */
scanSuspendPolicy(JdwpEvent ** match_list,int match_count)477 static JdwpSuspendPolicy scanSuspendPolicy(JdwpEvent** match_list, int match_count) {
478 JdwpSuspendPolicy policy = SP_NONE;
479
480 while (match_count--) {
481 if ((*match_list)->suspend_policy > policy) {
482 policy = (*match_list)->suspend_policy;
483 }
484 match_list++;
485 }
486
487 return policy;
488 }
489
490 /*
491 * Three possibilities:
492 * SP_NONE - do nothing
493 * SP_EVENT_THREAD - suspend ourselves
494 * SP_ALL - suspend everybody except JDWP support thread
495 */
SuspendByPolicy(JdwpSuspendPolicy suspend_policy,JDWP::ObjectId thread_self_id)496 void JdwpState::SuspendByPolicy(JdwpSuspendPolicy suspend_policy, JDWP::ObjectId thread_self_id) {
497 VLOG(jdwp) << "SuspendByPolicy(" << suspend_policy << ")";
498 if (suspend_policy == SP_NONE) {
499 return;
500 }
501
502 if (suspend_policy == SP_ALL) {
503 Dbg::SuspendVM();
504 } else {
505 CHECK_EQ(suspend_policy, SP_EVENT_THREAD);
506 }
507
508 /* this is rare but possible -- see CLASS_PREPARE handling */
509 if (thread_self_id == debug_thread_id_) {
510 LOG(INFO) << "NOTE: SuspendByPolicy not suspending JDWP thread";
511 return;
512 }
513
514 DebugInvokeReq* pReq = Dbg::GetInvokeReq();
515 while (true) {
516 pReq->ready = true;
517 Dbg::SuspendSelf();
518 pReq->ready = false;
519
520 /*
521 * The JDWP thread has told us (and possibly all other threads) to
522 * resume. See if it has left anything in our DebugInvokeReq mailbox.
523 */
524 if (!pReq->invoke_needed_) {
525 /*LOGD("SuspendByPolicy: no invoke needed");*/
526 break;
527 }
528
529 /* grab this before posting/suspending again */
530 SetWaitForEventThread(thread_self_id);
531
532 /* leave pReq->invoke_needed_ raised so we can check reentrancy */
533 Dbg::ExecuteMethod(pReq);
534
535 pReq->error = ERR_NONE;
536
537 /* clear this before signaling */
538 pReq->invoke_needed_ = false;
539
540 VLOG(jdwp) << "invoke complete, signaling and self-suspending";
541 Thread* self = Thread::Current();
542 MutexLock mu(self, pReq->lock_);
543 pReq->cond_.Signal(self);
544 }
545 }
546
SendRequestAndPossiblySuspend(ExpandBuf * pReq,JdwpSuspendPolicy suspend_policy,ObjectId threadId)547 void JdwpState::SendRequestAndPossiblySuspend(ExpandBuf* pReq, JdwpSuspendPolicy suspend_policy,
548 ObjectId threadId) {
549 Thread* self = Thread::Current();
550 self->AssertThreadSuspensionIsAllowable();
551 /* send request and possibly suspend ourselves */
552 if (pReq != NULL) {
553 JDWP::ObjectId thread_self_id = Dbg::GetThreadSelfId();
554 self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSend);
555 if (suspend_policy != SP_NONE) {
556 SetWaitForEventThread(threadId);
557 }
558 EventFinish(pReq);
559 SuspendByPolicy(suspend_policy, thread_self_id);
560 self->TransitionFromSuspendedToRunnable();
561 }
562 }
563
564 /*
565 * Determine if there is a method invocation in progress in the current
566 * thread.
567 *
568 * We look at the "invoke_needed" flag in the per-thread DebugInvokeReq
569 * state. If set, we're in the process of invoking a method.
570 */
InvokeInProgress()571 bool JdwpState::InvokeInProgress() {
572 DebugInvokeReq* pReq = Dbg::GetInvokeReq();
573 return pReq->invoke_needed_;
574 }
575
576 /*
577 * We need the JDWP thread to hold off on doing stuff while we post an
578 * event and then suspend ourselves.
579 *
580 * Call this with a threadId of zero if you just want to wait for the
581 * current thread operation to complete.
582 *
583 * This could go to sleep waiting for another thread, so it's important
584 * that the thread be marked as VMWAIT before calling here.
585 */
SetWaitForEventThread(ObjectId threadId)586 void JdwpState::SetWaitForEventThread(ObjectId threadId) {
587 bool waited = false;
588
589 /* this is held for very brief periods; contention is unlikely */
590 Thread* self = Thread::Current();
591 MutexLock mu(self, event_thread_lock_);
592
593 /*
594 * If another thread is already doing stuff, wait for it. This can
595 * go to sleep indefinitely.
596 */
597 while (event_thread_id_ != 0) {
598 VLOG(jdwp) << StringPrintf("event in progress (%#llx), %#llx sleeping", event_thread_id_, threadId);
599 waited = true;
600 event_thread_cond_.Wait(self);
601 }
602
603 if (waited || threadId != 0) {
604 VLOG(jdwp) << StringPrintf("event token grabbed (%#llx)", threadId);
605 }
606 if (threadId != 0) {
607 event_thread_id_ = threadId;
608 }
609 }
610
611 /*
612 * Clear the threadId and signal anybody waiting.
613 */
ClearWaitForEventThread()614 void JdwpState::ClearWaitForEventThread() {
615 /*
616 * Grab the mutex. Don't try to go in/out of VMWAIT mode, as this
617 * function is called by dvmSuspendSelf(), and the transition back
618 * to RUNNING would confuse it.
619 */
620 Thread* self = Thread::Current();
621 MutexLock mu(self, event_thread_lock_);
622
623 CHECK_NE(event_thread_id_, 0U);
624 VLOG(jdwp) << StringPrintf("cleared event token (%#llx)", event_thread_id_);
625
626 event_thread_id_ = 0;
627
628 event_thread_cond_.Signal(self);
629 }
630
631
632 /*
633 * Prep an event. Allocates storage for the message and leaves space for
634 * the header.
635 */
eventPrep()636 static ExpandBuf* eventPrep() {
637 ExpandBuf* pReq = expandBufAlloc();
638 expandBufAddSpace(pReq, kJDWPHeaderLen);
639 return pReq;
640 }
641
642 /*
643 * Write the header into the buffer and send the packet off to the debugger.
644 *
645 * Takes ownership of "pReq" (currently discards it).
646 */
EventFinish(ExpandBuf * pReq)647 void JdwpState::EventFinish(ExpandBuf* pReq) {
648 uint8_t* buf = expandBufGetBuffer(pReq);
649
650 Set4BE(buf, expandBufGetLength(pReq));
651 Set4BE(buf+4, NextRequestSerial());
652 Set1(buf+8, 0); /* flags */
653 Set1(buf+9, kJdwpEventCommandSet);
654 Set1(buf+10, kJdwpCompositeCommand);
655
656 SendRequest(pReq);
657
658 expandBufFree(pReq);
659 }
660
661
662 /*
663 * Tell the debugger that we have finished initializing. This is always
664 * sent, even if the debugger hasn't requested it.
665 *
666 * This should be sent "before the main thread is started and before
667 * any application code has been executed". The thread ID in the message
668 * must be for the main thread.
669 */
PostVMStart()670 bool JdwpState::PostVMStart() {
671 JdwpSuspendPolicy suspend_policy;
672 ObjectId threadId = Dbg::GetThreadSelfId();
673
674 if (options_->suspend) {
675 suspend_policy = SP_ALL;
676 } else {
677 suspend_policy = SP_NONE;
678 }
679
680 ExpandBuf* pReq = eventPrep();
681 {
682 MutexLock mu(Thread::Current(), event_list_lock_); // probably don't need this here
683
684 VLOG(jdwp) << "EVENT: " << EK_VM_START;
685 VLOG(jdwp) << " suspend_policy=" << suspend_policy;
686
687 expandBufAdd1(pReq, suspend_policy);
688 expandBufAdd4BE(pReq, 1);
689
690 expandBufAdd1(pReq, EK_VM_START);
691 expandBufAdd4BE(pReq, 0); /* requestId */
692 expandBufAdd8BE(pReq, threadId);
693 }
694
695 /* send request and possibly suspend ourselves */
696 SendRequestAndPossiblySuspend(pReq, suspend_policy, threadId);
697
698 return true;
699 }
700
701 /*
702 * A location of interest has been reached. This handles:
703 * Breakpoint
704 * SingleStep
705 * MethodEntry
706 * MethodExit
707 * These four types must be grouped together in a single response. The
708 * "eventFlags" indicates the type of event(s) that have happened.
709 *
710 * Valid mods:
711 * Count, ThreadOnly, ClassOnly, ClassMatch, ClassExclude, InstanceOnly
712 * LocationOnly (for breakpoint/step only)
713 * Step (for step only)
714 *
715 * Interesting test cases:
716 * - Put a breakpoint on a native method. Eclipse creates METHOD_ENTRY
717 * and METHOD_EXIT events with a ClassOnly mod on the method's class.
718 * - Use "run to line". Eclipse creates a BREAKPOINT with Count=1.
719 * - Single-step to a line with a breakpoint. Should get a single
720 * event message with both events in it.
721 */
PostLocationEvent(const JdwpLocation * pLoc,ObjectId thisPtr,int eventFlags)722 bool JdwpState::PostLocationEvent(const JdwpLocation* pLoc, ObjectId thisPtr, int eventFlags) {
723 ModBasket basket;
724 basket.pLoc = pLoc;
725 basket.classId = pLoc->class_id;
726 basket.thisPtr = thisPtr;
727 basket.threadId = Dbg::GetThreadSelfId();
728 basket.className = Dbg::GetClassName(pLoc->class_id);
729
730 /*
731 * On rare occasions we may need to execute interpreted code in the VM
732 * while handling a request from the debugger. Don't fire breakpoints
733 * while doing so. (I don't think we currently do this at all, so
734 * this is mostly paranoia.)
735 */
736 if (basket.threadId == debug_thread_id_) {
737 VLOG(jdwp) << "Ignoring location event in JDWP thread";
738 return false;
739 }
740
741 /*
742 * The debugger variable display tab may invoke the interpreter to format
743 * complex objects. We want to ignore breakpoints and method entry/exit
744 * traps while working on behalf of the debugger.
745 *
746 * If we don't ignore them, the VM will get hung up, because we'll
747 * suspend on a breakpoint while the debugger is still waiting for its
748 * method invocation to complete.
749 */
750 if (InvokeInProgress()) {
751 VLOG(jdwp) << "Not checking breakpoints during invoke (" << basket.className << ")";
752 return false;
753 }
754
755 JdwpEvent** match_list = NULL;
756 int match_count = 0;
757 ExpandBuf* pReq = NULL;
758 JdwpSuspendPolicy suspend_policy = SP_NONE;
759
760 {
761 MutexLock mu(Thread::Current(), event_list_lock_);
762 match_list = AllocMatchList(event_list_size_);
763 if ((eventFlags & Dbg::kBreakpoint) != 0) {
764 FindMatchingEvents(EK_BREAKPOINT, &basket, match_list, &match_count);
765 }
766 if ((eventFlags & Dbg::kSingleStep) != 0) {
767 FindMatchingEvents(EK_SINGLE_STEP, &basket, match_list, &match_count);
768 }
769 if ((eventFlags & Dbg::kMethodEntry) != 0) {
770 FindMatchingEvents(EK_METHOD_ENTRY, &basket, match_list, &match_count);
771 }
772 if ((eventFlags & Dbg::kMethodExit) != 0) {
773 FindMatchingEvents(EK_METHOD_EXIT, &basket, match_list, &match_count);
774
775 // TODO: match EK_METHOD_EXIT_WITH_RETURN_VALUE too; we need to include the 'value', though.
776 // FindMatchingEvents(EK_METHOD_EXIT_WITH_RETURN_VALUE, &basket, match_list, &match_count);
777 }
778 if (match_count != 0) {
779 VLOG(jdwp) << "EVENT: " << match_list[0]->eventKind << "(" << match_count << " total) "
780 << basket.className << "." << Dbg::GetMethodName(pLoc->method_id)
781 << StringPrintf(" thread=%#llx dex_pc=%#llx)", basket.threadId, pLoc->dex_pc);
782
783 suspend_policy = scanSuspendPolicy(match_list, match_count);
784 VLOG(jdwp) << " suspend_policy=" << suspend_policy;
785
786 pReq = eventPrep();
787 expandBufAdd1(pReq, suspend_policy);
788 expandBufAdd4BE(pReq, match_count);
789
790 for (int i = 0; i < match_count; i++) {
791 expandBufAdd1(pReq, match_list[i]->eventKind);
792 expandBufAdd4BE(pReq, match_list[i]->requestId);
793 expandBufAdd8BE(pReq, basket.threadId);
794 expandBufAddLocation(pReq, *pLoc);
795 }
796 }
797
798 CleanupMatchList(match_list, match_count);
799 }
800
801 SendRequestAndPossiblySuspend(pReq, suspend_policy, basket.threadId);
802 return match_count != 0;
803 }
804
805 /*
806 * A thread is starting or stopping.
807 *
808 * Valid mods:
809 * Count, ThreadOnly
810 */
PostThreadChange(ObjectId threadId,bool start)811 bool JdwpState::PostThreadChange(ObjectId threadId, bool start) {
812 CHECK_EQ(threadId, Dbg::GetThreadSelfId());
813
814 /*
815 * I don't think this can happen.
816 */
817 if (InvokeInProgress()) {
818 LOG(WARNING) << "Not posting thread change during invoke";
819 return false;
820 }
821
822 ModBasket basket;
823 basket.threadId = threadId;
824
825 ExpandBuf* pReq = NULL;
826 JdwpSuspendPolicy suspend_policy = SP_NONE;
827 int match_count = 0;
828 {
829 // Don't allow the list to be updated while we scan it.
830 MutexLock mu(Thread::Current(), event_list_lock_);
831 JdwpEvent** match_list = AllocMatchList(event_list_size_);
832
833 if (start) {
834 FindMatchingEvents(EK_THREAD_START, &basket, match_list, &match_count);
835 } else {
836 FindMatchingEvents(EK_THREAD_DEATH, &basket, match_list, &match_count);
837 }
838
839 if (match_count != 0) {
840 VLOG(jdwp) << "EVENT: " << match_list[0]->eventKind << "(" << match_count << " total) "
841 << StringPrintf("thread=%#llx", basket.threadId) << ")";
842
843 suspend_policy = scanSuspendPolicy(match_list, match_count);
844 VLOG(jdwp) << " suspend_policy=" << suspend_policy;
845
846 pReq = eventPrep();
847 expandBufAdd1(pReq, suspend_policy);
848 expandBufAdd4BE(pReq, match_count);
849
850 for (int i = 0; i < match_count; i++) {
851 expandBufAdd1(pReq, match_list[i]->eventKind);
852 expandBufAdd4BE(pReq, match_list[i]->requestId);
853 expandBufAdd8BE(pReq, basket.threadId);
854 }
855 }
856
857 CleanupMatchList(match_list, match_count);
858 }
859
860 SendRequestAndPossiblySuspend(pReq, suspend_policy, basket.threadId);
861
862 return match_count != 0;
863 }
864
865 /*
866 * Send a polite "VM is dying" message to the debugger.
867 *
868 * Skips the usual "event token" stuff.
869 */
PostVMDeath()870 bool JdwpState::PostVMDeath() {
871 VLOG(jdwp) << "EVENT: " << EK_VM_DEATH;
872
873 ExpandBuf* pReq = eventPrep();
874 expandBufAdd1(pReq, SP_NONE);
875 expandBufAdd4BE(pReq, 1);
876
877 expandBufAdd1(pReq, EK_VM_DEATH);
878 expandBufAdd4BE(pReq, 0);
879 EventFinish(pReq);
880 return true;
881 }
882
883 /*
884 * An exception has been thrown. It may or may not have been caught.
885 *
886 * Valid mods:
887 * Count, ThreadOnly, ClassOnly, ClassMatch, ClassExclude, LocationOnly,
888 * ExceptionOnly, InstanceOnly
889 *
890 * The "exceptionId" has not been added to the GC-visible object registry,
891 * because there's a pretty good chance that we're not going to send it
892 * up the debugger.
893 */
PostException(const JdwpLocation * pThrowLoc,ObjectId exceptionId,RefTypeId exceptionClassId,const JdwpLocation * pCatchLoc,ObjectId thisPtr)894 bool JdwpState::PostException(const JdwpLocation* pThrowLoc,
895 ObjectId exceptionId, RefTypeId exceptionClassId,
896 const JdwpLocation* pCatchLoc, ObjectId thisPtr) {
897 ModBasket basket;
898
899 basket.pLoc = pThrowLoc;
900 basket.classId = pThrowLoc->class_id;
901 basket.threadId = Dbg::GetThreadSelfId();
902 basket.className = Dbg::GetClassName(basket.classId);
903 basket.excepClassId = exceptionClassId;
904 basket.caught = (pCatchLoc->class_id != 0);
905 basket.thisPtr = thisPtr;
906
907 /* don't try to post an exception caused by the debugger */
908 if (InvokeInProgress()) {
909 VLOG(jdwp) << "Not posting exception hit during invoke (" << basket.className << ")";
910 return false;
911 }
912
913 JdwpEvent** match_list = NULL;
914 int match_count = 0;
915 ExpandBuf* pReq = NULL;
916 JdwpSuspendPolicy suspend_policy = SP_NONE;
917 {
918 MutexLock mu(Thread::Current(), event_list_lock_);
919 match_list = AllocMatchList(event_list_size_);
920 FindMatchingEvents(EK_EXCEPTION, &basket, match_list, &match_count);
921 if (match_count != 0) {
922 VLOG(jdwp) << "EVENT: " << match_list[0]->eventKind << "(" << match_count << " total)"
923 << StringPrintf(" thread=%#llx", basket.threadId)
924 << StringPrintf(" exceptId=%#llx", exceptionId)
925 << " caught=" << basket.caught << ")"
926 << " throw: " << *pThrowLoc;
927 if (pCatchLoc->class_id == 0) {
928 VLOG(jdwp) << " catch: (not caught)";
929 } else {
930 VLOG(jdwp) << " catch: " << *pCatchLoc;
931 }
932
933 suspend_policy = scanSuspendPolicy(match_list, match_count);
934 VLOG(jdwp) << " suspend_policy=" << suspend_policy;
935
936 pReq = eventPrep();
937 expandBufAdd1(pReq, suspend_policy);
938 expandBufAdd4BE(pReq, match_count);
939
940 for (int i = 0; i < match_count; i++) {
941 expandBufAdd1(pReq, match_list[i]->eventKind);
942 expandBufAdd4BE(pReq, match_list[i]->requestId);
943 expandBufAdd8BE(pReq, basket.threadId);
944
945 expandBufAddLocation(pReq, *pThrowLoc);
946 expandBufAdd1(pReq, JT_OBJECT);
947 expandBufAdd8BE(pReq, exceptionId);
948 expandBufAddLocation(pReq, *pCatchLoc);
949 }
950 }
951
952 CleanupMatchList(match_list, match_count);
953 }
954
955 SendRequestAndPossiblySuspend(pReq, suspend_policy, basket.threadId);
956
957 return match_count != 0;
958 }
959
960 /*
961 * Announce that a class has been loaded.
962 *
963 * Valid mods:
964 * Count, ThreadOnly, ClassOnly, ClassMatch, ClassExclude
965 */
PostClassPrepare(JdwpTypeTag tag,RefTypeId refTypeId,const std::string & signature,int status)966 bool JdwpState::PostClassPrepare(JdwpTypeTag tag, RefTypeId refTypeId, const std::string& signature,
967 int status) {
968 ModBasket basket;
969
970 basket.classId = refTypeId;
971 basket.threadId = Dbg::GetThreadSelfId();
972 basket.className = Dbg::GetClassName(basket.classId);
973
974 /* suppress class prep caused by debugger */
975 if (InvokeInProgress()) {
976 VLOG(jdwp) << "Not posting class prep caused by invoke (" << basket.className << ")";
977 return false;
978 }
979
980 ExpandBuf* pReq = NULL;
981 JdwpSuspendPolicy suspend_policy = SP_NONE;
982 int match_count = 0;
983 {
984 MutexLock mu(Thread::Current(), event_list_lock_);
985 JdwpEvent** match_list = AllocMatchList(event_list_size_);
986 FindMatchingEvents(EK_CLASS_PREPARE, &basket, match_list, &match_count);
987 if (match_count != 0) {
988 VLOG(jdwp) << "EVENT: " << match_list[0]->eventKind << "(" << match_count << " total) "
989 << StringPrintf("thread=%#llx", basket.threadId) << ") " << signature;
990
991 suspend_policy = scanSuspendPolicy(match_list, match_count);
992 VLOG(jdwp) << " suspend_policy=" << suspend_policy;
993
994 if (basket.threadId == debug_thread_id_) {
995 /*
996 * JDWP says that, for a class prep in the debugger thread, we
997 * should set threadId to null and if any threads were supposed
998 * to be suspended then we suspend all other threads.
999 */
1000 VLOG(jdwp) << " NOTE: class prepare in debugger thread!";
1001 basket.threadId = 0;
1002 if (suspend_policy == SP_EVENT_THREAD) {
1003 suspend_policy = SP_ALL;
1004 }
1005 }
1006
1007 pReq = eventPrep();
1008 expandBufAdd1(pReq, suspend_policy);
1009 expandBufAdd4BE(pReq, match_count);
1010
1011 for (int i = 0; i < match_count; i++) {
1012 expandBufAdd1(pReq, match_list[i]->eventKind);
1013 expandBufAdd4BE(pReq, match_list[i]->requestId);
1014 expandBufAdd8BE(pReq, basket.threadId);
1015
1016 expandBufAdd1(pReq, tag);
1017 expandBufAdd8BE(pReq, refTypeId);
1018 expandBufAddUtf8String(pReq, signature);
1019 expandBufAdd4BE(pReq, status);
1020 }
1021 }
1022 CleanupMatchList(match_list, match_count);
1023 }
1024
1025 SendRequestAndPossiblySuspend(pReq, suspend_policy, basket.threadId);
1026
1027 return match_count != 0;
1028 }
1029
1030 /*
1031 * Send up a chunk of DDM data.
1032 *
1033 * While this takes the form of a JDWP "event", it doesn't interact with
1034 * other debugger traffic, and can't suspend the VM, so we skip all of
1035 * the fun event token gymnastics.
1036 */
DdmSendChunkV(uint32_t type,const iovec * iov,int iov_count)1037 void JdwpState::DdmSendChunkV(uint32_t type, const iovec* iov, int iov_count) {
1038 uint8_t header[kJDWPHeaderLen + 8];
1039 size_t dataLen = 0;
1040
1041 CHECK(iov != NULL);
1042 CHECK_GT(iov_count, 0);
1043 CHECK_LT(iov_count, 10);
1044
1045 /*
1046 * "Wrap" the contents of the iovec with a JDWP/DDMS header. We do
1047 * this by creating a new copy of the vector with space for the header.
1048 */
1049 std::vector<iovec> wrapiov;
1050 wrapiov.push_back(iovec());
1051 for (int i = 0; i < iov_count; i++) {
1052 wrapiov.push_back(iov[i]);
1053 dataLen += iov[i].iov_len;
1054 }
1055
1056 /* form the header (JDWP plus DDMS) */
1057 Set4BE(header, sizeof(header) + dataLen);
1058 Set4BE(header+4, NextRequestSerial());
1059 Set1(header+8, 0); /* flags */
1060 Set1(header+9, kJDWPDdmCmdSet);
1061 Set1(header+10, kJDWPDdmCmd);
1062 Set4BE(header+11, type);
1063 Set4BE(header+15, dataLen);
1064
1065 wrapiov[0].iov_base = header;
1066 wrapiov[0].iov_len = sizeof(header);
1067
1068 // Try to avoid blocking GC during a send, but only safe when not using mutexes at a lower-level
1069 // than mutator for lock ordering reasons.
1070 Thread* self = Thread::Current();
1071 bool safe_to_release_mutator_lock_over_send = !Locks::mutator_lock_->IsExclusiveHeld(self);
1072 if (safe_to_release_mutator_lock_over_send) {
1073 for (size_t i = 0; i < kMutatorLock; ++i) {
1074 if (self->GetHeldMutex(static_cast<LockLevel>(i)) != NULL) {
1075 safe_to_release_mutator_lock_over_send = false;
1076 break;
1077 }
1078 }
1079 }
1080 if (safe_to_release_mutator_lock_over_send) {
1081 // Change state to waiting to allow GC, ... while we're sending.
1082 self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSend);
1083 SendBufferedRequest(type, wrapiov);
1084 self->TransitionFromSuspendedToRunnable();
1085 } else {
1086 // Send and possibly block GC...
1087 SendBufferedRequest(type, wrapiov);
1088 }
1089 }
1090
1091 } // namespace JDWP
1092
1093 } // namespace art
1094