375 lines
11 KiB
C++
375 lines
11 KiB
C++
//===-- DynamicLoaderDarwinKernel.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_DynamicLoaderDarwinKernel_h_
|
|
#define liblldb_DynamicLoaderDarwinKernel_h_
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
#include <map>
|
|
#include <vector>
|
|
#include <string>
|
|
|
|
// Other libraries and framework includes
|
|
|
|
#include "lldb/Target/DynamicLoader.h"
|
|
#include "lldb/Host/FileSpec.h"
|
|
#include "lldb/Host/TimeValue.h"
|
|
#include "lldb/Core/UUID.h"
|
|
#include "lldb/Host/Mutex.h"
|
|
#include "lldb/Target/Process.h"
|
|
|
|
class DynamicLoaderDarwinKernel : public lldb_private::DynamicLoader
|
|
{
|
|
public:
|
|
//------------------------------------------------------------------
|
|
// Static Functions
|
|
//------------------------------------------------------------------
|
|
static void
|
|
Initialize();
|
|
|
|
static void
|
|
Terminate();
|
|
|
|
static lldb_private::ConstString
|
|
GetPluginNameStatic();
|
|
|
|
static const char *
|
|
GetPluginDescriptionStatic();
|
|
|
|
static lldb_private::DynamicLoader *
|
|
CreateInstance (lldb_private::Process *process, bool force);
|
|
|
|
static void
|
|
DebuggerInitialize (lldb_private::Debugger &debugger);
|
|
|
|
DynamicLoaderDarwinKernel (lldb_private::Process *process, lldb::addr_t kernel_addr);
|
|
|
|
virtual
|
|
~DynamicLoaderDarwinKernel ();
|
|
|
|
//------------------------------------------------------------------
|
|
/// Called after attaching a process.
|
|
///
|
|
/// Allow DynamicLoader plug-ins to execute some code after
|
|
/// attaching to a process.
|
|
//------------------------------------------------------------------
|
|
virtual void
|
|
DidAttach ();
|
|
|
|
virtual void
|
|
DidLaunch ();
|
|
|
|
virtual lldb::ThreadPlanSP
|
|
GetStepThroughTrampolinePlan (lldb_private::Thread &thread,
|
|
bool stop_others);
|
|
|
|
virtual lldb_private::Error
|
|
CanLoadImage ();
|
|
|
|
//------------------------------------------------------------------
|
|
// PluginInterface protocol
|
|
//------------------------------------------------------------------
|
|
virtual lldb_private::ConstString
|
|
GetPluginName();
|
|
|
|
virtual uint32_t
|
|
GetPluginVersion();
|
|
|
|
protected:
|
|
void
|
|
PrivateInitialize (lldb_private::Process *process);
|
|
|
|
void
|
|
PrivateProcessStateChanged (lldb_private::Process *process,
|
|
lldb::StateType state);
|
|
|
|
void
|
|
UpdateIfNeeded();
|
|
|
|
void
|
|
LoadKernelModuleIfNeeded ();
|
|
|
|
void
|
|
Clear (bool clear_process);
|
|
|
|
void
|
|
PutToLog (lldb_private::Log *log) const;
|
|
|
|
static bool
|
|
BreakpointHitCallback (void *baton,
|
|
lldb_private::StoppointCallbackContext *context,
|
|
lldb::user_id_t break_id,
|
|
lldb::user_id_t break_loc_id);
|
|
|
|
bool
|
|
BreakpointHit (lldb_private::StoppointCallbackContext *context,
|
|
lldb::user_id_t break_id,
|
|
lldb::user_id_t break_loc_id);
|
|
uint32_t
|
|
GetAddrByteSize()
|
|
{
|
|
return m_kernel.GetAddressByteSize();
|
|
}
|
|
|
|
static lldb::ByteOrder
|
|
GetByteOrderFromMagic (uint32_t magic);
|
|
|
|
enum
|
|
{
|
|
KERNEL_MODULE_MAX_NAME = 64u,
|
|
// Versions less than 2 didn't have an entry size,
|
|
// they had a 64 bit name, 16 byte UUID, 8 byte addr,
|
|
// 8 byte size, 8 byte version, 4 byte load tag, and
|
|
// 4 byte flags
|
|
KERNEL_MODULE_ENTRY_SIZE_VERSION_1 = 64u + 16u + 8u + 8u + 8u + 4u + 4u
|
|
};
|
|
|
|
// class KextImageInfo represents a single kext or kernel binary image.
|
|
// The class was designed to hold the information from the OSKextLoadedKextSummary
|
|
// structure (in libkern/libkern/OSKextLibPrivate.h from xnu). The kernel maintains
|
|
// a list of loded kexts in memory (the OSKextLoadedKextSummaryHeader structure,
|
|
// which points to an array of OSKextLoadedKextSummary's).
|
|
//
|
|
// A KextImageInfos may have -
|
|
//
|
|
// 1. The load address, name, UUID, and size of a kext/kernel binary in memory
|
|
// (read straight out of the kernel's list-of-kexts loaded)
|
|
// 2. A ModuleSP based on a MemoryModule read out of the kernel's memory
|
|
// (very unlikely to have any symbolic information)
|
|
// 3. A ModuleSP for an on-disk copy of the kext binary, possibly with debug info
|
|
// or a dSYM
|
|
//
|
|
// For performance reasons, the developer may prefer that lldb not load the kexts out
|
|
// of memory at the start of a kernel session. But we should build up / maintain a
|
|
// list of kexts that the kernel has told us about so we can relocate a kext module
|
|
// later if the user explicitly adds it to the target.
|
|
|
|
class KextImageInfo
|
|
{
|
|
public:
|
|
KextImageInfo () :
|
|
m_name (),
|
|
m_module_sp (),
|
|
m_memory_module_sp (),
|
|
m_load_process_stop_id (UINT32_MAX),
|
|
m_uuid (),
|
|
m_load_address (LLDB_INVALID_ADDRESS),
|
|
m_size (0),
|
|
m_kernel_image (false)
|
|
{ }
|
|
|
|
void
|
|
Clear ()
|
|
{
|
|
m_load_address = LLDB_INVALID_ADDRESS;
|
|
m_size = 0;
|
|
m_name.clear ();
|
|
m_uuid.Clear();
|
|
m_module_sp.reset();
|
|
m_memory_module_sp.reset();
|
|
m_load_process_stop_id = UINT32_MAX;
|
|
}
|
|
|
|
bool
|
|
LoadImageAtFileAddress (lldb_private::Process *process);
|
|
|
|
bool
|
|
LoadImageUsingMemoryModule (lldb_private::Process *process);
|
|
|
|
bool
|
|
IsLoaded ()
|
|
{
|
|
return m_load_process_stop_id != UINT32_MAX;
|
|
}
|
|
|
|
void
|
|
SetLoadAddress (lldb::addr_t load_addr); // Address of the Mach-O header for this binary
|
|
|
|
lldb::addr_t
|
|
GetLoadAddress () const; // Address of the Mach-O header for this binary
|
|
|
|
lldb_private::UUID
|
|
GetUUID () const;
|
|
|
|
void
|
|
SetUUID (const lldb_private::UUID &uuid);
|
|
|
|
void
|
|
SetName (const char *);
|
|
|
|
std::string
|
|
GetName () const;
|
|
|
|
void
|
|
SetModule (lldb::ModuleSP module);
|
|
|
|
lldb::ModuleSP
|
|
GetModule ();
|
|
|
|
// try to fill in m_memory_module_sp from memory based on the m_load_address
|
|
bool
|
|
ReadMemoryModule (lldb_private::Process *process);
|
|
|
|
bool
|
|
IsKernel () const; // true if this is the mach_kernel; false if this is a kext
|
|
|
|
void
|
|
SetIsKernel (bool is_kernel);
|
|
|
|
uint64_t
|
|
GetSize () const;
|
|
|
|
void
|
|
SetSize (uint64_t size);
|
|
|
|
uint32_t
|
|
GetProcessStopId () const; // the stop-id when this binary was first noticed
|
|
|
|
void
|
|
SetProcessStopId (uint32_t stop_id);
|
|
|
|
bool
|
|
operator== (const KextImageInfo &rhs);
|
|
|
|
uint32_t
|
|
GetAddressByteSize (); // as determined by Mach-O header
|
|
|
|
lldb::ByteOrder
|
|
GetByteOrder(); // as determined by Mach-O header
|
|
|
|
lldb_private::ArchSpec
|
|
GetArchitecture () const; // as determined by Mach-O header
|
|
|
|
void
|
|
PutToLog (lldb_private::Log *log) const;
|
|
|
|
typedef std::vector<KextImageInfo> collection;
|
|
typedef collection::iterator iterator;
|
|
typedef collection::const_iterator const_iterator;
|
|
|
|
private:
|
|
std::string m_name;
|
|
lldb::ModuleSP m_module_sp;
|
|
lldb::ModuleSP m_memory_module_sp;
|
|
uint32_t m_load_process_stop_id; // the stop-id when this module was added to the Target
|
|
lldb_private::UUID m_uuid; // UUID for this dylib if it has one, else all zeros
|
|
lldb::addr_t m_load_address;
|
|
uint64_t m_size;
|
|
bool m_kernel_image; // true if this is the kernel, false if this is a kext
|
|
|
|
};
|
|
|
|
struct OSKextLoadedKextSummaryHeader
|
|
{
|
|
uint32_t version;
|
|
uint32_t entry_size;
|
|
uint32_t entry_count;
|
|
lldb::addr_t image_infos_addr;
|
|
|
|
OSKextLoadedKextSummaryHeader() :
|
|
version (0),
|
|
entry_size (0),
|
|
entry_count (0),
|
|
image_infos_addr (LLDB_INVALID_ADDRESS)
|
|
{
|
|
}
|
|
|
|
uint32_t
|
|
GetSize()
|
|
{
|
|
switch (version)
|
|
{
|
|
case 0: return 0; // Can't know the size without a valid version
|
|
case 1: return 8; // Version 1 only had a version + entry_count
|
|
default: break;
|
|
}
|
|
// Version 2 and above has version, entry_size, entry_count, and reserved
|
|
return 16;
|
|
}
|
|
|
|
void
|
|
Clear()
|
|
{
|
|
version = 0;
|
|
entry_size = 0;
|
|
entry_count = 0;
|
|
image_infos_addr = LLDB_INVALID_ADDRESS;
|
|
}
|
|
|
|
bool
|
|
IsValid() const
|
|
{
|
|
return version >= 1 || version <= 2;
|
|
}
|
|
};
|
|
|
|
void
|
|
RegisterNotificationCallbacks();
|
|
|
|
void
|
|
UnregisterNotificationCallbacks();
|
|
|
|
void
|
|
SetNotificationBreakpointIfNeeded ();
|
|
|
|
bool
|
|
ReadAllKextSummaries ();
|
|
|
|
bool
|
|
ReadKextSummaryHeader ();
|
|
|
|
bool
|
|
ParseKextSummaries (const lldb_private::Address &kext_summary_addr,
|
|
uint32_t count);
|
|
|
|
void
|
|
UpdateImageInfosHeaderAndLoadCommands(KextImageInfo::collection &image_infos,
|
|
uint32_t infos_count,
|
|
bool update_executable);
|
|
|
|
uint32_t
|
|
ReadKextSummaries (const lldb_private::Address &kext_summary_addr,
|
|
uint32_t image_infos_count,
|
|
KextImageInfo::collection &image_infos);
|
|
|
|
static lldb::addr_t
|
|
SearchForDarwinKernel (lldb_private::Process *process);
|
|
|
|
static lldb::addr_t
|
|
SearchForKernelAtSameLoadAddr (lldb_private::Process *process);
|
|
|
|
static lldb::addr_t
|
|
SearchForKernelWithDebugHints (lldb_private::Process *process);
|
|
|
|
static lldb::addr_t
|
|
SearchForKernelNearPC (lldb_private::Process *process);
|
|
|
|
static lldb::addr_t
|
|
SearchForKernelViaExhaustiveSearch (lldb_private::Process *process);
|
|
|
|
static lldb_private::UUID
|
|
CheckForKernelImageAtAddress (lldb::addr_t addr, lldb_private::Process *process);
|
|
|
|
lldb::addr_t m_kernel_load_address;
|
|
KextImageInfo m_kernel; // Info about the current kernel image being used
|
|
|
|
lldb_private::Address m_kext_summary_header_ptr_addr;
|
|
lldb_private::Address m_kext_summary_header_addr;
|
|
OSKextLoadedKextSummaryHeader m_kext_summary_header;
|
|
KextImageInfo::collection m_known_kexts;
|
|
mutable lldb_private::Mutex m_mutex;
|
|
lldb::user_id_t m_break_id;
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN (DynamicLoaderDarwinKernel);
|
|
};
|
|
|
|
#endif // liblldb_DynamicLoaderDarwinKernel_h_
|