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