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 | |
| 17 | #ifndef ART_JDWP_JDWP_H_ |
| 18 | #define ART_JDWP_JDWP_H_ |
| 19 | |
| 20 | #include "jdwp/jdwp_bits.h" |
| 21 | #include "jdwp/jdwp_constants.h" |
| 22 | #include "jdwp/jdwp_expand_buf.h" |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 23 | #include "../mutex.h" // TODO: fix our include path! |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 24 | |
| 25 | #include <pthread.h> |
| 26 | #include <stddef.h> |
| 27 | #include <stdint.h> |
| 28 | #include <string.h> |
| 29 | |
| 30 | struct iovec; |
| 31 | |
| 32 | namespace art { |
| 33 | |
Elliott Hughes | d07986f | 2011-12-06 18:27:45 -0800 | [diff] [blame] | 34 | struct Method; |
Elliott Hughes | 475fc23 | 2011-10-25 15:00:35 -0700 | [diff] [blame] | 35 | struct Thread; |
| 36 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 37 | namespace JDWP { |
| 38 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 39 | /* |
| 40 | * Fundamental types. |
| 41 | * |
| 42 | * ObjectId and RefTypeId must be the same size. |
| 43 | */ |
| 44 | typedef uint32_t FieldId; /* static or instance field */ |
| 45 | typedef uint32_t MethodId; /* any kind of method, including constructors */ |
| 46 | typedef uint64_t ObjectId; /* any object (threadID, stringID, arrayID, etc) */ |
| 47 | typedef uint64_t RefTypeId; /* like ObjectID, but unique for Class objects */ |
| 48 | typedef uint64_t FrameId; /* short-lived stack frame ID */ |
| 49 | |
| 50 | /* |
| 51 | * Match these with the type sizes. This way we don't have to pass |
| 52 | * a value and a length. |
| 53 | */ |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 54 | static inline FieldId ReadFieldId(const uint8_t** pBuf) { return Read4BE(pBuf); } |
| 55 | static inline MethodId ReadMethodId(const uint8_t** pBuf) { return Read4BE(pBuf); } |
| 56 | static inline ObjectId ReadObjectId(const uint8_t** pBuf) { return Read8BE(pBuf); } |
| 57 | static inline RefTypeId ReadRefTypeId(const uint8_t** pBuf) { return Read8BE(pBuf); } |
| 58 | static inline FrameId ReadFrameId(const uint8_t** pBuf) { return Read8BE(pBuf); } |
Elliott Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 59 | static inline JdwpTag ReadTag(const uint8_t** pBuf) { return static_cast<JdwpTag>(Read1(pBuf)); } |
Elliott Hughes | d07986f | 2011-12-06 18:27:45 -0800 | [diff] [blame] | 60 | static inline JdwpTypeTag ReadTypeTag(const uint8_t** pBuf) { return static_cast<JdwpTypeTag>(Read1(pBuf)); } |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 61 | static inline void SetFieldId(uint8_t* buf, FieldId val) { return Set4BE(buf, val); } |
| 62 | static inline void SetMethodId(uint8_t* buf, MethodId val) { return Set4BE(buf, val); } |
| 63 | static inline void SetObjectId(uint8_t* buf, ObjectId val) { return Set8BE(buf, val); } |
| 64 | static inline void SetRefTypeId(uint8_t* buf, RefTypeId val) { return Set8BE(buf, val); } |
| 65 | static inline void SetFrameId(uint8_t* buf, FrameId val) { return Set8BE(buf, val); } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 66 | static inline void expandBufAddFieldId(ExpandBuf* pReply, FieldId id) { expandBufAdd4BE(pReply, id); } |
| 67 | static inline void expandBufAddMethodId(ExpandBuf* pReply, MethodId id) { expandBufAdd4BE(pReply, id); } |
| 68 | static inline void expandBufAddObjectId(ExpandBuf* pReply, ObjectId id) { expandBufAdd8BE(pReply, id); } |
| 69 | static inline void expandBufAddRefTypeId(ExpandBuf* pReply, RefTypeId id) { expandBufAdd8BE(pReply, id); } |
| 70 | static inline void expandBufAddFrameId(ExpandBuf* pReply, FrameId id) { expandBufAdd8BE(pReply, id); } |
| 71 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 72 | /* |
| 73 | * Holds a JDWP "location". |
| 74 | */ |
| 75 | struct JdwpLocation { |
Elliott Hughes | d07986f | 2011-12-06 18:27:45 -0800 | [diff] [blame] | 76 | JdwpTypeTag typeTag; |
| 77 | RefTypeId classId; |
| 78 | MethodId methodId; |
Elliott Hughes | 972a47b | 2012-02-21 18:16:06 -0800 | [diff] [blame] | 79 | uint64_t dex_pc; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 80 | }; |
Elliott Hughes | 03181a8 | 2011-11-17 17:22:21 -0800 | [diff] [blame] | 81 | std::ostream& operator<<(std::ostream& os, const JdwpLocation& rhs); |
Elliott Hughes | 2aa2e39 | 2012-02-17 17:15:43 -0800 | [diff] [blame] | 82 | bool operator==(const JdwpLocation& lhs, const JdwpLocation& rhs); |
| 83 | bool operator!=(const JdwpLocation& lhs, const JdwpLocation& rhs); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 84 | |
| 85 | /* |
| 86 | * How we talk to the debugger. |
| 87 | */ |
| 88 | enum JdwpTransportType { |
| 89 | kJdwpTransportUnknown = 0, |
| 90 | kJdwpTransportSocket, /* transport=dt_socket */ |
| 91 | kJdwpTransportAndroidAdb, /* transport=dt_android_adb */ |
| 92 | }; |
| 93 | std::ostream& operator<<(std::ostream& os, const JdwpTransportType& rhs); |
| 94 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 95 | struct JdwpOptions { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 96 | JdwpTransportType transport; |
| 97 | bool server; |
| 98 | bool suspend; |
Elliott Hughes | d1cc836 | 2011-10-24 16:58:50 -0700 | [diff] [blame] | 99 | std::string host; |
Elliott Hughes | 6d8dd47 | 2012-01-17 18:27:41 -0800 | [diff] [blame] | 100 | uint16_t port; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 101 | }; |
| 102 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 103 | struct JdwpEvent; |
| 104 | struct JdwpNetState; |
| 105 | struct JdwpReqHeader; |
| 106 | struct JdwpTransport; |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 107 | struct ModBasket; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 108 | |
| 109 | /* |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 110 | * State for JDWP functions. |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 111 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 112 | struct JdwpState { |
| 113 | /* |
| 114 | * Perform one-time initialization. |
| 115 | * |
| 116 | * Among other things, this binds to a port to listen for a connection from |
| 117 | * the debugger. |
| 118 | * |
| 119 | * Returns a newly-allocated JdwpState struct on success, or NULL on failure. |
| 120 | */ |
| 121 | static JdwpState* Create(const JdwpOptions* options); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 122 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 123 | ~JdwpState(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 124 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 125 | /* |
| 126 | * Returns "true" if a debugger or DDM is connected. |
| 127 | */ |
| 128 | bool IsActive(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 129 | |
Elliott Hughes | 475fc23 | 2011-10-25 15:00:35 -0700 | [diff] [blame] | 130 | /** |
| 131 | * Returns the Thread* for the JDWP daemon thread. |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 132 | */ |
Elliott Hughes | 475fc23 | 2011-10-25 15:00:35 -0700 | [diff] [blame] | 133 | Thread* GetDebugThread(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 134 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 135 | /* |
| 136 | * Get time, in milliseconds, since the last debugger activity. |
| 137 | */ |
| 138 | int64_t LastDebuggerActivity(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 139 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 140 | /* |
| 141 | * When we hit a debugger event that requires suspension, it's important |
| 142 | * that we wait for the thread to suspend itself before processing any |
| 143 | * additional requests. (Otherwise, if the debugger immediately sends a |
| 144 | * "resume thread" command, the resume might arrive before the thread has |
| 145 | * suspended itself.) |
| 146 | * |
| 147 | * The thread should call the "set" function before sending the event to |
| 148 | * the debugger. The main JDWP handler loop calls "get" before processing |
| 149 | * an event, and will wait for thread suspension if it's set. Once the |
| 150 | * thread has suspended itself, the JDWP handler calls "clear" and |
| 151 | * continues processing the current event. This works in the suspend-all |
| 152 | * case because the event thread doesn't suspend itself until everything |
| 153 | * else has suspended. |
| 154 | * |
| 155 | * It's possible that multiple threads could encounter thread-suspending |
| 156 | * events at the same time, so we grab a mutex in the "set" call, and |
| 157 | * release it in the "clear" call. |
| 158 | */ |
| 159 | //ObjectId GetWaitForEventThread(); |
| 160 | void SetWaitForEventThread(ObjectId threadId); |
| 161 | void ClearWaitForEventThread(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 162 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 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 | */ |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 176 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 177 | /* |
| 178 | * The VM has finished initializing. Only called when the debugger is |
| 179 | * connected at the time initialization completes. |
| 180 | */ |
| 181 | bool PostVMStart(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 182 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 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 | bool PostLocationEvent(const JdwpLocation* pLoc, ObjectId thisPtr, int eventFlags); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 194 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 195 | /* |
| 196 | * An exception has been thrown. |
| 197 | * |
| 198 | * Pass in a zeroed-out "*pCatchLoc" if the exception wasn't caught. |
| 199 | */ |
| 200 | bool PostException(const JdwpLocation* pThrowLoc, ObjectId excepId, RefTypeId excepClassId, const JdwpLocation* pCatchLoc, ObjectId thisPtr); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 201 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 202 | /* |
| 203 | * A thread has started or stopped. |
| 204 | */ |
| 205 | bool PostThreadChange(ObjectId threadId, bool start); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 206 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 207 | /* |
| 208 | * Class has been prepared. |
| 209 | */ |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 210 | bool PostClassPrepare(JdwpTypeTag tag, RefTypeId refTypeId, const std::string& signature, int status); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 211 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 212 | /* |
| 213 | * The VM is about to stop. |
| 214 | */ |
| 215 | bool PostVMDeath(); |
| 216 | |
| 217 | /* |
| 218 | * Send up a chunk of DDM data. |
| 219 | */ |
Elliott Hughes | cccd84f | 2011-12-05 16:51:54 -0800 | [diff] [blame] | 220 | void DdmSendChunkV(uint32_t type, const iovec* iov, int iov_count); |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 221 | |
| 222 | /* |
| 223 | * Process a request from the debugger. |
| 224 | * |
| 225 | * "buf" points past the header, to the content of the message. "dataLen" |
| 226 | * can therefore be zero. |
| 227 | */ |
| 228 | void ProcessRequest(const JdwpReqHeader* pHeader, const uint8_t* buf, int dataLen, ExpandBuf* pReply); |
| 229 | |
| 230 | /* |
| 231 | * Send an event, formatted into "pReq", to the debugger. |
| 232 | * |
| 233 | * (Messages are sent asynchronously, and do not receive a reply.) |
| 234 | */ |
| 235 | bool SendRequest(ExpandBuf* pReq); |
| 236 | |
| 237 | void ResetState(); |
| 238 | |
| 239 | /* atomic ops to get next serial number */ |
| 240 | uint32_t NextRequestSerial(); |
| 241 | uint32_t NextEventSerial(); |
| 242 | |
| 243 | void Run(); |
| 244 | |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 245 | /* |
| 246 | * Register an event by adding it to the event list. |
| 247 | * |
| 248 | * "*pEvent" must be storage allocated with jdwpEventAlloc(). The caller |
| 249 | * may discard its pointer after calling this. |
| 250 | */ |
| 251 | JdwpError RegisterEvent(JdwpEvent* pEvent); |
| 252 | |
| 253 | /* |
| 254 | * Unregister an event, given the requestId. |
| 255 | */ |
| 256 | void UnregisterEventById(uint32_t requestId); |
| 257 | |
| 258 | /* |
| 259 | * Unregister all events. |
| 260 | */ |
| 261 | void UnregisterAll(); |
| 262 | |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 263 | private: |
Elliott Hughes | ba8eee1 | 2012-01-24 20:25:24 -0800 | [diff] [blame] | 264 | explicit JdwpState(const JdwpOptions* options); |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 265 | bool InvokeInProgress(); |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 266 | bool IsConnected(); |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 267 | void SuspendByPolicy(JdwpSuspendPolicy suspendPolicy); |
| 268 | void CleanupMatchList(JdwpEvent** matchList, int matchCount); |
| 269 | void EventFinish(ExpandBuf* pReq); |
| 270 | void FindMatchingEvents(JdwpEventKind eventKind, ModBasket* basket, JdwpEvent** matchList, int* pMatchCount); |
| 271 | void UnregisterEvent(JdwpEvent* pEvent); |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 272 | |
| 273 | public: // TODO: fix privacy |
| 274 | const JdwpOptions* options_; |
| 275 | private: |
| 276 | |
| 277 | /* wait for creation of the JDWP thread */ |
| 278 | Mutex thread_start_lock_; |
| 279 | ConditionVariable thread_start_cond_; |
| 280 | |
| 281 | volatile int32_t debug_thread_started_; |
Elliott Hughes | 475fc23 | 2011-10-25 15:00:35 -0700 | [diff] [blame] | 282 | pthread_t pthread_; |
| 283 | Thread* thread_; |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 284 | public: // TODO: fix privacy |
| 285 | ObjectId debugThreadId; |
| 286 | private: |
| 287 | bool run; |
| 288 | |
| 289 | const JdwpTransport* transport; |
| 290 | public: // TODO: fix privacy |
| 291 | JdwpNetState* netState; |
| 292 | private: |
| 293 | |
| 294 | /* for wait-for-debugger */ |
| 295 | Mutex attach_lock_; |
| 296 | ConditionVariable attach_cond_; |
| 297 | |
| 298 | /* time of last debugger activity, in milliseconds */ |
| 299 | int64_t lastActivityWhen; |
| 300 | |
| 301 | /* global counters and a mutex to protect them */ |
| 302 | uint32_t requestSerial; |
| 303 | uint32_t eventSerial; |
| 304 | Mutex serial_lock_; |
| 305 | |
| 306 | /* |
| 307 | * Events requested by the debugger (breakpoints, class prep, etc). |
| 308 | */ |
| 309 | public: // TODO: fix privacy |
| 310 | int numEvents; /* #of elements in eventList */ |
| 311 | JdwpEvent* eventList; /* linked list of events */ |
| 312 | Mutex event_lock_; /* guards numEvents/eventList */ |
| 313 | private: |
| 314 | |
| 315 | /* |
| 316 | * Synchronize suspension of event thread (to avoid receiving "resume" |
| 317 | * events before the thread has finished suspending itself). |
| 318 | */ |
| 319 | Mutex event_thread_lock_; |
| 320 | ConditionVariable event_thread_cond_; |
| 321 | ObjectId eventThreadId; |
| 322 | |
| 323 | /* |
| 324 | * DDM support. |
| 325 | */ |
| 326 | public: // TODO: fix privacy |
| 327 | bool ddmActive; |
| 328 | private: |
| 329 | }; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 330 | |
| 331 | } // namespace JDWP |
| 332 | |
| 333 | } // namespace art |
| 334 | |
| 335 | #endif // ART_JDWP_JDWP_H_ |