Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2008 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Elliott Hughes | 07ed66b | 2012-12-12 18:34:25 -0800 | [diff] [blame] | 17 | #include <errno.h> |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 18 | #include <stdlib.h> |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 19 | #include <sys/time.h> |
| 20 | #include <time.h> |
Elliott Hughes | 07ed66b | 2012-12-12 18:34:25 -0800 | [diff] [blame] | 21 | #include <unistd.h> |
| 22 | |
| 23 | #include "atomic.h" |
| 24 | #include "base/logging.h" |
| 25 | #include "debugger.h" |
| 26 | #include "jdwp/jdwp_priv.h" |
| 27 | #include "scoped_thread_state_change.h" |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 28 | |
| 29 | namespace art { |
| 30 | |
| 31 | namespace JDWP { |
| 32 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 33 | static void* StartJdwpThread(void* arg); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 34 | |
| 35 | /* |
| 36 | * JdwpNetStateBase class implementation |
| 37 | */ |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 38 | JdwpNetStateBase::JdwpNetStateBase(JdwpState* state) |
Mathieu Chartier | 4b95e8f | 2013-07-15 16:32:50 -0700 | [diff] [blame] | 39 | : state_(state), socket_lock_("JdwpNetStateBase lock", kJdwpSocketLock) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 40 | clientSock = -1; |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 41 | wake_pipe_[0] = -1; |
| 42 | wake_pipe_[1] = -1; |
| 43 | input_count_ = 0; |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 44 | awaiting_handshake_ = false; |
Elliott Hughes | cb69306 | 2013-02-21 09:48:08 -0800 | [diff] [blame] | 45 | } |
| 46 | |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 47 | JdwpNetStateBase::~JdwpNetStateBase() { |
| 48 | if (wake_pipe_[0] != -1) { |
| 49 | close(wake_pipe_[0]); |
| 50 | wake_pipe_[0] = -1; |
| 51 | } |
| 52 | if (wake_pipe_[1] != -1) { |
| 53 | close(wake_pipe_[1]); |
| 54 | wake_pipe_[1] = -1; |
| 55 | } |
| 56 | } |
| 57 | |
| 58 | bool JdwpNetStateBase::MakePipe() { |
| 59 | if (pipe(wake_pipe_) == -1) { |
| 60 | PLOG(ERROR) << "pipe failed"; |
| 61 | return false; |
| 62 | } |
| 63 | return true; |
| 64 | } |
| 65 | |
| 66 | void JdwpNetStateBase::WakePipe() { |
| 67 | // If we might be sitting in select, kick us loose. |
| 68 | if (wake_pipe_[1] != -1) { |
| 69 | VLOG(jdwp) << "+++ writing to wake pipe"; |
| 70 | TEMP_FAILURE_RETRY(write(wake_pipe_[1], "", 1)); |
| 71 | } |
| 72 | } |
| 73 | |
Elliott Hughes | cb69306 | 2013-02-21 09:48:08 -0800 | [diff] [blame] | 74 | void JdwpNetStateBase::ConsumeBytes(size_t count) { |
| 75 | CHECK_GT(count, 0U); |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 76 | CHECK_LE(count, input_count_); |
Elliott Hughes | cb69306 | 2013-02-21 09:48:08 -0800 | [diff] [blame] | 77 | |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 78 | if (count == input_count_) { |
| 79 | input_count_ = 0; |
Elliott Hughes | cb69306 | 2013-02-21 09:48:08 -0800 | [diff] [blame] | 80 | return; |
| 81 | } |
| 82 | |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 83 | memmove(input_buffer_, input_buffer_ + count, input_count_ - count); |
| 84 | input_count_ -= count; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 85 | } |
| 86 | |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 87 | bool JdwpNetStateBase::HaveFullPacket() { |
| 88 | if (awaiting_handshake_) { |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 89 | return (input_count_ >= kMagicHandshakeLen); |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 90 | } |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 91 | if (input_count_ < 4) { |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 92 | return false; |
| 93 | } |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 94 | uint32_t length = Get4BE(input_buffer_); |
| 95 | return (input_count_ >= length); |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 96 | } |
| 97 | |
| 98 | bool JdwpNetStateBase::IsAwaitingHandshake() { |
| 99 | return awaiting_handshake_; |
| 100 | } |
| 101 | |
| 102 | void JdwpNetStateBase::SetAwaitingHandshake(bool new_state) { |
| 103 | awaiting_handshake_ = new_state; |
| 104 | } |
| 105 | |
| 106 | bool JdwpNetStateBase::IsConnected() { |
| 107 | return clientSock >= 0; |
| 108 | } |
| 109 | |
| 110 | // Close a connection from a debugger (which may have already dropped us). |
| 111 | // Resets the state so we're ready to receive a new connection. |
| 112 | // Only called from the JDWP thread. |
| 113 | void JdwpNetStateBase::Close() { |
| 114 | if (clientSock < 0) { |
| 115 | return; |
| 116 | } |
| 117 | |
| 118 | VLOG(jdwp) << "+++ closing JDWP connection on fd " << clientSock; |
| 119 | |
| 120 | close(clientSock); |
| 121 | clientSock = -1; |
| 122 | } |
| 123 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 124 | /* |
Sebastien Hertz | 43c8d72 | 2014-03-18 12:19:52 +0100 | [diff] [blame] | 125 | * Write a packet of "length" bytes. Grabs a mutex to assure atomicity. |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 126 | */ |
Sebastien Hertz | 43c8d72 | 2014-03-18 12:19:52 +0100 | [diff] [blame] | 127 | ssize_t JdwpNetStateBase::WritePacket(ExpandBuf* pReply, size_t length) { |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 128 | MutexLock mu(Thread::Current(), socket_lock_); |
Sebastien Hertz | 43c8d72 | 2014-03-18 12:19:52 +0100 | [diff] [blame] | 129 | DCHECK_LE(length, expandBufGetLength(pReply)); |
| 130 | return TEMP_FAILURE_RETRY(write(clientSock, expandBufGetBuffer(pReply), length)); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 131 | } |
| 132 | |
| 133 | /* |
| 134 | * Write a buffered packet. Grabs a mutex to assure atomicity. |
| 135 | */ |
Brian Carlstrom | f529352 | 2013-07-19 00:24:00 -0700 | [diff] [blame] | 136 | ssize_t JdwpNetStateBase::WriteBufferedPacket(const std::vector<iovec>& iov) { |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 137 | MutexLock mu(Thread::Current(), socket_lock_); |
Mathieu Chartier | ad466ad | 2015-01-08 16:28:08 -0800 | [diff] [blame] | 138 | return WriteBufferedPacketLocked(iov); |
| 139 | } |
| 140 | |
| 141 | ssize_t JdwpNetStateBase::WriteBufferedPacketLocked(const std::vector<iovec>& iov) { |
| 142 | socket_lock_.AssertHeld(Thread::Current()); |
Brian Carlstrom | f529352 | 2013-07-19 00:24:00 -0700 | [diff] [blame] | 143 | return TEMP_FAILURE_RETRY(writev(clientSock, &iov[0], iov.size())); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 144 | } |
| 145 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 146 | bool JdwpState::IsConnected() { |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 147 | return netState != nullptr && netState->IsConnected(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 148 | } |
| 149 | |
Brian Carlstrom | f529352 | 2013-07-19 00:24:00 -0700 | [diff] [blame] | 150 | void JdwpState::SendBufferedRequest(uint32_t type, const std::vector<iovec>& iov) { |
Sebastien Hertz | 60ed7da | 2014-08-28 18:50:36 +0200 | [diff] [blame] | 151 | if (!IsConnected()) { |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 152 | // Can happen with some DDMS events. |
| 153 | VLOG(jdwp) << "Not sending JDWP packet: no debugger attached!"; |
| 154 | return; |
| 155 | } |
| 156 | |
| 157 | size_t expected = 0; |
Brian Carlstrom | f529352 | 2013-07-19 00:24:00 -0700 | [diff] [blame] | 158 | for (size_t i = 0; i < iov.size(); ++i) { |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 159 | expected += iov[i].iov_len; |
| 160 | } |
| 161 | |
| 162 | errno = 0; |
Brian Carlstrom | f529352 | 2013-07-19 00:24:00 -0700 | [diff] [blame] | 163 | ssize_t actual = netState->WriteBufferedPacket(iov); |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 164 | if (static_cast<size_t>(actual) != expected) { |
Ian Rogers | d9e4e0c | 2014-01-23 20:11:40 -0800 | [diff] [blame] | 165 | PLOG(ERROR) << StringPrintf("Failed to send JDWP packet %c%c%c%c to debugger (%zd of %zu)", |
| 166 | static_cast<char>(type >> 24), |
| 167 | static_cast<char>(type >> 16), |
| 168 | static_cast<char>(type >> 8), |
| 169 | static_cast<char>(type), |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 170 | actual, expected); |
| 171 | } |
| 172 | } |
| 173 | |
| 174 | void JdwpState::SendRequest(ExpandBuf* pReq) { |
Sebastien Hertz | 60ed7da | 2014-08-28 18:50:36 +0200 | [diff] [blame] | 175 | if (!IsConnected()) { |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 176 | // Can happen with some DDMS events. |
| 177 | VLOG(jdwp) << "Not sending JDWP packet: no debugger attached!"; |
| 178 | return; |
| 179 | } |
| 180 | |
| 181 | errno = 0; |
Sebastien Hertz | 43c8d72 | 2014-03-18 12:19:52 +0100 | [diff] [blame] | 182 | ssize_t actual = netState->WritePacket(pReq, expandBufGetLength(pReq)); |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 183 | if (static_cast<size_t>(actual) != expandBufGetLength(pReq)) { |
Ian Rogers | d9e4e0c | 2014-01-23 20:11:40 -0800 | [diff] [blame] | 184 | PLOG(ERROR) << StringPrintf("Failed to send JDWP packet to debugger (%zd of %zu)", |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 185 | actual, expandBufGetLength(pReq)); |
| 186 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 187 | } |
| 188 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 189 | /* |
| 190 | * Get the next "request" serial number. We use this when sending |
| 191 | * packets to the debugger. |
| 192 | */ |
| 193 | uint32_t JdwpState::NextRequestSerial() { |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 194 | return request_serial_++; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 195 | } |
| 196 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 197 | /* |
| 198 | * Get the next "event" serial number. We use this in the response to |
| 199 | * message type EventRequest.Set. |
| 200 | */ |
| 201 | uint32_t JdwpState::NextEventSerial() { |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 202 | return event_serial_++; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 203 | } |
| 204 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 205 | JdwpState::JdwpState(const JdwpOptions* options) |
| 206 | : options_(options), |
jeffhao | 0dfbb7e | 2012-11-28 15:26:03 -0800 | [diff] [blame] | 207 | thread_start_lock_("JDWP thread start lock", kJdwpStartLock), |
Ian Rogers | c604d73 | 2012-10-14 16:09:54 -0700 | [diff] [blame] | 208 | thread_start_cond_("JDWP thread start condition variable", thread_start_lock_), |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 209 | pthread_(0), |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 210 | thread_(nullptr), |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 211 | debug_thread_started_(false), |
Elliott Hughes | a21039c | 2012-06-21 12:09:25 -0700 | [diff] [blame] | 212 | debug_thread_id_(0), |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 213 | run(false), |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 214 | netState(nullptr), |
jeffhao | 0dfbb7e | 2012-11-28 15:26:03 -0800 | [diff] [blame] | 215 | attach_lock_("JDWP attach lock", kJdwpAttachLock), |
Ian Rogers | c604d73 | 2012-10-14 16:09:54 -0700 | [diff] [blame] | 216 | attach_cond_("JDWP attach condition variable", attach_lock_), |
Elliott Hughes | a21039c | 2012-06-21 12:09:25 -0700 | [diff] [blame] | 217 | last_activity_time_ms_(0), |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 218 | request_serial_(0x10000000), |
| 219 | event_serial_(0x20000000), |
jeffhao | a77f0f6 | 2012-12-05 17:19:31 -0800 | [diff] [blame] | 220 | event_list_lock_("JDWP event list lock", kJdwpEventListLock), |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 221 | event_list_(nullptr), |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 222 | event_list_size_(0), |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 223 | event_thread_lock_("JDWP event thread lock"), |
Ian Rogers | c604d73 | 2012-10-14 16:09:54 -0700 | [diff] [blame] | 224 | event_thread_cond_("JDWP event thread condition variable", event_thread_lock_), |
Elliott Hughes | a21039c | 2012-06-21 12:09:25 -0700 | [diff] [blame] | 225 | event_thread_id_(0), |
Sebastien Hertz | 99660e1 | 2014-02-19 15:04:42 +0100 | [diff] [blame] | 226 | process_request_lock_("JDWP process request lock"), |
| 227 | process_request_cond_("JDWP process request condition variable", process_request_lock_), |
| 228 | processing_request_(false), |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 229 | ddm_is_active_(false), |
| 230 | should_exit_(false), |
| 231 | exit_status_(0) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 232 | } |
| 233 | |
| 234 | /* |
| 235 | * Initialize JDWP. |
| 236 | * |
| 237 | * Does not return until JDWP thread is running, but may return before |
| 238 | * the thread is accepting network connections. |
| 239 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 240 | JdwpState* JdwpState::Create(const JdwpOptions* options) { |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 241 | Thread* self = Thread::Current(); |
| 242 | Locks::mutator_lock_->AssertNotHeld(self); |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 243 | std::unique_ptr<JdwpState> state(new JdwpState(options)); |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 244 | switch (options->transport) { |
Sebastien Hertz | bb5c355 | 2014-04-14 14:38:24 +0200 | [diff] [blame] | 245 | case kJdwpTransportSocket: |
| 246 | InitSocketTransport(state.get(), options); |
| 247 | break; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 248 | #ifdef HAVE_ANDROID_OS |
Sebastien Hertz | bb5c355 | 2014-04-14 14:38:24 +0200 | [diff] [blame] | 249 | case kJdwpTransportAndroidAdb: |
| 250 | InitAdbTransport(state.get(), options); |
| 251 | break; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 252 | #endif |
Sebastien Hertz | bb5c355 | 2014-04-14 14:38:24 +0200 | [diff] [blame] | 253 | default: |
| 254 | LOG(FATAL) << "Unknown transport: " << options->transport; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 255 | } |
| 256 | |
Sebastien Hertz | bb5c355 | 2014-04-14 14:38:24 +0200 | [diff] [blame] | 257 | { |
Jeff Hao | add037d | 2013-07-15 14:24:14 -0700 | [diff] [blame] | 258 | /* |
| 259 | * Grab a mutex before starting the thread. This ensures they |
| 260 | * won't signal the cond var before we're waiting. |
| 261 | */ |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 262 | MutexLock thread_start_locker(self, state->thread_start_lock_); |
Sebastien Hertz | bb5c355 | 2014-04-14 14:38:24 +0200 | [diff] [blame] | 263 | |
Jeff Hao | add037d | 2013-07-15 14:24:14 -0700 | [diff] [blame] | 264 | /* |
| 265 | * We have bound to a port, or are trying to connect outbound to a |
| 266 | * debugger. Create the JDWP thread and let it continue the mission. |
| 267 | */ |
Sebastien Hertz | bb5c355 | 2014-04-14 14:38:24 +0200 | [diff] [blame] | 268 | CHECK_PTHREAD_CALL(pthread_create, (&state->pthread_, nullptr, StartJdwpThread, state.get()), |
| 269 | "JDWP thread"); |
Jeff Hao | add037d | 2013-07-15 14:24:14 -0700 | [diff] [blame] | 270 | |
| 271 | /* |
| 272 | * Wait until the thread finishes basic initialization. |
Jeff Hao | add037d | 2013-07-15 14:24:14 -0700 | [diff] [blame] | 273 | */ |
Sebastien Hertz | bb5c355 | 2014-04-14 14:38:24 +0200 | [diff] [blame] | 274 | while (!state->debug_thread_started_) { |
Ian Rogers | c604d73 | 2012-10-14 16:09:54 -0700 | [diff] [blame] | 275 | state->thread_start_cond_.Wait(self); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 276 | } |
Sebastien Hertz | bb5c355 | 2014-04-14 14:38:24 +0200 | [diff] [blame] | 277 | } |
Jeff Hao | add037d | 2013-07-15 14:24:14 -0700 | [diff] [blame] | 278 | |
Sebastien Hertz | bb5c355 | 2014-04-14 14:38:24 +0200 | [diff] [blame] | 279 | if (options->suspend) { |
Jeff Hao | add037d | 2013-07-15 14:24:14 -0700 | [diff] [blame] | 280 | /* |
| 281 | * For suspend=y, wait for the debugger to connect to us or for us to |
| 282 | * connect to the debugger. |
| 283 | * |
| 284 | * The JDWP thread will signal us when it connects successfully or |
| 285 | * times out (for timeout=xxx), so we have to check to see what happened |
| 286 | * when we wake up. |
| 287 | */ |
| 288 | { |
| 289 | ScopedThreadStateChange tsc(self, kWaitingForDebuggerToAttach); |
| 290 | MutexLock attach_locker(self, state->attach_lock_); |
Sebastien Hertz | c6345ef | 2014-08-18 19:26:39 +0200 | [diff] [blame] | 291 | while (state->debug_thread_id_ == 0) { |
| 292 | state->attach_cond_.Wait(self); |
| 293 | } |
Jeff Hao | add037d | 2013-07-15 14:24:14 -0700 | [diff] [blame] | 294 | } |
| 295 | if (!state->IsActive()) { |
| 296 | LOG(ERROR) << "JDWP connection failed"; |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 297 | return nullptr; |
Jeff Hao | add037d | 2013-07-15 14:24:14 -0700 | [diff] [blame] | 298 | } |
| 299 | |
| 300 | LOG(INFO) << "JDWP connected"; |
| 301 | |
| 302 | /* |
| 303 | * Ordinarily we would pause briefly to allow the debugger to set |
| 304 | * breakpoints and so on, but for "suspend=y" the VM init code will |
| 305 | * pause the VM when it sends the VM_START message. |
| 306 | */ |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 307 | } |
| 308 | |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 309 | return state.release(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 310 | } |
| 311 | |
| 312 | /* |
| 313 | * Reset all session-related state. There should not be an active connection |
| 314 | * to the client at this point. The rest of the VM still thinks there is |
| 315 | * a debugger attached. |
| 316 | * |
| 317 | * This includes freeing up the debugger event list. |
| 318 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 319 | void JdwpState::ResetState() { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 320 | /* could reset the serial numbers, but no need to */ |
| 321 | |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 322 | UnregisterAll(); |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 323 | { |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 324 | MutexLock mu(Thread::Current(), event_list_lock_); |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 325 | CHECK(event_list_ == nullptr); |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 326 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 327 | |
Sebastien Hertz | 7ec2f1c | 2014-03-27 20:06:47 +0100 | [diff] [blame] | 328 | Dbg::ProcessDelayedFullUndeoptimizations(); |
| 329 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 330 | /* |
| 331 | * Should not have one of these in progress. If the debugger went away |
| 332 | * mid-request, though, we could see this. |
| 333 | */ |
Elliott Hughes | a21039c | 2012-06-21 12:09:25 -0700 | [diff] [blame] | 334 | if (event_thread_id_ != 0) { |
Elliott Hughes | 3d30d9b | 2011-12-07 17:35:48 -0800 | [diff] [blame] | 335 | LOG(WARNING) << "Resetting state while event in progress"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 336 | DCHECK(false); |
| 337 | } |
| 338 | } |
| 339 | |
| 340 | /* |
| 341 | * Tell the JDWP thread to shut down. Frees "state". |
| 342 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 343 | JdwpState::~JdwpState() { |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 344 | if (netState != nullptr) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 345 | /* |
| 346 | * Close down the network to inspire the thread to halt. |
| 347 | */ |
Elliott Hughes | 0cc1bbd | 2012-01-12 12:27:08 -0800 | [diff] [blame] | 348 | VLOG(jdwp) << "JDWP shutting down net..."; |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 349 | netState->Shutdown(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 350 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 351 | if (debug_thread_started_) { |
| 352 | run = false; |
| 353 | void* threadReturn; |
Elliott Hughes | 475fc23 | 2011-10-25 15:00:35 -0700 | [diff] [blame] | 354 | if (pthread_join(pthread_, &threadReturn) != 0) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 355 | LOG(WARNING) << "JDWP thread join failed"; |
| 356 | } |
| 357 | } |
| 358 | |
Elliott Hughes | 0cc1bbd | 2012-01-12 12:27:08 -0800 | [diff] [blame] | 359 | VLOG(jdwp) << "JDWP freeing netstate..."; |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 360 | delete netState; |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 361 | netState = nullptr; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 362 | } |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 363 | CHECK(netState == nullptr); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 364 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 365 | ResetState(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 366 | } |
| 367 | |
| 368 | /* |
| 369 | * Are we talking to a debugger? |
| 370 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 371 | bool JdwpState::IsActive() { |
| 372 | return IsConnected(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 373 | } |
| 374 | |
Elliott Hughes | cb69306 | 2013-02-21 09:48:08 -0800 | [diff] [blame] | 375 | // Returns "false" if we encounter a connection-fatal error. |
| 376 | bool JdwpState::HandlePacket() { |
| 377 | JdwpNetStateBase* netStateBase = reinterpret_cast<JdwpNetStateBase*>(netState); |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 378 | JDWP::Request request(netStateBase->input_buffer_, netStateBase->input_count_); |
Elliott Hughes | cb69306 | 2013-02-21 09:48:08 -0800 | [diff] [blame] | 379 | |
| 380 | ExpandBuf* pReply = expandBufAlloc(); |
Ian Rogers | c0542af | 2014-09-03 16:16:56 -0700 | [diff] [blame] | 381 | size_t replyLength = ProcessRequest(&request, pReply); |
Sebastien Hertz | 43c8d72 | 2014-03-18 12:19:52 +0100 | [diff] [blame] | 382 | ssize_t cc = netStateBase->WritePacket(pReply, replyLength); |
Sebastien Hertz | 400a3a9 | 2014-02-24 14:56:21 +0100 | [diff] [blame] | 383 | |
| 384 | /* |
| 385 | * We processed this request and sent its reply. Notify other threads waiting for us they can now |
| 386 | * send events. |
| 387 | */ |
Sebastien Hertz | 99660e1 | 2014-02-19 15:04:42 +0100 | [diff] [blame] | 388 | EndProcessingRequest(); |
| 389 | |
Sebastien Hertz | 43c8d72 | 2014-03-18 12:19:52 +0100 | [diff] [blame] | 390 | if (cc != static_cast<ssize_t>(replyLength)) { |
Elliott Hughes | cb69306 | 2013-02-21 09:48:08 -0800 | [diff] [blame] | 391 | PLOG(ERROR) << "Failed sending reply to debugger"; |
| 392 | expandBufFree(pReply); |
| 393 | return false; |
| 394 | } |
| 395 | expandBufFree(pReply); |
| 396 | netStateBase->ConsumeBytes(request.GetLength()); |
| 397 | return true; |
| 398 | } |
| 399 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 400 | /* |
| 401 | * Entry point for JDWP thread. The thread was created through the VM |
| 402 | * mechanisms, so there is a java/lang/Thread associated with us. |
| 403 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 404 | static void* StartJdwpThread(void* arg) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 405 | JdwpState* state = reinterpret_cast<JdwpState*>(arg); |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 406 | CHECK(state != nullptr); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 407 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 408 | state->Run(); |
Sebastien Hertz | 7d95565 | 2014-10-22 10:57:10 +0200 | [diff] [blame] | 409 | return nullptr; |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 410 | } |
| 411 | |
| 412 | void JdwpState::Run() { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 413 | Runtime* runtime = Runtime::Current(); |
Mathieu Chartier | 664bebf | 2012-11-12 16:54:11 -0800 | [diff] [blame] | 414 | CHECK(runtime->AttachCurrentThread("JDWP", true, runtime->GetSystemThreadGroup(), |
| 415 | !runtime->IsCompiler())); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 416 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 417 | VLOG(jdwp) << "JDWP: thread running"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 418 | |
| 419 | /* |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 420 | * Finish initializing, then notify the creating thread that |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 421 | * we're running. |
| 422 | */ |
Elliott Hughes | 475fc23 | 2011-10-25 15:00:35 -0700 | [diff] [blame] | 423 | thread_ = Thread::Current(); |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 424 | run = true; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 425 | |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 426 | { |
| 427 | MutexLock locker(thread_, thread_start_lock_); |
| 428 | debug_thread_started_ = true; |
Ian Rogers | c604d73 | 2012-10-14 16:09:54 -0700 | [diff] [blame] | 429 | thread_start_cond_.Broadcast(thread_); |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 430 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 431 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 432 | /* set the thread state to kWaitingInMainDebuggerLoop so GCs don't wait for us */ |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 433 | CHECK_EQ(thread_->GetState(), kNative); |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 434 | Locks::mutator_lock_->AssertNotHeld(thread_); |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 435 | thread_->SetState(kWaitingInMainDebuggerLoop); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 436 | |
| 437 | /* |
| 438 | * Loop forever if we're in server mode, processing connections. In |
| 439 | * non-server mode, we bail out of the thread when the debugger drops |
| 440 | * us. |
| 441 | * |
| 442 | * We broadcast a notification when a debugger attaches, after we |
| 443 | * successfully process the handshake. |
| 444 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 445 | while (run) { |
| 446 | if (options_->server) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 447 | /* |
| 448 | * Block forever, waiting for a connection. To support the |
| 449 | * "timeout=xxx" option we'll need to tweak this. |
| 450 | */ |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 451 | if (!netState->Accept()) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 452 | break; |
| 453 | } |
| 454 | } else { |
| 455 | /* |
| 456 | * If we're not acting as a server, we need to connect out to the |
| 457 | * debugger. To support the "timeout=xxx" option we need to |
| 458 | * have a timeout if the handshake reply isn't received in a |
| 459 | * reasonable amount of time. |
| 460 | */ |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 461 | if (!netState->Establish(options_)) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 462 | /* wake anybody who was waiting for us to succeed */ |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 463 | MutexLock mu(thread_, attach_lock_); |
Sebastien Hertz | c6345ef | 2014-08-18 19:26:39 +0200 | [diff] [blame] | 464 | debug_thread_id_ = static_cast<ObjectId>(-1); |
Ian Rogers | c604d73 | 2012-10-14 16:09:54 -0700 | [diff] [blame] | 465 | attach_cond_.Broadcast(thread_); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 466 | break; |
| 467 | } |
| 468 | } |
| 469 | |
| 470 | /* prep debug code to handle the new connection */ |
| 471 | Dbg::Connected(); |
| 472 | |
| 473 | /* process requests until the debugger drops */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 474 | bool first = true; |
Elliott Hughes | 8696433 | 2012-02-15 19:37:42 -0800 | [diff] [blame] | 475 | while (!Dbg::IsDisposed()) { |
Sebastien Hertz | bb5c355 | 2014-04-14 14:38:24 +0200 | [diff] [blame] | 476 | // sanity check -- shouldn't happen? |
| 477 | CHECK_EQ(thread_->GetState(), kWaitingInMainDebuggerLoop); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 478 | |
Elliott Hughes | 5d10a87 | 2013-04-17 19:26:43 -0700 | [diff] [blame] | 479 | if (!netState->ProcessIncoming()) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 480 | /* blocking read */ |
| 481 | break; |
| 482 | } |
| 483 | |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 484 | if (should_exit_) { |
| 485 | exit(exit_status_); |
| 486 | } |
| 487 | |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 488 | if (first && !netState->IsAwaitingHandshake()) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 489 | /* handshake worked, tell the interpreter that we're active */ |
| 490 | first = false; |
| 491 | |
| 492 | /* set thread ID; requires object registry to be active */ |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 493 | { |
| 494 | ScopedObjectAccess soa(thread_); |
| 495 | debug_thread_id_ = Dbg::GetThreadSelfId(); |
| 496 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 497 | |
| 498 | /* wake anybody who's waiting for us */ |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 499 | MutexLock mu(thread_, attach_lock_); |
Ian Rogers | c604d73 | 2012-10-14 16:09:54 -0700 | [diff] [blame] | 500 | attach_cond_.Broadcast(thread_); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 501 | } |
| 502 | } |
| 503 | |
Elliott Hughes | 68a5e3c | 2013-04-17 17:13:35 -0700 | [diff] [blame] | 504 | netState->Close(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 505 | |
Elliott Hughes | a21039c | 2012-06-21 12:09:25 -0700 | [diff] [blame] | 506 | if (ddm_is_active_) { |
| 507 | ddm_is_active_ = false; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 508 | |
| 509 | /* broadcast the disconnect; must be in RUNNING state */ |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 510 | thread_->TransitionFromSuspendedToRunnable(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 511 | Dbg::DdmDisconnected(); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 512 | thread_->TransitionFromRunnableToSuspended(kWaitingInMainDebuggerLoop); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 513 | } |
| 514 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 515 | { |
| 516 | ScopedObjectAccess soa(thread_); |
Elliott Hughes | 0f82716 | 2013-02-26 12:12:58 -0800 | [diff] [blame] | 517 | |
| 518 | // Release session state, e.g. remove breakpoint instructions. |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 519 | ResetState(); |
| 520 | } |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 521 | // Tell the rest of the runtime that the debugger is no longer around. |
| 522 | Dbg::Disconnected(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 523 | |
| 524 | /* if we had threads suspended, resume them now */ |
| 525 | Dbg::UndoDebuggerSuspensions(); |
| 526 | |
| 527 | /* if we connected out, this was a one-shot deal */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 528 | if (!options_->server) { |
| 529 | run = false; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 530 | } |
| 531 | } |
| 532 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 533 | /* back to native, for thread shutdown */ |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 534 | CHECK_EQ(thread_->GetState(), kWaitingInMainDebuggerLoop); |
| 535 | thread_->SetState(kNative); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 536 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 537 | VLOG(jdwp) << "JDWP: thread detaching and exiting..."; |
Elliott Hughes | 6ba581a | 2011-10-25 11:45:35 -0700 | [diff] [blame] | 538 | runtime->DetachCurrentThread(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 539 | } |
| 540 | |
Elliott Hughes | a21039c | 2012-06-21 12:09:25 -0700 | [diff] [blame] | 541 | void JdwpState::NotifyDdmsActive() { |
| 542 | if (!ddm_is_active_) { |
| 543 | ddm_is_active_ = true; |
| 544 | Dbg::DdmConnected(); |
| 545 | } |
| 546 | } |
| 547 | |
Elliott Hughes | 475fc23 | 2011-10-25 15:00:35 -0700 | [diff] [blame] | 548 | Thread* JdwpState::GetDebugThread() { |
| 549 | return thread_; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 550 | } |
| 551 | |
| 552 | /* |
| 553 | * Support routines for waitForDebugger(). |
| 554 | * |
| 555 | * We can't have a trivial "waitForDebugger" function that returns the |
| 556 | * instant the debugger connects, because we run the risk of executing code |
| 557 | * before the debugger has had a chance to configure breakpoints or issue |
| 558 | * suspend calls. It would be nice to just sit in the suspended state, but |
| 559 | * most debuggers don't expect any threads to be suspended when they attach. |
| 560 | * |
| 561 | * There's no JDWP event we can post to tell the debugger, "we've stopped, |
| 562 | * and we like it that way". We could send a fake breakpoint, which should |
| 563 | * cause the debugger to immediately send a resume, but the debugger might |
| 564 | * send the resume immediately or might throw an exception of its own upon |
| 565 | * receiving a breakpoint event that it didn't ask for. |
| 566 | * |
| 567 | * What we really want is a "wait until the debugger is done configuring |
| 568 | * stuff" event. We can approximate this with a "wait until the debugger |
| 569 | * has been idle for a brief period". |
| 570 | */ |
| 571 | |
| 572 | /* |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 573 | * Return the time, in milliseconds, since the last debugger activity. |
| 574 | * |
| 575 | * Returns -1 if no debugger is attached, or 0 if we're in the middle of |
| 576 | * processing a debugger request. |
| 577 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 578 | int64_t JdwpState::LastDebuggerActivity() { |
Elliott Hughes | c0f0933 | 2012-03-26 13:27:06 -0700 | [diff] [blame] | 579 | if (!Dbg::IsDebuggerActive()) { |
Brian Carlstrom | 4d466a8 | 2014-05-08 19:05:29 -0700 | [diff] [blame] | 580 | LOG(WARNING) << "no active debugger"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 581 | return -1; |
| 582 | } |
| 583 | |
Ian Rogers | 37f3c96 | 2014-07-17 11:25:30 -0700 | [diff] [blame] | 584 | int64_t last = last_activity_time_ms_.LoadSequentiallyConsistent(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 585 | |
| 586 | /* initializing or in the middle of something? */ |
| 587 | if (last == 0) { |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 588 | VLOG(jdwp) << "+++ last=busy"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 589 | return 0; |
| 590 | } |
| 591 | |
| 592 | /* now get the current time */ |
Elliott Hughes | 7162ad9 | 2011-10-27 14:08:42 -0700 | [diff] [blame] | 593 | int64_t now = MilliTime(); |
Elliott Hughes | c3b3e75 | 2012-01-27 13:48:50 -0800 | [diff] [blame] | 594 | CHECK_GE(now, last); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 595 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 596 | VLOG(jdwp) << "+++ debugger interval=" << (now - last); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 597 | return now - last; |
| 598 | } |
| 599 | |
Elliott Hughes | 64f574f | 2013-02-20 14:57:12 -0800 | [diff] [blame] | 600 | void JdwpState::ExitAfterReplying(int exit_status) { |
| 601 | LOG(WARNING) << "Debugger told VM to exit with status " << exit_status; |
| 602 | should_exit_ = true; |
| 603 | exit_status_ = exit_status; |
| 604 | } |
| 605 | |
Elliott Hughes | 03181a8 | 2011-11-17 17:22:21 -0800 | [diff] [blame] | 606 | std::ostream& operator<<(std::ostream& os, const JdwpLocation& rhs) { |
Elliott Hughes | d07986f | 2011-12-06 18:27:45 -0800 | [diff] [blame] | 607 | os << "JdwpLocation[" |
Elliott Hughes | a96836a | 2013-01-17 12:27:49 -0800 | [diff] [blame] | 608 | << Dbg::GetClassName(rhs.class_id) << "." << Dbg::GetMethodName(rhs.method_id) |
Ian Rogers | d9e4e0c | 2014-01-23 20:11:40 -0800 | [diff] [blame] | 609 | << "@" << StringPrintf("%#" PRIx64, rhs.dex_pc) << " " << rhs.type_tag << "]"; |
Elliott Hughes | 03181a8 | 2011-11-17 17:22:21 -0800 | [diff] [blame] | 610 | return os; |
| 611 | } |
| 612 | |
Elliott Hughes | 2aa2e39 | 2012-02-17 17:15:43 -0800 | [diff] [blame] | 613 | bool operator==(const JdwpLocation& lhs, const JdwpLocation& rhs) { |
Elliott Hughes | 7484741 | 2012-06-20 18:10:21 -0700 | [diff] [blame] | 614 | return lhs.dex_pc == rhs.dex_pc && lhs.method_id == rhs.method_id && |
| 615 | lhs.class_id == rhs.class_id && lhs.type_tag == rhs.type_tag; |
Elliott Hughes | 2aa2e39 | 2012-02-17 17:15:43 -0800 | [diff] [blame] | 616 | } |
| 617 | |
| 618 | bool operator!=(const JdwpLocation& lhs, const JdwpLocation& rhs) { |
| 619 | return !(lhs == rhs); |
| 620 | } |
| 621 | |
Igor Murashkin | aaebaa0 | 2015-01-26 10:55:53 -0800 | [diff] [blame] | 622 | bool operator==(const JdwpOptions& lhs, const JdwpOptions& rhs) { |
| 623 | if (&lhs == &rhs) { |
| 624 | return true; |
| 625 | } |
| 626 | |
| 627 | return lhs.transport == rhs.transport && |
| 628 | lhs.server == rhs.server && |
| 629 | lhs.suspend == rhs.suspend && |
| 630 | lhs.host == rhs.host && |
| 631 | lhs.port == rhs.port; |
| 632 | } |
| 633 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 634 | } // namespace JDWP |
| 635 | |
| 636 | } // namespace art |