DynamicLoaderFreeBSDKernel.h

Go to the documentation of this file.

//===-- DynamicLoaderFreeBSDKernel.h -----------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#ifndef LLDB_SOURCE_PLUGINS_DYNAMICLOADER_FREEBSD_KERNEL_DYNAMICLOADERFREEBSDKERNEL_H
#define LLDB_SOURCE_PLUGINS_DYNAMICLOADER_FREEBSD_KERNEL_DYNAMICLOADERFREEBSDKERNEL_H
 
#include <mutex>
#include <string>
#include <vector>
 
#include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/Process.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/UUID.h"
#include "llvm/BinaryFormat/ELF.h"
 
class DynamicLoaderFreeBSDKernel : public lldb_private::DynamicLoader {
public:
  DynamicLoaderFreeBSDKernel(lldb_private::Process *process,
                             lldb::addr_t kernel_addr);
 
  ~DynamicLoaderFreeBSDKernel() override;
 
  // Static Functions
 
  static void Initialize();
 
  static void Terminate();
 
  static llvm::StringRef GetPluginNameStatic() { return "freebsd-kernel"; }
 
  static llvm::StringRef GetPluginDescriptionStatic();
 
  static lldb_private::DynamicLoader *
  CreateInstance(lldb_private::Process *process, bool force);
 
  static void DebuggerInit(lldb_private::Debugger &debugger);
 
  static lldb::addr_t FindFreeBSDKernel(lldb_private::Process *process);
 
  // Hooks for time point that after attach to some proccess
  void DidAttach() override;
 
  void DidLaunch() override;
 
  lldb::ThreadPlanSP GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
                                                  bool stop_others) override;
 
  lldb_private::Status CanLoadImage() override;
 
  llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
protected:
  class KModImageInfo {
  public:
    KModImageInfo()
        : m_module_sp(), m_memory_module_sp(), m_uuid(), m_name(), m_path() {}
 
    void Clear() {
      m_load_address = LLDB_INVALID_ADDRESS;
      m_name.clear();
      m_uuid.Clear();
      m_module_sp.reset();
      m_memory_module_sp.reset();
      m_stop_id = UINT32_MAX;
      m_path.clear();
    }
 
    void SetLoadAddress(lldb::addr_t load_address) {
      m_load_address = load_address;
    }
 
    lldb::addr_t GetLoadAddress() const { return m_load_address; }
 
    void SetUUID(const lldb_private::UUID uuid) { m_uuid = uuid; }
 
    lldb_private::UUID GetUUID() const { return m_uuid; }
 
    void SetName(const char *name) { m_name = name; }
 
    std::string GetName() const { return m_name; }
 
    void SetPath(const char *path) { m_path = path; }
 
    std::string GetPath() const { return m_path; }
 
    void SetModule(lldb::ModuleSP module) { m_module_sp = module; }
 
    lldb::ModuleSP GetModule() { return m_module_sp; }
 
    void SetIsKernel(bool is_kernel) { m_is_kernel = is_kernel; }
 
    bool IsKernel() const { return m_is_kernel; };
 
    void SetStopID(uint32_t stop_id) { m_stop_id = stop_id; }
 
    uint32_t GetStopID() { return m_stop_id; }
 
    bool IsLoaded() const { return m_stop_id != UINT32_MAX; };
 
    bool ReadMemoryModule(lldb_private::Process *process);
 
    bool LoadImageUsingMemoryModule(lldb_private::Process *process);
 
    bool LoadImageUsingFileAddress(lldb_private::Process *process);
 
    using collection_type = std::vector<KModImageInfo>;
 
  private:
    lldb::ModuleSP m_module_sp;
    lldb::ModuleSP m_memory_module_sp;
    lldb::addr_t m_load_address = LLDB_INVALID_ADDRESS;
    lldb_private::UUID m_uuid;
    bool m_is_kernel = false;
    std::string m_name;
    std::string m_path;
    uint32_t m_stop_id = UINT32_MAX;
  };
 
  void PrivateInitialize(lldb_private::Process *process);
 
  void Clear(bool clear_process);
 
  void Update();
 
  void LoadKernelModules();
 
  void ReadAllKmods();
 
  bool ReadAllKmods(lldb_private::Address linker_files_head_address,
                    KModImageInfo::collection_type &kmods_list);
 
  bool ReadKmodsListHeader();
 
  bool ParseKmods(lldb_private::Address linker_files_head_address);
 
  void SetNotificationBreakPoint();
 
  static lldb_private::UUID
  CheckForKernelImageAtAddress(lldb_private::Process *process,
                               lldb::addr_t address,
                               bool *read_error = nullptr);
 
  static lldb::addr_t FindKernelAtLoadAddress(lldb_private::Process *process);
 
  static bool ReadELFHeader(lldb_private::Process *process,
                            lldb::addr_t address, llvm::ELF::Elf32_Ehdr &header,
                            bool *read_error = nullptr);
 
  lldb_private::Process *m_process;
  lldb_private::Address m_linker_file_list_struct_addr;
  lldb_private::Address m_linker_file_head_addr;
  lldb::addr_t m_kernel_load_address;
  KModImageInfo m_kernel_image_info;
  KModImageInfo::collection_type m_linker_files_list;
  std::recursive_mutex m_mutex;
  std::unordered_map<std::string, lldb_private::UUID> m_kld_name_to_uuid;
 
private:
  DynamicLoaderFreeBSDKernel(const DynamicLoaderFreeBSDKernel &) = delete;
 
  const DynamicLoaderFreeBSDKernel &
  operator=(const DynamicLoaderFreeBSDKernel &) = delete;
};
 
#endif