jdwp.h revision 37f3c968ecd04e77802fe17bb82dabc07de21ca1
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#ifndef ART_RUNTIME_JDWP_JDWP_H_ 18#define ART_RUNTIME_JDWP_JDWP_H_ 19 20#include "atomic.h" 21#include "base/mutex.h" 22#include "jdwp/jdwp_bits.h" 23#include "jdwp/jdwp_constants.h" 24#include "jdwp/jdwp_expand_buf.h" 25 26#include <pthread.h> 27#include <stddef.h> 28#include <stdint.h> 29#include <string.h> 30 31struct iovec; 32 33namespace art { 34 35union JValue; 36class Thread; 37 38namespace mirror { 39 class ArtMethod; 40} // namespace mirror 41 42namespace JDWP { 43 44/* 45 * Fundamental types. 46 * 47 * ObjectId and RefTypeId must be the same size. 48 */ 49typedef uint32_t FieldId; /* static or instance field */ 50typedef uint32_t MethodId; /* any kind of method, including constructors */ 51typedef uint64_t ObjectId; /* any object (threadID, stringID, arrayID, etc) */ 52typedef uint64_t RefTypeId; /* like ObjectID, but unique for Class objects */ 53typedef uint64_t FrameId; /* short-lived stack frame ID */ 54 55ObjectId ReadObjectId(const uint8_t** pBuf); 56 57static inline void SetFieldId(uint8_t* buf, FieldId val) { return Set4BE(buf, val); } 58static inline void SetMethodId(uint8_t* buf, MethodId val) { return Set4BE(buf, val); } 59static inline void SetObjectId(uint8_t* buf, ObjectId val) { return Set8BE(buf, val); } 60static inline void SetRefTypeId(uint8_t* buf, RefTypeId val) { return Set8BE(buf, val); } 61static inline void SetFrameId(uint8_t* buf, FrameId val) { return Set8BE(buf, val); } 62static inline void expandBufAddFieldId(ExpandBuf* pReply, FieldId id) { expandBufAdd4BE(pReply, id); } 63static inline void expandBufAddMethodId(ExpandBuf* pReply, MethodId id) { expandBufAdd4BE(pReply, id); } 64static inline void expandBufAddObjectId(ExpandBuf* pReply, ObjectId id) { expandBufAdd8BE(pReply, id); } 65static inline void expandBufAddRefTypeId(ExpandBuf* pReply, RefTypeId id) { expandBufAdd8BE(pReply, id); } 66static inline void expandBufAddFrameId(ExpandBuf* pReply, FrameId id) { expandBufAdd8BE(pReply, id); } 67 68/* 69 * Holds a JDWP "location". 70 */ 71struct JdwpLocation { 72 JdwpTypeTag type_tag; 73 RefTypeId class_id; 74 MethodId method_id; 75 uint64_t dex_pc; 76}; 77std::ostream& operator<<(std::ostream& os, const JdwpLocation& rhs) 78 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 79bool operator==(const JdwpLocation& lhs, const JdwpLocation& rhs); 80bool operator!=(const JdwpLocation& lhs, const JdwpLocation& rhs); 81 82/* 83 * How we talk to the debugger. 84 */ 85enum JdwpTransportType { 86 kJdwpTransportUnknown = 0, 87 kJdwpTransportSocket, // transport=dt_socket 88 kJdwpTransportAndroidAdb, // transport=dt_android_adb 89}; 90std::ostream& operator<<(std::ostream& os, const JdwpTransportType& rhs); 91 92struct JdwpOptions { 93 JdwpTransportType transport; 94 bool server; 95 bool suspend; 96 std::string host; 97 uint16_t port; 98}; 99 100struct JdwpEvent; 101class JdwpNetStateBase; 102struct ModBasket; 103class Request; 104 105/* 106 * State for JDWP functions. 107 */ 108struct JdwpState { 109 /* 110 * Perform one-time initialization. 111 * 112 * Among other things, this binds to a port to listen for a connection from 113 * the debugger. 114 * 115 * Returns a newly-allocated JdwpState struct on success, or NULL on failure. 116 */ 117 static JdwpState* Create(const JdwpOptions* options) 118 LOCKS_EXCLUDED(Locks::mutator_lock_); 119 120 ~JdwpState(); 121 122 /* 123 * Returns "true" if a debugger or DDM is connected. 124 */ 125 bool IsActive(); 126 127 /** 128 * Returns the Thread* for the JDWP daemon thread. 129 */ 130 Thread* GetDebugThread(); 131 132 /* 133 * Get time, in milliseconds, since the last debugger activity. 134 */ 135 int64_t LastDebuggerActivity(); 136 137 void ExitAfterReplying(int exit_status); 138 139 /* 140 * When we hit a debugger event that requires suspension, it's important 141 * that we wait for the thread to suspend itself before processing any 142 * additional requests. (Otherwise, if the debugger immediately sends a 143 * "resume thread" command, the resume might arrive before the thread has 144 * suspended itself.) 145 * 146 * The thread should call the "set" function before sending the event to 147 * the debugger. The main JDWP handler loop calls "get" before processing 148 * an event, and will wait for thread suspension if it's set. Once the 149 * thread has suspended itself, the JDWP handler calls "clear" and 150 * continues processing the current event. This works in the suspend-all 151 * case because the event thread doesn't suspend itself until everything 152 * else has suspended. 153 * 154 * It's possible that multiple threads could encounter thread-suspending 155 * events at the same time, so we grab a mutex in the "set" call, and 156 * release it in the "clear" call. 157 */ 158 // ObjectId GetWaitForEventThread(); 159 void SetWaitForEventThread(ObjectId threadId) 160 LOCKS_EXCLUDED(event_thread_lock_, process_request_lock_); 161 void ClearWaitForEventThread() LOCKS_EXCLUDED(event_thread_lock_); 162 163 /* 164 * These notify the debug code that something interesting has happened. This 165 * could be a thread starting or ending, an exception, or an opportunity 166 * for a breakpoint. These calls do not mean that an event the debugger 167 * is interested has happened, just that something has happened that the 168 * debugger *might* be interested in. 169 * 170 * The item of interest may trigger multiple events, some or all of which 171 * are grouped together in a single response. 172 * 173 * The event may cause the current thread or all threads (except the 174 * JDWP support thread) to be suspended. 175 */ 176 177 /* 178 * The VM has finished initializing. Only called when the debugger is 179 * connected at the time initialization completes. 180 */ 181 bool PostVMStart() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 182 183 /* 184 * A location of interest has been reached. This is used for breakpoints, 185 * single-stepping, and method entry/exit. (JDWP requires that these four 186 * events are grouped together in a single response.) 187 * 188 * In some cases "*pLoc" will just have a method and class name, e.g. when 189 * issuing a MethodEntry on a native method. 190 * 191 * "eventFlags" indicates the types of events that have occurred. 192 * 193 * "returnValue" is non-null for MethodExit events only. 194 */ 195 bool PostLocationEvent(const JdwpLocation* pLoc, ObjectId thisPtr, int eventFlags, 196 const JValue* returnValue) 197 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 198 199 /* 200 * A field of interest has been accessed or modified. This is used for field access and field 201 * modification events. 202 * 203 * "fieldValue" is non-null for field modification events only. 204 * "is_modification" is true for field modification, false for field access. 205 */ 206 bool PostFieldEvent(const JdwpLocation* pLoc, RefTypeId typeId, FieldId fieldId, 207 ObjectId thisPtr, const JValue* fieldValue, bool is_modification) 208 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 209 210 /* 211 * An exception has been thrown. 212 * 213 * Pass in a zeroed-out "*pCatchLoc" if the exception wasn't caught. 214 */ 215 bool PostException(const JdwpLocation* pThrowLoc, ObjectId excepId, RefTypeId excepClassId, 216 const JdwpLocation* pCatchLoc, ObjectId thisPtr) 217 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 218 219 /* 220 * A thread has started or stopped. 221 */ 222 bool PostThreadChange(ObjectId threadId, bool start) 223 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 224 225 /* 226 * Class has been prepared. 227 */ 228 bool PostClassPrepare(JdwpTypeTag tag, RefTypeId refTypeId, const std::string& signature, 229 int status) 230 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 231 232 /* 233 * The VM is about to stop. 234 */ 235 bool PostVMDeath(); 236 237 // Called if/when we realize we're talking to DDMS. 238 void NotifyDdmsActive() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 239 240 /* 241 * Send up a chunk of DDM data. 242 */ 243 void DdmSendChunkV(uint32_t type, const iovec* iov, int iov_count) 244 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 245 246 bool HandlePacket(); 247 248 void SendRequest(ExpandBuf* pReq); 249 250 void ResetState() 251 LOCKS_EXCLUDED(event_list_lock_) 252 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 253 254 /* atomic ops to get next serial number */ 255 uint32_t NextRequestSerial(); 256 uint32_t NextEventSerial(); 257 258 void Run() 259 LOCKS_EXCLUDED(Locks::mutator_lock_, 260 Locks::thread_suspend_count_lock_); 261 262 /* 263 * Register an event by adding it to the event list. 264 * 265 * "*pEvent" must be storage allocated with jdwpEventAlloc(). The caller 266 * may discard its pointer after calling this. 267 */ 268 JdwpError RegisterEvent(JdwpEvent* pEvent) 269 LOCKS_EXCLUDED(event_list_lock_) 270 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 271 272 /* 273 * Unregister an event, given the requestId. 274 */ 275 void UnregisterEventById(uint32_t requestId) 276 LOCKS_EXCLUDED(event_list_lock_) 277 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 278 279 /* 280 * Unregister all events. 281 */ 282 void UnregisterAll() 283 LOCKS_EXCLUDED(event_list_lock_) 284 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 285 286 private: 287 explicit JdwpState(const JdwpOptions* options); 288 size_t ProcessRequest(Request& request, ExpandBuf* pReply); 289 bool InvokeInProgress(); 290 bool IsConnected(); 291 void SuspendByPolicy(JdwpSuspendPolicy suspend_policy, JDWP::ObjectId thread_self_id) 292 LOCKS_EXCLUDED(Locks::mutator_lock_); 293 void SendRequestAndPossiblySuspend(ExpandBuf* pReq, JdwpSuspendPolicy suspend_policy, 294 ObjectId threadId) 295 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 296 void CleanupMatchList(JdwpEvent** match_list, 297 size_t match_count) 298 EXCLUSIVE_LOCKS_REQUIRED(event_list_lock_) 299 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 300 void EventFinish(ExpandBuf* pReq); 301 void FindMatchingEvents(JdwpEventKind eventKind, 302 const ModBasket& basket, 303 JdwpEvent** match_list, 304 size_t* pMatchCount) 305 EXCLUSIVE_LOCKS_REQUIRED(event_list_lock_) 306 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 307 void UnregisterEvent(JdwpEvent* pEvent) 308 EXCLUSIVE_LOCKS_REQUIRED(event_list_lock_) 309 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 310 void SendBufferedRequest(uint32_t type, const std::vector<iovec>& iov); 311 312 void StartProcessingRequest() LOCKS_EXCLUDED(process_request_lock_); 313 void EndProcessingRequest() LOCKS_EXCLUDED(process_request_lock_); 314 void WaitForProcessingRequest() LOCKS_EXCLUDED(process_request_lock_); 315 316 public: // TODO: fix privacy 317 const JdwpOptions* options_; 318 319 private: 320 /* wait for creation of the JDWP thread */ 321 Mutex thread_start_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 322 ConditionVariable thread_start_cond_ GUARDED_BY(thread_start_lock_); 323 324 pthread_t pthread_; 325 Thread* thread_; 326 327 volatile int32_t debug_thread_started_ GUARDED_BY(thread_start_lock_); 328 ObjectId debug_thread_id_; 329 330 private: 331 bool run; 332 333 public: // TODO: fix privacy 334 JdwpNetStateBase* netState; 335 336 private: 337 // For wait-for-debugger. 338 Mutex attach_lock_ ACQUIRED_AFTER(thread_start_lock_); 339 ConditionVariable attach_cond_ GUARDED_BY(attach_lock_); 340 341 // Time of last debugger activity, in milliseconds. 342 Atomic<int64_t> last_activity_time_ms_; 343 344 // Global counters and a mutex to protect them. 345 AtomicInteger request_serial_; 346 AtomicInteger event_serial_; 347 348 // Linked list of events requested by the debugger (breakpoints, class prep, etc). 349 Mutex event_list_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER ACQUIRED_BEFORE(Locks::breakpoint_lock_); 350 351 JdwpEvent* event_list_ GUARDED_BY(event_list_lock_); 352 size_t event_list_size_ GUARDED_BY(event_list_lock_); // Number of elements in event_list_. 353 354 // Used to synchronize suspension of the event thread (to avoid receiving "resume" 355 // events before the thread has finished suspending itself). 356 Mutex event_thread_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 357 ConditionVariable event_thread_cond_ GUARDED_BY(event_thread_lock_); 358 ObjectId event_thread_id_; 359 360 // Used to synchronize request processing and event sending (to avoid sending an event before 361 // sending the reply of a command being processed). 362 Mutex process_request_lock_ ACQUIRED_AFTER(event_thread_lock_); 363 ConditionVariable process_request_cond_ GUARDED_BY(process_request_lock_); 364 bool processing_request_ GUARDED_BY(process_request_lock_); 365 366 bool ddm_is_active_; 367 368 bool should_exit_; 369 int exit_status_; 370}; 371 372std::string DescribeField(const FieldId& field_id) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 373std::string DescribeMethod(const MethodId& method_id) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 374std::string DescribeRefTypeId(const RefTypeId& ref_type_id) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 375 376class Request { 377 public: 378 Request(const uint8_t* bytes, uint32_t available); 379 ~Request(); 380 381 std::string ReadUtf8String(); 382 383 // Helper function: read a variable-width value from the input buffer. 384 uint64_t ReadValue(size_t width); 385 386 int32_t ReadSigned32(const char* what); 387 388 uint32_t ReadUnsigned32(const char* what); 389 390 FieldId ReadFieldId() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 391 392 MethodId ReadMethodId() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 393 394 ObjectId ReadObjectId(const char* specific_kind); 395 396 ObjectId ReadArrayId(); 397 398 ObjectId ReadObjectId(); 399 400 ObjectId ReadThreadId(); 401 402 ObjectId ReadThreadGroupId(); 403 404 RefTypeId ReadRefTypeId() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 405 406 FrameId ReadFrameId(); 407 408 template <typename T> T ReadEnum1(const char* specific_kind) { 409 T value = static_cast<T>(Read1()); 410 VLOG(jdwp) << " " << specific_kind << " " << value; 411 return value; 412 } 413 414 JdwpTag ReadTag(); 415 416 JdwpTypeTag ReadTypeTag(); 417 418 JdwpLocation ReadLocation() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 419 420 JdwpModKind ReadModKind(); 421 422 // 423 // Return values from this JDWP packet's header. 424 // 425 size_t GetLength() { return byte_count_; } 426 uint32_t GetId() { return id_; } 427 uint8_t GetCommandSet() { return command_set_; } 428 uint8_t GetCommand() { return command_; } 429 430 // Returns the number of bytes remaining. 431 size_t size() { return end_ - p_; } 432 433 // Returns a pointer to the next byte. 434 const uint8_t* data() { return p_; } 435 436 void Skip(size_t count) { p_ += count; } 437 438 void CheckConsumed(); 439 440 private: 441 uint8_t Read1(); 442 uint16_t Read2BE(); 443 uint32_t Read4BE(); 444 uint64_t Read8BE(); 445 446 uint32_t byte_count_; 447 uint32_t id_; 448 uint8_t command_set_; 449 uint8_t command_; 450 451 const uint8_t* p_; 452 const uint8_t* end_; 453 454 DISALLOW_COPY_AND_ASSIGN(Request); 455}; 456 457} // namespace JDWP 458 459} // namespace art 460 461#endif // ART_RUNTIME_JDWP_JDWP_H_ 462