2d6a9ec935
This finally removes the use of the Mutex and Condition classes. This is an
intricate patch as the Mutex and Condition classes were tied together.
Furthermore, many places had slightly differing uses of time values. Convert
timeout values to relative everywhere to permit the use of
std::chrono::duration, which is required for the use of
std::condition_variable's timeout. Adjust all Condition and related Mutex
classes over to std::{,recursive_}mutex and std::condition_variable.
This change primarily comes at the cost of breaking the TracingMutex which was
based around the Mutex class. It would be possible to write a wrapper to
provide similar functionality, but that is beyond the scope of this change.
llvm-svn: 277011
348 lines
9.5 KiB
C++
348 lines
9.5 KiB
C++
//===-- CommunicationKDP.h --------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef liblldb_CommunicationKDP_h_
|
|
#define liblldb_CommunicationKDP_h_
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
#include <list>
|
|
#include <mutex>
|
|
#include <string>
|
|
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/lldb-private.h"
|
|
#include "lldb/Core/Communication.h"
|
|
#include "lldb/Core/Listener.h"
|
|
#include "lldb/Core/StreamBuffer.h"
|
|
#include "lldb/Host/Predicate.h"
|
|
#include "lldb/Host/TimeValue.h"
|
|
|
|
class CommunicationKDP : public lldb_private::Communication
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
eBroadcastBitRunPacketSent = kLoUserBroadcastBit
|
|
};
|
|
|
|
const static uint32_t kMaxPacketSize = 1200;
|
|
const static uint32_t kMaxDataSize = 1024;
|
|
typedef lldb_private::StreamBuffer<1024> PacketStreamType;
|
|
typedef enum
|
|
{
|
|
KDP_CONNECT = 0u,
|
|
KDP_DISCONNECT,
|
|
KDP_HOSTINFO,
|
|
KDP_VERSION,
|
|
KDP_MAXBYTES,
|
|
KDP_READMEM,
|
|
KDP_WRITEMEM,
|
|
KDP_READREGS,
|
|
KDP_WRITEREGS,
|
|
KDP_LOAD,
|
|
KDP_IMAGEPATH,
|
|
KDP_SUSPEND,
|
|
KDP_RESUMECPUS,
|
|
KDP_EXCEPTION,
|
|
KDP_TERMINATION,
|
|
KDP_BREAKPOINT_SET,
|
|
KDP_BREAKPOINT_REMOVE,
|
|
KDP_REGIONS,
|
|
KDP_REATTACH,
|
|
KDP_HOSTREBOOT,
|
|
KDP_READMEM64,
|
|
KDP_WRITEMEM64,
|
|
KDP_BREAKPOINT_SET64,
|
|
KDP_BREAKPOINT_REMOVE64,
|
|
KDP_KERNELVERSION,
|
|
KDP_READPHYSMEM64,
|
|
KDP_WRITEPHYSMEM64,
|
|
KDP_READIOPORT,
|
|
KDP_WRITEIOPORT,
|
|
KDP_READMSR64,
|
|
KDP_WRITEMSR64,
|
|
KDP_DUMPINFO
|
|
} CommandType;
|
|
|
|
enum
|
|
{
|
|
KDP_FEATURE_BP = (1u << 0)
|
|
};
|
|
|
|
typedef enum
|
|
{
|
|
KDP_PROTERR_SUCCESS = 0,
|
|
KDP_PROTERR_ALREADY_CONNECTED,
|
|
KDP_PROTERR_BAD_NBYTES,
|
|
KDP_PROTERR_BADFLAVOR
|
|
} KDPError;
|
|
|
|
typedef enum
|
|
{
|
|
ePacketTypeRequest = 0x00u,
|
|
ePacketTypeReply = 0x80u,
|
|
ePacketTypeMask = 0x80u,
|
|
eCommandTypeMask = 0x7fu
|
|
} PacketType;
|
|
//------------------------------------------------------------------
|
|
// Constructors and Destructors
|
|
//------------------------------------------------------------------
|
|
CommunicationKDP (const char *comm_name);
|
|
|
|
virtual
|
|
~CommunicationKDP();
|
|
|
|
bool
|
|
SendRequestPacket (const PacketStreamType &request_packet);
|
|
|
|
// Wait for a packet within 'nsec' seconds
|
|
size_t
|
|
WaitForPacketWithTimeoutMicroSeconds (lldb_private::DataExtractor &response,
|
|
uint32_t usec);
|
|
|
|
bool
|
|
GetSequenceMutex(std::unique_lock<std::recursive_mutex> &lock);
|
|
|
|
bool
|
|
CheckForPacket (const uint8_t *src,
|
|
size_t src_len,
|
|
lldb_private::DataExtractor &packet);
|
|
bool
|
|
IsRunning() const
|
|
{
|
|
return m_is_running.GetValue();
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Set the global packet timeout.
|
|
//
|
|
// For clients, this is the timeout that gets used when sending
|
|
// packets and waiting for responses. For servers, this might not
|
|
// get used, and if it doesn't this should be moved to the
|
|
// CommunicationKDPClient.
|
|
//------------------------------------------------------------------
|
|
uint32_t
|
|
SetPacketTimeout (uint32_t packet_timeout)
|
|
{
|
|
const uint32_t old_packet_timeout = m_packet_timeout;
|
|
m_packet_timeout = packet_timeout;
|
|
return old_packet_timeout;
|
|
}
|
|
|
|
uint32_t
|
|
GetPacketTimeoutInMicroSeconds () const
|
|
{
|
|
return m_packet_timeout * lldb_private::TimeValue::MicroSecPerSec;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Public Request Packets
|
|
//------------------------------------------------------------------
|
|
bool
|
|
SendRequestConnect (uint16_t reply_port,
|
|
uint16_t exc_port,
|
|
const char *greeting);
|
|
|
|
bool
|
|
SendRequestReattach (uint16_t reply_port);
|
|
|
|
bool
|
|
SendRequestDisconnect ();
|
|
|
|
uint32_t
|
|
SendRequestReadMemory (lldb::addr_t addr,
|
|
void *dst,
|
|
uint32_t dst_size,
|
|
lldb_private::Error &error);
|
|
|
|
uint32_t
|
|
SendRequestWriteMemory (lldb::addr_t addr,
|
|
const void *src,
|
|
uint32_t src_len,
|
|
lldb_private::Error &error);
|
|
|
|
bool
|
|
SendRawRequest (uint8_t command_byte,
|
|
const void *src,
|
|
uint32_t src_len,
|
|
lldb_private::DataExtractor &reply,
|
|
lldb_private::Error &error);
|
|
|
|
uint32_t
|
|
SendRequestReadRegisters (uint32_t cpu,
|
|
uint32_t flavor,
|
|
void *dst,
|
|
uint32_t dst_size,
|
|
lldb_private::Error &error);
|
|
|
|
uint32_t
|
|
SendRequestWriteRegisters (uint32_t cpu,
|
|
uint32_t flavor,
|
|
const void *src,
|
|
uint32_t src_size,
|
|
lldb_private::Error &error);
|
|
|
|
const char *
|
|
GetKernelVersion ();
|
|
|
|
// Disable KDP_IMAGEPATH for now, it seems to hang the KDP connection...
|
|
// const char *
|
|
// GetImagePath ();
|
|
|
|
uint32_t
|
|
GetVersion ();
|
|
|
|
uint32_t
|
|
GetFeatureFlags ();
|
|
|
|
bool
|
|
LocalBreakpointsAreSupported ()
|
|
{
|
|
return (GetFeatureFlags() & KDP_FEATURE_BP) != 0;
|
|
}
|
|
|
|
uint32_t
|
|
GetCPUMask ();
|
|
|
|
uint32_t
|
|
GetCPUType ();
|
|
|
|
uint32_t
|
|
GetCPUSubtype ();
|
|
|
|
lldb_private::UUID
|
|
GetUUID ();
|
|
|
|
bool
|
|
RemoteIsEFI ();
|
|
|
|
bool
|
|
RemoteIsDarwinKernel ();
|
|
|
|
lldb::addr_t
|
|
GetLoadAddress ();
|
|
|
|
bool
|
|
SendRequestResume ();
|
|
|
|
bool
|
|
SendRequestSuspend ();
|
|
|
|
bool
|
|
SendRequestBreakpoint (bool set, lldb::addr_t addr);
|
|
|
|
protected:
|
|
|
|
bool
|
|
SendRequestPacketNoLock (const PacketStreamType &request_packet);
|
|
|
|
size_t
|
|
WaitForPacketWithTimeoutMicroSecondsNoLock (lldb_private::DataExtractor &response,
|
|
uint32_t timeout_usec);
|
|
|
|
bool
|
|
WaitForNotRunningPrivate(const std::chrono::microseconds &timeout);
|
|
|
|
void
|
|
MakeRequestPacketHeader (CommandType request_type,
|
|
PacketStreamType &request_packet,
|
|
uint16_t request_length);
|
|
|
|
//------------------------------------------------------------------
|
|
// Protected Request Packets (use public accessors which will cache
|
|
// results.
|
|
//------------------------------------------------------------------
|
|
bool
|
|
SendRequestVersion ();
|
|
|
|
bool
|
|
SendRequestHostInfo ();
|
|
|
|
bool
|
|
SendRequestKernelVersion ();
|
|
|
|
// Disable KDP_IMAGEPATH for now, it seems to hang the KDP connection...
|
|
//bool
|
|
//SendRequestImagePath ();
|
|
|
|
void
|
|
DumpPacket (lldb_private::Stream &s,
|
|
const void *data,
|
|
uint32_t data_len);
|
|
|
|
void
|
|
DumpPacket (lldb_private::Stream &s,
|
|
const lldb_private::DataExtractor& extractor);
|
|
|
|
bool
|
|
VersionIsValid() const
|
|
{
|
|
return m_kdp_version_version != 0;
|
|
}
|
|
|
|
bool
|
|
HostInfoIsValid() const
|
|
{
|
|
return m_kdp_hostinfo_cpu_type != 0;
|
|
}
|
|
|
|
bool
|
|
ExtractIsReply (uint8_t first_packet_byte) const
|
|
{
|
|
// TODO: handle big endian...
|
|
return (first_packet_byte & ePacketTypeMask) != 0;
|
|
}
|
|
|
|
CommandType
|
|
ExtractCommand (uint8_t first_packet_byte) const
|
|
{
|
|
// TODO: handle big endian...
|
|
return (CommandType)(first_packet_byte & eCommandTypeMask);
|
|
}
|
|
|
|
static const char *
|
|
GetCommandAsCString (uint8_t command);
|
|
|
|
void
|
|
ClearKDPSettings ();
|
|
|
|
bool
|
|
SendRequestAndGetReply (const CommandType command,
|
|
const PacketStreamType &request_packet,
|
|
lldb_private::DataExtractor &reply_packet);
|
|
//------------------------------------------------------------------
|
|
// Classes that inherit from CommunicationKDP can see and modify these
|
|
//------------------------------------------------------------------
|
|
uint32_t m_addr_byte_size;
|
|
lldb::ByteOrder m_byte_order;
|
|
uint32_t m_packet_timeout;
|
|
std::recursive_mutex m_sequence_mutex; // Restrict access to sending/receiving packets to a single thread at a time
|
|
lldb_private::Predicate<bool> m_is_running;
|
|
uint32_t m_session_key;
|
|
uint8_t m_request_sequence_id;
|
|
uint8_t m_exception_sequence_id;
|
|
uint32_t m_kdp_version_version;
|
|
uint32_t m_kdp_version_feature;
|
|
uint32_t m_kdp_hostinfo_cpu_mask;
|
|
uint32_t m_kdp_hostinfo_cpu_type;
|
|
uint32_t m_kdp_hostinfo_cpu_subtype;
|
|
std::string m_kernel_version;
|
|
//std::string m_image_path; // Disable KDP_IMAGEPATH for now, it seems to hang the KDP connection...
|
|
lldb::addr_t m_last_read_memory_addr; // Last memory read address for logging
|
|
private:
|
|
//------------------------------------------------------------------
|
|
// For CommunicationKDP only
|
|
//------------------------------------------------------------------
|
|
DISALLOW_COPY_AND_ASSIGN (CommunicationKDP);
|
|
};
|
|
|
|
#endif // liblldb_CommunicationKDP_h_
|