lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h

//===-- 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 const char *
    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 const char *
    GetPluginName();

    virtual const char *
    GetShortPluginName();

    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);

    bool
    AddModulesUsingImageInfos (KextImageInfo::collection &image_infos);

    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
    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_