//===-- 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 "llvm/Support/MachO.h"
#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_