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