blob: 8fd07cc11b02af598661acdfec1b42e636f9bfbe [file] [log] [blame]
* Copyright (C) 2008 The Android Open Source Project
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* See the License for the specific language governing permissions and
* limitations under the License.
#include "atomic.h"
#include "base/mutex.h"
#include "jdwp/jdwp_bits.h"
#include "jdwp/jdwp_constants.h"
#include "jdwp/jdwp_expand_buf.h"
#include <pthread.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
struct iovec;
namespace art {
union JValue;
class Thread;
namespace mirror {
class ArtMethod;
} // namespace mirror
namespace JDWP {
* Fundamental types.
* ObjectId and RefTypeId must be the same size.
typedef uint32_t FieldId; /* static or instance field */
typedef uint32_t MethodId; /* any kind of method, including constructors */
typedef uint64_t ObjectId; /* any object (threadID, stringID, arrayID, etc) */
typedef uint64_t RefTypeId; /* like ObjectID, but unique for Class objects */
typedef uint64_t FrameId; /* short-lived stack frame ID */
ObjectId ReadObjectId(const uint8_t** pBuf);
static inline void SetFieldId(uint8_t* buf, FieldId val) { return Set4BE(buf, val); }
static inline void SetMethodId(uint8_t* buf, MethodId val) { return Set4BE(buf, val); }
static inline void SetObjectId(uint8_t* buf, ObjectId val) { return Set8BE(buf, val); }
static inline void SetRefTypeId(uint8_t* buf, RefTypeId val) { return Set8BE(buf, val); }
static inline void SetFrameId(uint8_t* buf, FrameId val) { return Set8BE(buf, val); }
static inline void expandBufAddFieldId(ExpandBuf* pReply, FieldId id) { expandBufAdd4BE(pReply, id); }
static inline void expandBufAddMethodId(ExpandBuf* pReply, MethodId id) { expandBufAdd4BE(pReply, id); }
static inline void expandBufAddObjectId(ExpandBuf* pReply, ObjectId id) { expandBufAdd8BE(pReply, id); }
static inline void expandBufAddRefTypeId(ExpandBuf* pReply, RefTypeId id) { expandBufAdd8BE(pReply, id); }
static inline void expandBufAddFrameId(ExpandBuf* pReply, FrameId id) { expandBufAdd8BE(pReply, id); }
* Holds a JDWP "location".
struct JdwpLocation {
JdwpTypeTag type_tag;
RefTypeId class_id;
MethodId method_id;
uint64_t dex_pc;
std::ostream& operator<<(std::ostream& os, const JdwpLocation& rhs)
bool operator==(const JdwpLocation& lhs, const JdwpLocation& rhs);
bool operator!=(const JdwpLocation& lhs, const JdwpLocation& rhs);
* How we talk to the debugger.
enum JdwpTransportType {
kJdwpTransportUnknown = 0,
kJdwpTransportSocket, // transport=dt_socket
kJdwpTransportAndroidAdb, // transport=dt_android_adb
std::ostream& operator<<(std::ostream& os, const JdwpTransportType& rhs);
struct JdwpOptions {
JdwpTransportType transport;
bool server;
bool suspend;
std::string host;
uint16_t port;
struct JdwpEvent;
class JdwpNetStateBase;
struct ModBasket;
class Request;
* State for JDWP functions.
struct JdwpState {
* Perform one-time initialization.
* Among other things, this binds to a port to listen for a connection from
* the debugger.
* Returns a newly-allocated JdwpState struct on success, or NULL on failure.
static JdwpState* Create(const JdwpOptions* options)
* Returns "true" if a debugger or DDM is connected.
bool IsActive();
* Returns the Thread* for the JDWP daemon thread.
Thread* GetDebugThread();
* Get time, in milliseconds, since the last debugger activity.
int64_t LastDebuggerActivity();
void ExitAfterReplying(int exit_status);
* When we hit a debugger event that requires suspension, it's important
* that we wait for the thread to suspend itself before processing any
* additional requests. (Otherwise, if the debugger immediately sends a
* "resume thread" command, the resume might arrive before the thread has
* suspended itself.)
* The thread should call the "set" function before sending the event to
* the debugger. The main JDWP handler loop calls "get" before processing
* an event, and will wait for thread suspension if it's set. Once the
* thread has suspended itself, the JDWP handler calls "clear" and
* continues processing the current event. This works in the suspend-all
* case because the event thread doesn't suspend itself until everything
* else has suspended.
* It's possible that multiple threads could encounter thread-suspending
* events at the same time, so we grab a mutex in the "set" call, and
* release it in the "clear" call.
// ObjectId GetWaitForEventThread();
void SetWaitForEventThread(ObjectId threadId)
LOCKS_EXCLUDED(event_thread_lock_, process_request_lock_);
void ClearWaitForEventThread() LOCKS_EXCLUDED(event_thread_lock_);
* These notify the debug code that something interesting has happened. This
* could be a thread starting or ending, an exception, or an opportunity
* for a breakpoint. These calls do not mean that an event the debugger
* is interested has happened, just that something has happened that the
* debugger *might* be interested in.
* The item of interest may trigger multiple events, some or all of which
* are grouped together in a single response.
* The event may cause the current thread or all threads (except the
* JDWP support thread) to be suspended.
* The VM has finished initializing. Only called when the debugger is
* connected at the time initialization completes.
bool PostVMStart() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
* A location of interest has been reached. This is used for breakpoints,
* single-stepping, and method entry/exit. (JDWP requires that these four
* events are grouped together in a single response.)
* In some cases "*pLoc" will just have a method and class name, e.g. when
* issuing a MethodEntry on a native method.
* "eventFlags" indicates the types of events that have occurred.
* "returnValue" is non-null for MethodExit events only.
bool PostLocationEvent(const JdwpLocation* pLoc, ObjectId thisPtr, int eventFlags,
const JValue* returnValue)
* A field of interest has been accessed or modified. This is used for field access and field
* modification events.
* "fieldValue" is non-null for field modification events only.
* "is_modification" is true for field modification, false for field access.
bool PostFieldEvent(const JdwpLocation* pLoc, RefTypeId typeId, FieldId fieldId,
ObjectId thisPtr, const JValue* fieldValue, bool is_modification)
* An exception has been thrown.
* Pass in a zeroed-out "*pCatchLoc" if the exception wasn't caught.
bool PostException(const JdwpLocation* pThrowLoc, ObjectId excepId, RefTypeId excepClassId,
const JdwpLocation* pCatchLoc, ObjectId thisPtr)
* A thread has started or stopped.
bool PostThreadChange(ObjectId threadId, bool start)
* Class has been prepared.
bool PostClassPrepare(JdwpTypeTag tag, RefTypeId refTypeId, const std::string& signature,
int status)
* The VM is about to stop.
bool PostVMDeath();
// Called if/when we realize we're talking to DDMS.
void NotifyDdmsActive() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
* Send up a chunk of DDM data.
void DdmSendChunkV(uint32_t type, const iovec* iov, int iov_count)
bool HandlePacket();
void SendRequest(ExpandBuf* pReq);
void ResetState()
/* atomic ops to get next serial number */
uint32_t NextRequestSerial();
uint32_t NextEventSerial();
void Run()
* Register an event by adding it to the event list.
* "*pEvent" must be storage allocated with jdwpEventAlloc(). The caller
* may discard its pointer after calling this.
JdwpError RegisterEvent(JdwpEvent* pEvent)
* Unregister an event, given the requestId.
void UnregisterEventById(uint32_t requestId)
* Unregister all events.
void UnregisterAll()
explicit JdwpState(const JdwpOptions* options);
size_t ProcessRequest(Request& request, ExpandBuf* pReply);
bool InvokeInProgress();
bool IsConnected();
void SuspendByPolicy(JdwpSuspendPolicy suspend_policy, JDWP::ObjectId thread_self_id)
void SendRequestAndPossiblySuspend(ExpandBuf* pReq, JdwpSuspendPolicy suspend_policy,
ObjectId threadId)
void CleanupMatchList(JdwpEvent** match_list,
size_t match_count)
void EventFinish(ExpandBuf* pReq);
void FindMatchingEvents(JdwpEventKind eventKind,
const ModBasket& basket,
JdwpEvent** match_list,
size_t* pMatchCount)
void UnregisterEvent(JdwpEvent* pEvent)
void SendBufferedRequest(uint32_t type, const std::vector<iovec>& iov);
void StartProcessingRequest() LOCKS_EXCLUDED(process_request_lock_);
void EndProcessingRequest() LOCKS_EXCLUDED(process_request_lock_);
void WaitForProcessingRequest() LOCKS_EXCLUDED(process_request_lock_);
public: // TODO: fix privacy
const JdwpOptions* options_;
/* wait for creation of the JDWP thread */
Mutex thread_start_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
ConditionVariable thread_start_cond_ GUARDED_BY(thread_start_lock_);
pthread_t pthread_;
Thread* thread_;
volatile int32_t debug_thread_started_ GUARDED_BY(thread_start_lock_);
ObjectId debug_thread_id_;
bool run;
public: // TODO: fix privacy
JdwpNetStateBase* netState;
// For wait-for-debugger.
Mutex attach_lock_ ACQUIRED_AFTER(thread_start_lock_);
ConditionVariable attach_cond_ GUARDED_BY(attach_lock_);
// Time of last debugger activity, in milliseconds.
Atomic<int64_t> last_activity_time_ms_;
// Global counters and a mutex to protect them.
AtomicInteger request_serial_;
AtomicInteger event_serial_;
// Linked list of events requested by the debugger (breakpoints, class prep, etc).
Mutex event_list_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER ACQUIRED_BEFORE(Locks::breakpoint_lock_);
JdwpEvent* event_list_ GUARDED_BY(event_list_lock_);
size_t event_list_size_ GUARDED_BY(event_list_lock_); // Number of elements in event_list_.
// Used to synchronize suspension of the event thread (to avoid receiving "resume"
// events before the thread has finished suspending itself).
Mutex event_thread_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
ConditionVariable event_thread_cond_ GUARDED_BY(event_thread_lock_);
ObjectId event_thread_id_;
// Used to synchronize request processing and event sending (to avoid sending an event before
// sending the reply of a command being processed).
Mutex process_request_lock_ ACQUIRED_AFTER(event_thread_lock_);
ConditionVariable process_request_cond_ GUARDED_BY(process_request_lock_);
bool processing_request_ GUARDED_BY(process_request_lock_);
bool ddm_is_active_;
bool should_exit_;
int exit_status_;
std::string DescribeField(const FieldId& field_id) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
std::string DescribeMethod(const MethodId& method_id) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
std::string DescribeRefTypeId(const RefTypeId& ref_type_id) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
class Request {
Request(const uint8_t* bytes, uint32_t available);
std::string ReadUtf8String();
// Helper function: read a variable-width value from the input buffer.
uint64_t ReadValue(size_t width);
int32_t ReadSigned32(const char* what);
uint32_t ReadUnsigned32(const char* what);
FieldId ReadFieldId() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
MethodId ReadMethodId() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
ObjectId ReadObjectId(const char* specific_kind);
ObjectId ReadArrayId();
ObjectId ReadObjectId();
ObjectId ReadThreadId();
ObjectId ReadThreadGroupId();
RefTypeId ReadRefTypeId() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
FrameId ReadFrameId();
template <typename T> T ReadEnum1(const char* specific_kind) {
T value = static_cast<T>(Read1());
VLOG(jdwp) << " " << specific_kind << " " << value;
return value;
JdwpTag ReadTag();
JdwpTypeTag ReadTypeTag();
JdwpLocation ReadLocation() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
JdwpModKind ReadModKind();
// Return values from this JDWP packet's header.
size_t GetLength() { return byte_count_; }
uint32_t GetId() { return id_; }
uint8_t GetCommandSet() { return command_set_; }
uint8_t GetCommand() { return command_; }
// Returns the number of bytes remaining.
size_t size() { return end_ - p_; }
// Returns a pointer to the next byte.
const uint8_t* data() { return p_; }
void Skip(size_t count) { p_ += count; }
void CheckConsumed();
uint8_t Read1();
uint16_t Read2BE();
uint32_t Read4BE();
uint64_t Read8BE();
uint32_t byte_count_;
uint32_t id_;
uint8_t command_set_;
uint8_t command_;
const uint8_t* p_;
const uint8_t* end_;
} // namespace JDWP
} // namespace art