KernelElf Class Reference

ELF 文件相关 More...

#include <kernel_elf.hpp>

Collaboration diagram for KernelElf:

Public Member Functions
auto	GetElfSize () const -> size_t
	获取 elf 文件大小
构造/析构函数
	KernelElf (uint64_t elf_addr)
	构造函数
	KernelElf ()=default
	KernelElf (const KernelElf &)=default
	KernelElf (KernelElf &&)=default
auto	operator= (const KernelElf &) -> KernelElf &=default
auto	operator= (KernelElf &&) -> KernelElf &=default
	~KernelElf ()=default

Public Attributes
std::span< Elf64_Sym >	symtab {}
	符号表
uint8_t *	strtab {nullptr}
	字符串表

Protected Member Functions
auto	CheckElfIdentity () const -> Expected< void >

Protected Attributes
elf 文件相关
std::span< uint8_t >	elf_ {}
Elf64_Ehdr	ehdr_ {}
std::span< Elf64_Phdr >	phdr_ {}
std::span< Elf64_Shdr >	shdr_ {}

Private Member Functions
auto	CheckElfMagic () const -> Expected< void >
auto	CheckElfClass () const -> Expected< void >

Detailed Description

ELF 文件相关

Copyright

Copyright The SimpleKernel Contributors

Definition at line 22 of file kernel_elf.hpp.

Constructor & Destructor Documentation

KernelElf() [1/4]

KernelElf::KernelElf ( uint64_t  elf_addr )

inlineexplicit

构造函数

Parameters

elf_addr

elf 地址

Definition at line 42 of file kernel_elf.hpp.

                                        {
    assert(elf_addr != 0U && "elf_addr is null");
 
    elf_ = std::span<uint8_t>(reinterpret_cast<uint8_t*>(elf_addr), EI_NIDENT);
 
    // 检查 elf 头数据
    CheckElfIdentity().or_else([](Error err) -> Expected<void> {
      klog::Err("KernelElf NOT valid ELF file: {}", err.message());
      while (true) {
        cpu_io::Pause();
      }
      return {};
    });
 
    ehdr_ = *reinterpret_cast<const Elf64_Ehdr*>(elf_.data());
 
    // 重新计算 elf 大小
    size_t max_size = EI_NIDENT;
    if (ehdr_.e_phoff != 0) {
      size_t ph_end = ehdr_.e_phoff + ehdr_.e_phnum * ehdr_.e_phentsize;
      if (ph_end > max_size) {
        max_size = ph_end;
      }
    }
    if (ehdr_.e_shoff != 0) {
      size_t sh_end = ehdr_.e_shoff + ehdr_.e_shnum * ehdr_.e_shentsize;
      if (sh_end > max_size) {
        max_size = sh_end;
      }
      const auto* shdrs =
          reinterpret_cast<const Elf64_Shdr*>(elf_.data() + ehdr_.e_shoff);
      for (int i = 0; i < ehdr_.e_shnum; ++i) {
        size_t section_end = shdrs[i].sh_offset + shdrs[i].sh_size;
        if (section_end > max_size) {
          max_size = section_end;
        }
      }
    }
    elf_ = std::span<uint8_t>(reinterpret_cast<uint8_t*>(elf_addr), max_size);
 
    phdr_ = std::span<Elf64_Phdr>(
        reinterpret_cast<Elf64_Phdr*>(elf_.data() + ehdr_.e_phoff),
        ehdr_.e_phnum);
 
    shdr_ = std::span<Elf64_Shdr>(
        reinterpret_cast<Elf64_Shdr*>(elf_.data() + ehdr_.e_shoff),
        ehdr_.e_shnum);
 
    const auto* shstrtab = reinterpret_cast<const char*>(elf_.data()) +
                           shdr_[ehdr_.e_shstrndx].sh_offset;
    for (auto shdr : shdr_) {
      if (strcmp(shstrtab + shdr.sh_name, ".symtab") == 0) {
        symtab = std::span<Elf64_Sym>(
            reinterpret_cast<Elf64_Sym*>(elf_.data() + shdr.sh_offset),
            (shdr.sh_size / sizeof(Elf64_Sym)));
      } else if (strcmp(shstrtab + shdr.sh_name, ".strtab") == 0) {
        strtab = elf_.data() + shdr.sh_offset;
      }
    }
  }

Here is the call graph for this function:

KernelElf() [2/4]

KernelElf::KernelElf ( )

default

KernelElf() [3/4]

KernelElf::KernelElf ( const KernelElf &  )

default

KernelElf() [4/4]

KernelElf::KernelElf ( KernelElf &&  )

default

~KernelElf()

KernelElf::~KernelElf ( )

default

Member Function Documentation

CheckElfClass()

auto KernelElf::CheckElfClass ( ) const -> Expected<void>

inlineprivate

检查 ELF class (32/64 bit)

Definition at line 143 of file kernel_elf.hpp.

                                                             {
    if (elf_[EI_CLASS] == ELFCLASS32) {
      return std::unexpected(Error(ErrorCode::kElfUnsupported32Bit));
    }
    if (elf_[EI_CLASS] != ELFCLASS64) {
      return std::unexpected(Error(ErrorCode::kElfInvalidClass));
    }
    return {};
  }

Here is the caller graph for this function:

CheckElfIdentity()

auto KernelElf::CheckElfIdentity ( ) const -> Expected<void>

inlineprotected

检查 elf 标识

Returns

成功返回 Expected<void>，失败返回错误

Definition at line 124 of file kernel_elf.hpp.

                                                                {
    return CheckElfMagic().and_then([this]() { return CheckElfClass(); });
  }

Here is the call graph for this function:

Here is the caller graph for this function:

CheckElfMagic()

auto KernelElf::CheckElfMagic ( ) const -> Expected<void>

inlineprivate

检查 ELF magic number

Definition at line 132 of file kernel_elf.hpp.

                                                             {
    if ((elf_[EI_MAG0] != ELFMAG0) || (elf_[EI_MAG1] != ELFMAG1) ||
        (elf_[EI_MAG2] != ELFMAG2) || (elf_[EI_MAG3] != ELFMAG3)) {
      return std::unexpected(Error(ErrorCode::kElfInvalidMagic));
    }
    return {};
  }

Here is the caller graph for this function:

GetElfSize()

auto KernelElf::GetElfSize ( ) const -> size_t

inline

获取 elf 文件大小

Returns

elf 文件大小

Definition at line 33 of file kernel_elf.hpp.

{ return elf_.size(); }

Here is the caller graph for this function:

operator=() [1/2]

auto KernelElf::operator= ( const KernelElf &  ) -> KernelElf &=default

default

operator=() [2/2]

auto KernelElf::operator= ( KernelElf &&  ) -> KernelElf &=default

default

Member Data Documentation

ehdr_

Elf64_Ehdr KernelElf::ehdr_ {}

protected

Definition at line 115 of file kernel_elf.hpp.

{};

elf_

std::span<uint8_t> KernelElf::elf_ {}

protected

Definition at line 114 of file kernel_elf.hpp.

{};

phdr_

std::span<Elf64_Phdr> KernelElf::phdr_ {}

protected

Definition at line 116 of file kernel_elf.hpp.

{};

shdr_

std::span<Elf64_Shdr> KernelElf::shdr_ {}

protected

Definition at line 117 of file kernel_elf.hpp.

{};

strtab

uint8_t* KernelElf::strtab {nullptr}

字符串表

Definition at line 27 of file kernel_elf.hpp.

{nullptr};

symtab

std::span<Elf64_Sym> KernelElf::symtab {}

符号表

Definition at line 25 of file kernel_elf.hpp.

{};

---

The documentation for this class was generated from the following file:

• /workspaces/SimpleKernel/src/include/kernel_elf.hpp