Userspace: Write a dynamic loader
This allows running executing dynamically linked executables!
This commit is contained in:
parent
f30947336a
commit
aa7e92b275
|
|
@ -23,7 +23,7 @@ You can find a live demo [here](https://bananymous.com/banan-os)
|
||||||
- [ ] Task bar
|
- [ ] Task bar
|
||||||
- [ ] Program launcher
|
- [ ] Program launcher
|
||||||
- [ ] Some nice apps
|
- [ ] Some nice apps
|
||||||
- [ ] ELF dynamic linking
|
- [x] ELF dynamic linking
|
||||||
- [ ] copy-on-write memory
|
- [ ] copy-on-write memory
|
||||||
|
|
||||||
#### Drivers
|
#### Drivers
|
||||||
|
|
|
||||||
|
|
@ -6,6 +6,7 @@ set(USERSPACE_PROGRAMS
|
||||||
cp
|
cp
|
||||||
dd
|
dd
|
||||||
dhcp-client
|
dhcp-client
|
||||||
|
DynamicLoader
|
||||||
echo
|
echo
|
||||||
getopt
|
getopt
|
||||||
http-server
|
http-server
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,25 @@
|
||||||
|
set(SOURCES
|
||||||
|
main.cpp
|
||||||
|
utils.cpp
|
||||||
|
)
|
||||||
|
|
||||||
|
add_executable(DynamicLoader ${SOURCES})
|
||||||
|
target_compile_options(DynamicLoader PRIVATE -fno-tree-loop-distribute-patterns -fno-rtti -pie -fpie -ffunction-sections -fdata-sections -mgeneral-regs-only)
|
||||||
|
target_compile_options(DynamicLoader PRIVATE -Wall -Wextra -Werror)
|
||||||
|
target_compile_definitions(DynamicLoader PRIVATE __arch=${BANAN_ARCH})
|
||||||
|
target_link_options(DynamicLoader PRIVATE -nolibc -nostartfiles -static-libgcc -pie -fpie)
|
||||||
|
target_link_options(DynamicLoader PRIVATE LINKER:--no-dynamic-linker)
|
||||||
|
|
||||||
|
# DynamicLoader does not support relocating itself
|
||||||
|
add_custom_command(
|
||||||
|
TARGET DynamicLoader POST_BUILD
|
||||||
|
COMMAND readelf --relocs $<TARGET_FILE:DynamicLoader> | grep -q 'There are no relocations in this file'
|
||||||
|
)
|
||||||
|
|
||||||
|
banan_include_headers(DynamicLoader ban)
|
||||||
|
banan_include_headers(DynamicLoader kernel)
|
||||||
|
banan_include_headers(DynamicLoader libc)
|
||||||
|
banan_include_headers(DynamicLoader libelf)
|
||||||
|
|
||||||
|
set_target_properties(DynamicLoader PROPERTIES OUTPUT_NAME DynamicLoader.so)
|
||||||
|
install(TARGETS DynamicLoader DESTINATION ${CMAKE_INSTALL_LIBDIR} OPTIONAL)
|
||||||
|
|
@ -0,0 +1,928 @@
|
||||||
|
#include "utils.h"
|
||||||
|
|
||||||
|
#include <LibELF/Types.h>
|
||||||
|
#include <LibELF/Values.h>
|
||||||
|
|
||||||
|
#include <fcntl.h>
|
||||||
|
#include <limits.h>
|
||||||
|
#include <sys/mman.h>
|
||||||
|
#include <sys/syscall.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
|
||||||
|
extern "C"
|
||||||
|
__attribute__((naked))
|
||||||
|
void _start()
|
||||||
|
{
|
||||||
|
#if defined(__x86_64__)
|
||||||
|
asm volatile(
|
||||||
|
"xorq %rbp, %rbp;"
|
||||||
|
"call _entry;"
|
||||||
|
"ud2;"
|
||||||
|
);
|
||||||
|
#elif defined(__i686__)
|
||||||
|
asm volatile(
|
||||||
|
"xorl %ebp, %ebp;"
|
||||||
|
"pushl %ecx;"
|
||||||
|
"pushl %edx;"
|
||||||
|
"pushl %esi;"
|
||||||
|
"pushl %edi;"
|
||||||
|
"call _entry;"
|
||||||
|
"ud2;"
|
||||||
|
);
|
||||||
|
#else
|
||||||
|
#error "unsupported architecture"
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
__attribute__((naked, noreturn))
|
||||||
|
static void call_entry_point(int, char**, char**, uintptr_t)
|
||||||
|
{
|
||||||
|
#if defined(__x86_64__)
|
||||||
|
asm volatile(
|
||||||
|
"andq $-16, %rsp;"
|
||||||
|
"jmp *%rcx;"
|
||||||
|
);
|
||||||
|
#elif defined(__i686__)
|
||||||
|
asm volatile(
|
||||||
|
"addl $4, %esp;"
|
||||||
|
"popl %edi;"
|
||||||
|
"popl %esi;"
|
||||||
|
"popl %edx;"
|
||||||
|
"popl %ecx;"
|
||||||
|
"andl $-16, %esp;"
|
||||||
|
"jmp *%ecx;"
|
||||||
|
);
|
||||||
|
#else
|
||||||
|
#error "unsupported architecture"
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
using namespace LibELF;
|
||||||
|
|
||||||
|
static void validate_program_header(const ElfNativeFileHeader& file_header)
|
||||||
|
{
|
||||||
|
if (file_header.e_ident[EI_MAG0] != ELFMAG0 ||
|
||||||
|
file_header.e_ident[EI_MAG1] != ELFMAG1 ||
|
||||||
|
file_header.e_ident[EI_MAG2] != ELFMAG2 ||
|
||||||
|
file_header.e_ident[EI_MAG3] != ELFMAG3)
|
||||||
|
{
|
||||||
|
print_error_and_exit("ELF has invalid magic in header", 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (file_header.e_ident[EI_DATA] != ELFDATA2LSB)
|
||||||
|
print_error_and_exit("ELF is not little-endian", 0);
|
||||||
|
|
||||||
|
if (file_header.e_ident[EI_VERSION] != EV_CURRENT)
|
||||||
|
print_error_and_exit("ELF has invalid version", 0);
|
||||||
|
|
||||||
|
#if defined(__x86_64__)
|
||||||
|
if (file_header.e_ident[EI_CLASS] != ELFCLASS64)
|
||||||
|
#elif defined(__i686__)
|
||||||
|
if (file_header.e_ident[EI_CLASS] != ELFCLASS32)
|
||||||
|
#else
|
||||||
|
#error "unsupported architecture"
|
||||||
|
#endif
|
||||||
|
print_error_and_exit("ELF not in native format", 0);
|
||||||
|
|
||||||
|
if (file_header.e_type != ET_EXEC && file_header.e_type != ET_DYN)
|
||||||
|
print_error_and_exit("ELF has unsupported file header type", 0);
|
||||||
|
|
||||||
|
if (file_header.e_version != EV_CURRENT)
|
||||||
|
print_error_and_exit("ELF has unsupported version", 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
__attribute__((naked))
|
||||||
|
static void resolve_symbol_trampoline()
|
||||||
|
{
|
||||||
|
#if defined(__x86_64__)
|
||||||
|
asm volatile(
|
||||||
|
"pushq %rdi;"
|
||||||
|
"pushq %rsi;"
|
||||||
|
"pushq %rdx;"
|
||||||
|
"pushq %rcx;"
|
||||||
|
"pushq %r8;"
|
||||||
|
"pushq %r9;"
|
||||||
|
"pushq %r10;"
|
||||||
|
"pushq %r11;"
|
||||||
|
|
||||||
|
"movq 64(%rsp), %rdi;"
|
||||||
|
"movq 72(%rsp), %rsi;"
|
||||||
|
|
||||||
|
"call resolve_symbol;"
|
||||||
|
|
||||||
|
"popq %r11;"
|
||||||
|
"popq %r10;"
|
||||||
|
"popq %r9;"
|
||||||
|
"popq %r8;"
|
||||||
|
"popq %rcx;"
|
||||||
|
"popq %rdx;"
|
||||||
|
"popq %rsi;"
|
||||||
|
"popq %rdi;"
|
||||||
|
|
||||||
|
"addq $16, %rsp;"
|
||||||
|
"jmp *%rax;"
|
||||||
|
);
|
||||||
|
#elif defined(__i686__)
|
||||||
|
asm volatile(
|
||||||
|
"call resolve_symbol;"
|
||||||
|
"addl $8, %esp;"
|
||||||
|
"jmp *%eax;"
|
||||||
|
);
|
||||||
|
#else
|
||||||
|
#error "unsupported architecture"
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
struct LoadedElf
|
||||||
|
{
|
||||||
|
ElfNativeFileHeader file_header;
|
||||||
|
ElfNativeDynamic* dynamics;
|
||||||
|
|
||||||
|
uintptr_t base;
|
||||||
|
|
||||||
|
uintptr_t hash;
|
||||||
|
|
||||||
|
uintptr_t strtab;
|
||||||
|
|
||||||
|
uintptr_t symtab;
|
||||||
|
size_t syment;
|
||||||
|
|
||||||
|
uintptr_t rel;
|
||||||
|
size_t relent;
|
||||||
|
size_t relsz;
|
||||||
|
|
||||||
|
uintptr_t rela;
|
||||||
|
size_t relaent;
|
||||||
|
size_t relasz;
|
||||||
|
|
||||||
|
uintptr_t jmprel;
|
||||||
|
size_t pltrel;
|
||||||
|
size_t pltrelsz;
|
||||||
|
|
||||||
|
uintptr_t init;
|
||||||
|
uintptr_t init_array;
|
||||||
|
size_t init_arraysz;
|
||||||
|
|
||||||
|
bool has_called_init;
|
||||||
|
bool is_relocated;
|
||||||
|
|
||||||
|
char path[PATH_MAX];
|
||||||
|
};
|
||||||
|
|
||||||
|
constexpr uintptr_t SYM_NOT_FOUND = -1;
|
||||||
|
|
||||||
|
static uint32_t elf_hash(const char* name)
|
||||||
|
{
|
||||||
|
uint32_t h = 0, g;
|
||||||
|
while (*name)
|
||||||
|
{
|
||||||
|
h = (h << 4) + *name++;
|
||||||
|
if ((g = h & 0xF0000000))
|
||||||
|
h ^= g >> 24;
|
||||||
|
h &= ~g;
|
||||||
|
}
|
||||||
|
return h;
|
||||||
|
}
|
||||||
|
|
||||||
|
static ElfNativeSymbol* find_symbol(const LoadedElf& elf, const char* name)
|
||||||
|
{
|
||||||
|
const uint32_t* hash_table = reinterpret_cast<uint32_t*>(elf.hash);
|
||||||
|
const uint32_t nbucket = hash_table[0];
|
||||||
|
|
||||||
|
for (uint32_t entry = hash_table[2 + (elf_hash(name) % nbucket)]; entry; entry = hash_table[2 + nbucket + entry])
|
||||||
|
{
|
||||||
|
auto& symbol = *reinterpret_cast<ElfNativeSymbol*>(elf.symtab + entry * elf.syment);
|
||||||
|
if (symbol.st_shndx == 0)
|
||||||
|
continue;
|
||||||
|
const char* symbol_name = reinterpret_cast<const char*>(elf.strtab + symbol.st_name);
|
||||||
|
if (strcmp(name, symbol_name))
|
||||||
|
continue;
|
||||||
|
return &symbol;
|
||||||
|
}
|
||||||
|
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
static uintptr_t get_symbol_address(const LoadedElf& elf, const char* name)
|
||||||
|
{
|
||||||
|
auto* symbol = find_symbol(elf, name);
|
||||||
|
if (symbol == nullptr)
|
||||||
|
return SYM_NOT_FOUND;
|
||||||
|
return elf.base + symbol->st_value;
|
||||||
|
}
|
||||||
|
|
||||||
|
static LoadedElf* get_libc_elf();
|
||||||
|
static LoadedElf* get_libgcc_elf();
|
||||||
|
|
||||||
|
template<typename RelocT> requires BAN::is_same_v<RelocT, ElfNativeRelocation> || BAN::is_same_v<RelocT, ElfNativeRelocationA>
|
||||||
|
static uintptr_t handle_relocation(const LoadedElf& elf, const RelocT& reloc)
|
||||||
|
{
|
||||||
|
uintptr_t symbol_address = 0;
|
||||||
|
size_t symbol_size = 0;
|
||||||
|
|
||||||
|
#if defined(__x86_64__)
|
||||||
|
const bool is_copy = (ELF64_R_TYPE(reloc.r_info) == R_X86_64_COPY);
|
||||||
|
if (const uint32_t symbol_index = ELF64_R_SYM(reloc.r_info))
|
||||||
|
#elif defined(__i686__)
|
||||||
|
const bool is_copy = (ELF32_R_TYPE(reloc.r_info) == R_386_COPY);
|
||||||
|
if (const uint32_t symbol_index = ELF32_R_SYM(reloc.r_info))
|
||||||
|
#else
|
||||||
|
#error "unsupported architecture"
|
||||||
|
#endif
|
||||||
|
{
|
||||||
|
const auto& symbol = *reinterpret_cast<ElfNativeSymbol*>(elf.symtab + symbol_index * elf.syment);
|
||||||
|
const char* symbol_name = reinterpret_cast<const char*>(elf.strtab + symbol.st_name);
|
||||||
|
|
||||||
|
symbol_size = symbol.st_size;
|
||||||
|
|
||||||
|
if (!is_copy && symbol.st_shndx)
|
||||||
|
symbol_address = elf.base + symbol.st_value;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
// external symbol
|
||||||
|
symbol_address = SYM_NOT_FOUND;
|
||||||
|
for (size_t i = 0; symbol_address == SYM_NOT_FOUND; i++)
|
||||||
|
{
|
||||||
|
auto& dynamic = elf.dynamics[i];
|
||||||
|
if (dynamic.d_tag == DT_NULL)
|
||||||
|
break;
|
||||||
|
if (dynamic.d_tag != DT_NEEDED)
|
||||||
|
continue;
|
||||||
|
const auto& lib_elf = *reinterpret_cast<LoadedElf*>(dynamic.d_un.d_ptr);
|
||||||
|
symbol_address = get_symbol_address(lib_elf, symbol_name);
|
||||||
|
}
|
||||||
|
|
||||||
|
// libgcc_s.so needs symbols from libc, but we can't link it as toolchain
|
||||||
|
// has to be built before libc. This hack allows resolving symbols from
|
||||||
|
// libc even if its not specified as dependency, but is loaded
|
||||||
|
if (symbol_address == SYM_NOT_FOUND)
|
||||||
|
if (const auto* libc_elf = get_libc_elf())
|
||||||
|
symbol_address = get_symbol_address(*libc_elf, symbol_name);
|
||||||
|
if (symbol_address == SYM_NOT_FOUND)
|
||||||
|
if (const auto* libgcc_elf = get_libgcc_elf())
|
||||||
|
symbol_address = get_symbol_address(*libgcc_elf, symbol_name);
|
||||||
|
|
||||||
|
if (symbol_address == SYM_NOT_FOUND)
|
||||||
|
{
|
||||||
|
if (ELF_ST_BIND(symbol.st_info) != STB_WEAK)
|
||||||
|
{
|
||||||
|
print(STDERR_FILENO, elf.path);
|
||||||
|
print(STDERR_FILENO, ": could not find symbol \"");
|
||||||
|
print(STDERR_FILENO, symbol_name);
|
||||||
|
print_error_and_exit("\"", 0);
|
||||||
|
}
|
||||||
|
symbol_address = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t size = 0;
|
||||||
|
uintptr_t value = 0;
|
||||||
|
bool add_addend = false;
|
||||||
|
|
||||||
|
#if defined(__x86_64__)
|
||||||
|
switch (ELF64_R_TYPE(reloc.r_info))
|
||||||
|
{
|
||||||
|
case R_X86_64_NONE:
|
||||||
|
break;
|
||||||
|
case R_X86_64_64:
|
||||||
|
size = 8;
|
||||||
|
value = symbol_address;
|
||||||
|
add_addend = true;
|
||||||
|
break;
|
||||||
|
case R_X86_64_COPY:
|
||||||
|
if (symbol_address == 0)
|
||||||
|
print_error_and_exit("copy undefined weak symbol?", 0);
|
||||||
|
memcpy(
|
||||||
|
reinterpret_cast<void*>(elf.base + reloc.r_offset),
|
||||||
|
reinterpret_cast<void*>(symbol_address),
|
||||||
|
symbol_size
|
||||||
|
);
|
||||||
|
break;
|
||||||
|
case R_X86_64_GLOB_DAT:
|
||||||
|
size = 8;
|
||||||
|
value = symbol_address;
|
||||||
|
break;
|
||||||
|
case R_X86_64_JUMP_SLOT:
|
||||||
|
size = 8;
|
||||||
|
value = symbol_address;
|
||||||
|
break;
|
||||||
|
case R_X86_64_RELATIVE:
|
||||||
|
size = 8;
|
||||||
|
value = elf.base;
|
||||||
|
add_addend = true;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
print(STDERR_FILENO, "unsupported reloc type ");
|
||||||
|
print_uint(STDERR_FILENO, ELF64_R_TYPE(reloc.r_info));
|
||||||
|
print(STDERR_FILENO, " in ");
|
||||||
|
print(STDERR_FILENO, elf.path);
|
||||||
|
print_error_and_exit("", 0);
|
||||||
|
}
|
||||||
|
#elif defined(__i686__)
|
||||||
|
switch (ELF32_R_TYPE(reloc.r_info))
|
||||||
|
{
|
||||||
|
case R_386_NONE:
|
||||||
|
break;
|
||||||
|
case R_386_32:
|
||||||
|
size = 4;
|
||||||
|
value = symbol_address;
|
||||||
|
add_addend = true;
|
||||||
|
break;
|
||||||
|
case R_386_PC32:
|
||||||
|
size = 4;
|
||||||
|
value = symbol_address - reloc.r_offset;
|
||||||
|
add_addend = true;
|
||||||
|
break;
|
||||||
|
case R_386_COPY:
|
||||||
|
memcpy(
|
||||||
|
reinterpret_cast<void*>(elf.base + reloc.r_offset),
|
||||||
|
reinterpret_cast<void*>(symbol_address),
|
||||||
|
symbol_size
|
||||||
|
);
|
||||||
|
break;
|
||||||
|
case R_386_GLOB_DAT:
|
||||||
|
size = 4;
|
||||||
|
value = symbol_address;
|
||||||
|
break;
|
||||||
|
case R_386_JMP_SLOT:
|
||||||
|
size = 4;
|
||||||
|
value = symbol_address;
|
||||||
|
break;
|
||||||
|
case R_386_RELATIVE:
|
||||||
|
size = 4;
|
||||||
|
value = elf.base;
|
||||||
|
add_addend = true;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
print(STDERR_FILENO, "unsupported reloc type ");
|
||||||
|
print_uint(STDERR_FILENO, ELF32_R_TYPE(reloc.r_info));
|
||||||
|
print_error_and_exit("", 0);
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
#error "unsupported architecture"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
if (add_addend)
|
||||||
|
{
|
||||||
|
if constexpr(BAN::is_same_v<RelocT, ElfNativeRelocationA>)
|
||||||
|
value += reloc.r_addend;
|
||||||
|
else
|
||||||
|
{
|
||||||
|
switch (size)
|
||||||
|
{
|
||||||
|
case 0: break;
|
||||||
|
case 1: value += *reinterpret_cast<uint8_t*> (elf.base + reloc.r_offset); break;
|
||||||
|
case 2: value += *reinterpret_cast<uint16_t*>(elf.base + reloc.r_offset); break;
|
||||||
|
case 4: value += *reinterpret_cast<uint32_t*>(elf.base + reloc.r_offset); break;
|
||||||
|
case 8: value += *reinterpret_cast<uint64_t*>(elf.base + reloc.r_offset); break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (size)
|
||||||
|
{
|
||||||
|
case 0: break;
|
||||||
|
case 1: *reinterpret_cast<uint8_t*> (elf.base + reloc.r_offset) = value; break;
|
||||||
|
case 2: *reinterpret_cast<uint16_t*>(elf.base + reloc.r_offset) = value; break;
|
||||||
|
case 4: *reinterpret_cast<uint32_t*>(elf.base + reloc.r_offset) = value; break;
|
||||||
|
case 8: *reinterpret_cast<uint64_t*>(elf.base + reloc.r_offset) = value; break;
|
||||||
|
}
|
||||||
|
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void relocate_elf(LoadedElf& elf, bool lazy_load)
|
||||||
|
{
|
||||||
|
if (elf.is_relocated)
|
||||||
|
return;
|
||||||
|
|
||||||
|
// relocate libraries
|
||||||
|
for (size_t i = 0;; i++)
|
||||||
|
{
|
||||||
|
auto& dynamic = elf.dynamics[i];
|
||||||
|
if (dynamic.d_tag == DT_NULL)
|
||||||
|
break;
|
||||||
|
if (dynamic.d_tag != DT_NEEDED)
|
||||||
|
continue;
|
||||||
|
relocate_elf(*reinterpret_cast<LoadedElf*>(dynamic.d_un.d_ptr), lazy_load);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (elf.is_relocated)
|
||||||
|
return;
|
||||||
|
|
||||||
|
// do "normal" relocations
|
||||||
|
if (elf.rel && elf.relent)
|
||||||
|
for (size_t i = 0; i < elf.relsz / elf.relent; i++)
|
||||||
|
handle_relocation(elf, *reinterpret_cast<ElfNativeRelocation*>(elf.rel + i * elf.relent));
|
||||||
|
if (elf.rela && elf.relaent)
|
||||||
|
for (size_t i = 0; i < elf.relasz / elf.relaent; i++)
|
||||||
|
handle_relocation(elf, *reinterpret_cast<ElfNativeRelocationA*>(elf.rela + i * elf.relaent));
|
||||||
|
|
||||||
|
// do jumprel relocations
|
||||||
|
if (elf.jmprel && elf.pltrelsz)
|
||||||
|
{
|
||||||
|
if (elf.pltrel != DT_REL && elf.pltrel != DT_RELA)
|
||||||
|
print_error_and_exit("invalid value for DT_PLTREL", 0);
|
||||||
|
|
||||||
|
if (!lazy_load)
|
||||||
|
{
|
||||||
|
switch (elf.pltrel)
|
||||||
|
{
|
||||||
|
case DT_REL:
|
||||||
|
for (size_t i = 0; i < elf.pltrelsz / sizeof(ElfNativeRelocation); i++)
|
||||||
|
handle_relocation(elf, reinterpret_cast<ElfNativeRelocation*>(elf.jmprel)[i]);
|
||||||
|
break;
|
||||||
|
case DT_RELA:
|
||||||
|
for (size_t i = 0; i < elf.pltrelsz / sizeof(ElfNativeRelocationA); i++)
|
||||||
|
handle_relocation(elf, reinterpret_cast<ElfNativeRelocationA*>(elf.jmprel)[i]);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
const size_t pltrelent = (elf.pltrel == DT_REL)
|
||||||
|
? sizeof(ElfNativeRelocation)
|
||||||
|
: sizeof(ElfNativeRelocationA);
|
||||||
|
|
||||||
|
for (size_t i = 0; i < elf.pltrelsz / pltrelent; i++)
|
||||||
|
{
|
||||||
|
const auto info = (elf.pltrel == DT_REL)
|
||||||
|
? reinterpret_cast<ElfNativeRelocation*>(elf.jmprel)[i].r_info
|
||||||
|
: reinterpret_cast<ElfNativeRelocationA*>(elf.jmprel)[i].r_info;
|
||||||
|
const auto offset = (elf.pltrel == DT_REL)
|
||||||
|
? reinterpret_cast<ElfNativeRelocation*>(elf.jmprel)[i].r_offset
|
||||||
|
: reinterpret_cast<ElfNativeRelocationA*>(elf.jmprel)[i].r_offset;
|
||||||
|
|
||||||
|
#if defined(__x86_64__)
|
||||||
|
if (ELF64_R_TYPE(info) != R_X86_64_JUMP_SLOT)
|
||||||
|
print_error_and_exit("jmprel relocation not R_X86_64_JUMP_SLOT", 0);
|
||||||
|
#elif defined(__i686__)
|
||||||
|
if (ELF32_R_TYPE(info) != R_386_JMP_SLOT)
|
||||||
|
print_error_and_exit("jmprel relocation not R_386_JMP_SLOT", 0);
|
||||||
|
#else
|
||||||
|
#error "unsupported architecture"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
*reinterpret_cast<uintptr_t*>(elf.base + offset) += elf.base;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
elf.is_relocated = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
extern "C"
|
||||||
|
__attribute__((used))
|
||||||
|
uintptr_t resolve_symbol(const LoadedElf& elf, uintptr_t plt_entry)
|
||||||
|
{
|
||||||
|
if (elf.pltrel == DT_REL)
|
||||||
|
return handle_relocation(elf, *reinterpret_cast<ElfNativeRelocation*>(elf.jmprel + plt_entry));
|
||||||
|
if (elf.pltrel == DT_RELA)
|
||||||
|
return handle_relocation(elf, reinterpret_cast<ElfNativeRelocationA*>(elf.jmprel)[plt_entry]);
|
||||||
|
print_error_and_exit("invalid value for DT_PLTREL", 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
static LoadedElf& load_elf(const char* path, int fd);
|
||||||
|
|
||||||
|
static void handle_dynamic(LoadedElf& elf)
|
||||||
|
{
|
||||||
|
uintptr_t pltgot = 0;
|
||||||
|
|
||||||
|
for (size_t i = 0;; i++)
|
||||||
|
{
|
||||||
|
auto& dynamic = elf.dynamics[i];
|
||||||
|
if (dynamic.d_tag == DT_NULL)
|
||||||
|
break;
|
||||||
|
|
||||||
|
switch (dynamic.d_tag)
|
||||||
|
{
|
||||||
|
case DT_PLTGOT: dynamic.d_un.d_ptr += elf.base; break;
|
||||||
|
case DT_HASH: dynamic.d_un.d_ptr += elf.base; break;
|
||||||
|
case DT_STRTAB: dynamic.d_un.d_ptr += elf.base; break;
|
||||||
|
case DT_SYMTAB: dynamic.d_un.d_ptr += elf.base; break;
|
||||||
|
case DT_RELA: dynamic.d_un.d_ptr += elf.base; break;
|
||||||
|
case DT_INIT: dynamic.d_un.d_ptr += elf.base; break;
|
||||||
|
case DT_FINI: dynamic.d_un.d_ptr += elf.base; break;
|
||||||
|
case DT_REL: dynamic.d_un.d_ptr += elf.base; break;
|
||||||
|
case DT_JMPREL: dynamic.d_un.d_ptr += elf.base; break;
|
||||||
|
case DT_INIT_ARRAY: dynamic.d_un.d_ptr += elf.base; break;
|
||||||
|
case DT_FINI_ARRAY: dynamic.d_un.d_ptr += elf.base; break;
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (dynamic.d_tag)
|
||||||
|
{
|
||||||
|
case DT_PLTRELSZ: elf.pltrelsz = dynamic.d_un.d_val; break;
|
||||||
|
case DT_PLTGOT: pltgot = dynamic.d_un.d_ptr; break;
|
||||||
|
case DT_HASH: elf.hash = dynamic.d_un.d_ptr; break;
|
||||||
|
case DT_STRTAB: elf.strtab = dynamic.d_un.d_ptr; break;
|
||||||
|
case DT_SYMTAB: elf.symtab = dynamic.d_un.d_ptr; break;
|
||||||
|
case DT_RELA: elf.rela = dynamic.d_un.d_ptr; break;
|
||||||
|
case DT_RELASZ: elf.relasz = dynamic.d_un.d_val; break;
|
||||||
|
case DT_RELAENT: elf.relaent = dynamic.d_un.d_val; break;
|
||||||
|
case DT_SYMENT: elf.syment = dynamic.d_un.d_val; break;
|
||||||
|
case DT_REL: elf.rel = dynamic.d_un.d_ptr; break;
|
||||||
|
case DT_RELSZ: elf.relsz = dynamic.d_un.d_val; break;
|
||||||
|
case DT_RELENT: elf.relent = dynamic.d_un.d_val; break;
|
||||||
|
case DT_PLTREL: elf.pltrel = dynamic.d_un.d_val; break;
|
||||||
|
case DT_JMPREL: elf.jmprel = dynamic.d_un.d_ptr; break;
|
||||||
|
case DT_INIT: elf.init = dynamic.d_un.d_ptr; break;
|
||||||
|
case DT_INIT_ARRAY: elf.init_array = dynamic.d_un.d_ptr; break;
|
||||||
|
case DT_INIT_ARRAYSZ: elf.init_arraysz = dynamic.d_un.d_val; break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (size_t i = 0;; i++)
|
||||||
|
{
|
||||||
|
auto& dynamic = elf.dynamics[i];
|
||||||
|
if (dynamic.d_tag == DT_NULL)
|
||||||
|
break;
|
||||||
|
if (dynamic.d_tag != DT_NEEDED)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
const char* library_dir = "/usr/lib/";
|
||||||
|
|
||||||
|
char path_buffer[PATH_MAX];
|
||||||
|
char* path_ptr = path_buffer;
|
||||||
|
|
||||||
|
const char* library_name = reinterpret_cast<const char*>(elf.strtab + dynamic.d_un.d_val);
|
||||||
|
if (library_name[0] != '/')
|
||||||
|
for (size_t i = 0; library_dir[i]; i++)
|
||||||
|
*path_ptr++ = library_dir[i];
|
||||||
|
for (size_t i = 0; library_name[i]; i++)
|
||||||
|
*path_ptr++ = library_name[i];
|
||||||
|
*path_ptr = '\0';
|
||||||
|
|
||||||
|
char realpath[PATH_MAX];
|
||||||
|
if (auto ret = syscall(SYS_REALPATH, path_buffer, realpath); ret < 0)
|
||||||
|
print_error_and_exit("realpath", ret);
|
||||||
|
|
||||||
|
int library_fd = syscall(SYS_OPEN, realpath, O_RDONLY);
|
||||||
|
if (library_fd < 0)
|
||||||
|
print_error_and_exit("could not open library", library_fd);
|
||||||
|
|
||||||
|
const auto& loaded_elf = load_elf(realpath, library_fd);
|
||||||
|
dynamic.d_un.d_ptr = reinterpret_cast<uintptr_t>(&loaded_elf);
|
||||||
|
|
||||||
|
syscall(SYS_CLOSE, library_fd);
|
||||||
|
}
|
||||||
|
|
||||||
|
// setup required GOT entries
|
||||||
|
reinterpret_cast<uintptr_t*>(pltgot)[0] = reinterpret_cast<uintptr_t>(elf.dynamics);
|
||||||
|
reinterpret_cast<uintptr_t*>(pltgot)[1] = reinterpret_cast<uintptr_t>(&elf);
|
||||||
|
reinterpret_cast<uintptr_t*>(pltgot)[2] = reinterpret_cast<uintptr_t>(&resolve_symbol_trampoline);
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool can_load_elf(int fd, const ElfNativeFileHeader& file_header, uintptr_t base)
|
||||||
|
{
|
||||||
|
for (size_t i = 0; i < file_header.e_phnum; i++)
|
||||||
|
{
|
||||||
|
ElfNativeProgramHeader program_header;
|
||||||
|
if (auto ret = syscall(SYS_PREAD, fd, &program_header, sizeof(program_header), file_header.e_phoff + i * file_header.e_phentsize); ret != sizeof(program_header))
|
||||||
|
print_error_and_exit("could not read program header", ret);
|
||||||
|
program_header.p_vaddr += base;
|
||||||
|
|
||||||
|
uintptr_t page_alinged_vaddr = program_header.p_vaddr & ~(uintptr_t)0xFFF;
|
||||||
|
size_t mmap_length = (program_header.p_vaddr + program_header.p_memsz) - page_alinged_vaddr;
|
||||||
|
|
||||||
|
sys_mmap_t mmap_args;
|
||||||
|
mmap_args.addr = reinterpret_cast<void*>(page_alinged_vaddr);
|
||||||
|
mmap_args.fildes = -1;
|
||||||
|
mmap_args.flags = MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE;
|
||||||
|
mmap_args.len = mmap_length;
|
||||||
|
mmap_args.off = 0;
|
||||||
|
mmap_args.prot = PROT_NONE;
|
||||||
|
|
||||||
|
auto ret = reinterpret_cast<void*>(syscall(SYS_MMAP, &mmap_args));
|
||||||
|
if (ret == MAP_FAILED)
|
||||||
|
return false;
|
||||||
|
syscall(SYS_MUNMAP, ret, mmap_length);
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void load_program_header(const ElfNativeProgramHeader& program_header, int fd, bool needs_writable)
|
||||||
|
{
|
||||||
|
if (program_header.p_type != PT_LOAD)
|
||||||
|
print_error_and_exit("trying to load non PT_LOAD program header", 0);
|
||||||
|
if (program_header.p_memsz < program_header.p_filesz)
|
||||||
|
print_error_and_exit("invalid program header, memsz lower than filesz", 0);
|
||||||
|
|
||||||
|
const int prot =
|
||||||
|
[&program_header]() -> int
|
||||||
|
{
|
||||||
|
int result = 0;
|
||||||
|
if (program_header.p_flags & PF_R)
|
||||||
|
result |= PROT_READ;
|
||||||
|
if (program_header.p_flags & PF_W)
|
||||||
|
result |= PROT_WRITE;
|
||||||
|
if (program_header.p_flags & PF_X)
|
||||||
|
result |= PROT_EXEC;
|
||||||
|
return result;
|
||||||
|
}();
|
||||||
|
|
||||||
|
const uintptr_t aligned_vaddr = program_header.p_vaddr & ~(uintptr_t)0xFFF;
|
||||||
|
|
||||||
|
sys_mmap_t mmap_args;
|
||||||
|
mmap_args.addr = reinterpret_cast<void*>(aligned_vaddr);
|
||||||
|
mmap_args.fildes = -1;
|
||||||
|
mmap_args.flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED;
|
||||||
|
mmap_args.len = (program_header.p_vaddr + program_header.p_memsz) - aligned_vaddr;
|
||||||
|
mmap_args.off = 0;
|
||||||
|
mmap_args.prot = prot | PROT_WRITE;
|
||||||
|
|
||||||
|
if (auto ret = syscall(SYS_MMAP, &mmap_args); ret != static_cast<long>(aligned_vaddr))
|
||||||
|
print_error_and_exit("could not load program header", ret);
|
||||||
|
if (auto ret = syscall(SYS_PREAD, fd, program_header.p_vaddr, program_header.p_filesz, program_header.p_offset); ret != static_cast<long>(program_header.p_filesz))
|
||||||
|
print_error_and_exit("could not load program header", ret);
|
||||||
|
|
||||||
|
return;
|
||||||
|
|
||||||
|
uintptr_t filesz = program_header.p_filesz;
|
||||||
|
|
||||||
|
if (program_header.p_filesz != program_header.p_memsz)
|
||||||
|
{
|
||||||
|
const uintptr_t data_end_vaddr = program_header.p_vaddr + program_header.p_filesz;
|
||||||
|
const uintptr_t zero_end_vaddr = program_header.p_vaddr + program_header.p_memsz;
|
||||||
|
|
||||||
|
uintptr_t start_vaddr = data_end_vaddr & ~(uintptr_t)0xFFF;
|
||||||
|
if (program_header.p_vaddr & 0xFFF)
|
||||||
|
start_vaddr = program_header.p_vaddr & ~(uintptr_t)0xFFF;
|
||||||
|
|
||||||
|
if (start_vaddr != data_end_vaddr)
|
||||||
|
{
|
||||||
|
const uintptr_t end_vaddr = (data_end_vaddr + 4095) & ~(uintptr_t)0xFFF;
|
||||||
|
const ptrdiff_t length = min(end_vaddr - start_vaddr, zero_end_vaddr - start_vaddr);
|
||||||
|
|
||||||
|
sys_mmap_t mmap_args;
|
||||||
|
mmap_args.addr = reinterpret_cast<void*>(start_vaddr);
|
||||||
|
mmap_args.fildes = -1;
|
||||||
|
mmap_args.flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED;
|
||||||
|
mmap_args.len = length;
|
||||||
|
mmap_args.off = 0;
|
||||||
|
mmap_args.prot = prot | PROT_WRITE;
|
||||||
|
|
||||||
|
if (auto ret = syscall(SYS_MMAP, &mmap_args); ret != static_cast<long>(start_vaddr))
|
||||||
|
print_error_and_exit("could not load program header", ret);
|
||||||
|
|
||||||
|
uintptr_t dummy_bytes = program_header.p_vaddr - start_vaddr;
|
||||||
|
if (program_header.p_vaddr & 0xFFF)
|
||||||
|
dummy_bytes = 0;
|
||||||
|
|
||||||
|
const uintptr_t data_vaddr = program_header.p_vaddr + dummy_bytes;
|
||||||
|
const ptrdiff_t data_bytes = data_end_vaddr - data_vaddr;
|
||||||
|
const uintptr_t data_offset = program_header.p_offset + dummy_bytes;
|
||||||
|
if (auto ret = syscall(SYS_PREAD, fd, data_vaddr, data_bytes, data_offset); ret != data_bytes)
|
||||||
|
print_error_and_exit("could not load program header", ret);
|
||||||
|
|
||||||
|
if (!(prot & PROT_WRITE) && !needs_writable)
|
||||||
|
{
|
||||||
|
// FIXME: Implement mprotect so PROT_WRITE can be removed
|
||||||
|
//syscall(SYS_MPROTECT, start_vaddr, length, prot);
|
||||||
|
}
|
||||||
|
|
||||||
|
filesz -= data_bytes;
|
||||||
|
start_vaddr += 4096;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (start_vaddr < zero_end_vaddr)
|
||||||
|
{
|
||||||
|
sys_mmap_t mmap_args;
|
||||||
|
mmap_args.addr = reinterpret_cast<void*>(start_vaddr);
|
||||||
|
mmap_args.fildes = -1;
|
||||||
|
mmap_args.flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED;
|
||||||
|
mmap_args.len = zero_end_vaddr - start_vaddr;
|
||||||
|
mmap_args.off = 0;
|
||||||
|
mmap_args.prot = prot | (needs_writable ? PROT_WRITE : 0);
|
||||||
|
|
||||||
|
if (auto ret = syscall(SYS_MMAP, &mmap_args); ret != static_cast<long>(start_vaddr))
|
||||||
|
print_error_and_exit("could not load program header", ret);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (filesz)
|
||||||
|
{
|
||||||
|
sys_mmap_t mmap_args;
|
||||||
|
mmap_args.addr = reinterpret_cast<void*>(program_header.p_vaddr);
|
||||||
|
mmap_args.fildes = fd;
|
||||||
|
mmap_args.flags = MAP_PRIVATE | MAP_FIXED;
|
||||||
|
mmap_args.len = filesz;
|
||||||
|
mmap_args.off = program_header.p_offset;
|
||||||
|
mmap_args.prot = prot | (needs_writable ? PROT_WRITE : 0);
|
||||||
|
|
||||||
|
if (auto ret = syscall(SYS_MMAP, &mmap_args); ret != static_cast<long>(program_header.p_vaddr))
|
||||||
|
print_error_and_exit("could not load program header", ret);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static LoadedElf s_loaded_files[128];
|
||||||
|
static size_t s_loaded_file_count = 0;
|
||||||
|
|
||||||
|
static LoadedElf* get_libc_elf()
|
||||||
|
{
|
||||||
|
for (size_t i = 0; i < s_loaded_file_count; i++)
|
||||||
|
if (strcmp(s_loaded_files[i].path, "/usr/lib/libc.so") == 0)
|
||||||
|
return &s_loaded_files[i];
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
static LoadedElf* get_libgcc_elf()
|
||||||
|
{
|
||||||
|
for (size_t i = 0; i < s_loaded_file_count; i++)
|
||||||
|
if (strcmp(s_loaded_files[i].path, "/usr/lib/libgcc_s.so") == 0)
|
||||||
|
return &s_loaded_files[i];
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
static LoadedElf& load_elf(const char* path, int fd)
|
||||||
|
{
|
||||||
|
for (size_t i = 0; i < s_loaded_file_count; i++)
|
||||||
|
if (strcmp(s_loaded_files[i].path, path) == 0)
|
||||||
|
return s_loaded_files[i];
|
||||||
|
|
||||||
|
ElfNativeFileHeader file_header;
|
||||||
|
if (auto ret = syscall(SYS_READ, fd, &file_header, sizeof(file_header)); ret != sizeof(file_header))
|
||||||
|
print_error_and_exit("could not read file header", ret);
|
||||||
|
|
||||||
|
validate_program_header(file_header);
|
||||||
|
|
||||||
|
uintptr_t base = 0;
|
||||||
|
if (file_header.e_type == ET_DYN)
|
||||||
|
{
|
||||||
|
#if defined(__x86_64__)
|
||||||
|
constexpr uintptr_t base_mask = 0x7FFFFFFFF000;
|
||||||
|
#elif defined(__i686__)
|
||||||
|
constexpr uintptr_t base_mask = 0x7FFFF000;
|
||||||
|
#else
|
||||||
|
#error "unsupported architecture"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// FIXME: This is very hacky :D
|
||||||
|
do {
|
||||||
|
base = (get_random_uptr() & base_mask) + 0x100000;
|
||||||
|
} while (!can_load_elf(fd, file_header, base));
|
||||||
|
}
|
||||||
|
|
||||||
|
bool needs_writable = false;
|
||||||
|
bool has_dynamic_pheader = false;
|
||||||
|
ElfNativeProgramHeader dynamic_pheader;
|
||||||
|
for (size_t i = 0; i < file_header.e_phnum; i++)
|
||||||
|
{
|
||||||
|
if (auto ret = syscall(SYS_PREAD, fd, &dynamic_pheader, sizeof(dynamic_pheader), file_header.e_phoff + i * file_header.e_phentsize); ret != sizeof(dynamic_pheader))
|
||||||
|
print_error_and_exit("could not read program header", ret);
|
||||||
|
if (dynamic_pheader.p_type != PT_DYNAMIC)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
sys_mmap_t mmap_args;
|
||||||
|
mmap_args.addr = nullptr;
|
||||||
|
mmap_args.fildes = -1;
|
||||||
|
mmap_args.flags = MAP_ANONYMOUS | MAP_PRIVATE;
|
||||||
|
mmap_args.len = dynamic_pheader.p_memsz;
|
||||||
|
mmap_args.off = 0;
|
||||||
|
mmap_args.prot = PROT_READ | PROT_WRITE;
|
||||||
|
|
||||||
|
const auto uaddr = syscall(SYS_MMAP, &mmap_args);
|
||||||
|
if (uaddr < 0)
|
||||||
|
print_error_and_exit("could not map dynamic header", uaddr);
|
||||||
|
if (auto ret = syscall(SYS_PREAD, fd, uaddr, dynamic_pheader.p_filesz, dynamic_pheader.p_offset); ret != static_cast<long>(dynamic_pheader.p_filesz))
|
||||||
|
print_error_and_exit("could not read dynamic header", ret);
|
||||||
|
|
||||||
|
const auto* dynamics = reinterpret_cast<ElfNativeDynamic*>(uaddr);
|
||||||
|
for (size_t j = 0;; j++)
|
||||||
|
{
|
||||||
|
const auto& dynamic = dynamics[j];
|
||||||
|
if (dynamic.d_tag == DT_NULL)
|
||||||
|
break;
|
||||||
|
if (dynamic.d_tag != DT_TEXTREL)
|
||||||
|
continue;
|
||||||
|
needs_writable = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
syscall(SYS_MUNMAP, uaddr, dynamic_pheader.p_memsz);
|
||||||
|
|
||||||
|
has_dynamic_pheader = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (size_t i = 0; i < file_header.e_phnum; i++)
|
||||||
|
{
|
||||||
|
ElfNativeProgramHeader program_header;
|
||||||
|
if (auto ret = syscall(SYS_PREAD, fd, &program_header, sizeof(program_header), file_header.e_phoff + i * file_header.e_phentsize); ret != sizeof(program_header))
|
||||||
|
print_error_and_exit("could not read program header", ret);
|
||||||
|
|
||||||
|
switch (program_header.p_type)
|
||||||
|
{
|
||||||
|
case PT_NULL:
|
||||||
|
case PT_DYNAMIC:
|
||||||
|
case PT_INTERP:
|
||||||
|
case PT_NOTE:
|
||||||
|
case PT_PHDR:
|
||||||
|
break;
|
||||||
|
case PT_LOAD:
|
||||||
|
program_header.p_vaddr += base;
|
||||||
|
load_program_header(program_header, fd, needs_writable);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
print(STDERR_FILENO, "unsupported program header type ");
|
||||||
|
print_uint(STDERR_FILENO, program_header.p_type);
|
||||||
|
print_error_and_exit("", 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
auto& elf = s_loaded_files[s_loaded_file_count++];
|
||||||
|
elf.base = base;
|
||||||
|
elf.dynamics = nullptr;
|
||||||
|
memcpy(&elf.file_header, &file_header, sizeof(file_header));
|
||||||
|
strcpy(elf.path, path);
|
||||||
|
|
||||||
|
if (has_dynamic_pheader)
|
||||||
|
{
|
||||||
|
sys_mmap_t mmap_args;
|
||||||
|
mmap_args.addr = nullptr;
|
||||||
|
mmap_args.fildes = -1;
|
||||||
|
mmap_args.flags = MAP_ANONYMOUS | MAP_PRIVATE;
|
||||||
|
mmap_args.len = dynamic_pheader.p_memsz;
|
||||||
|
mmap_args.off = 0;
|
||||||
|
mmap_args.prot = PROT_READ | PROT_WRITE;
|
||||||
|
|
||||||
|
const auto uaddr = syscall(SYS_MMAP, &mmap_args);
|
||||||
|
if (uaddr < 0)
|
||||||
|
print_error_and_exit("could not map dynamic header", uaddr);
|
||||||
|
if (auto ret = syscall(SYS_PREAD, fd, uaddr, dynamic_pheader.p_filesz, dynamic_pheader.p_offset); ret != static_cast<long>(dynamic_pheader.p_filesz))
|
||||||
|
print_error_and_exit("could not read dynamic header", ret);
|
||||||
|
|
||||||
|
elf.dynamics = reinterpret_cast<ElfNativeDynamic*>(uaddr);
|
||||||
|
handle_dynamic(elf);
|
||||||
|
}
|
||||||
|
|
||||||
|
return elf;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void call_init_funcs(LoadedElf& elf, char** envp, bool skip)
|
||||||
|
{
|
||||||
|
if (elf.has_called_init)
|
||||||
|
return;
|
||||||
|
|
||||||
|
if (elf.dynamics)
|
||||||
|
{
|
||||||
|
for (size_t i = 0;; i++)
|
||||||
|
{
|
||||||
|
const auto& dynamic = elf.dynamics[i];
|
||||||
|
if (dynamic.d_tag == DT_NULL)
|
||||||
|
break;
|
||||||
|
if (dynamic.d_tag == DT_NEEDED)
|
||||||
|
call_init_funcs(*reinterpret_cast<LoadedElf*>(dynamic.d_un.d_ptr), envp, false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (elf.has_called_init || skip)
|
||||||
|
return;
|
||||||
|
|
||||||
|
using init_t = void(*)();
|
||||||
|
if (elf.init)
|
||||||
|
reinterpret_cast<init_t>(elf.init)();
|
||||||
|
for (size_t i = 0; i < elf.init_arraysz / sizeof(init_t); i++)
|
||||||
|
reinterpret_cast<init_t*>(elf.init_array)[i]();
|
||||||
|
|
||||||
|
if (strcmp(elf.path, "/usr/lib/libc.so") == 0)
|
||||||
|
{
|
||||||
|
const uintptr_t init_libc = get_symbol_address(elf, "_init_libc");
|
||||||
|
if (init_libc != SYM_NOT_FOUND)
|
||||||
|
{
|
||||||
|
using init_libc_t = void(*)(char**);
|
||||||
|
reinterpret_cast<init_libc_t>(init_libc)(envp);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
elf.has_called_init = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
extern "C"
|
||||||
|
__attribute__((used, noreturn))
|
||||||
|
int _entry(int argc, char** argv, char** envp, int fd)
|
||||||
|
{
|
||||||
|
const bool invoked_directly = (fd < 0);
|
||||||
|
if (invoked_directly)
|
||||||
|
{
|
||||||
|
if (argc < 2)
|
||||||
|
print_error_and_exit("missing program name", 0);
|
||||||
|
|
||||||
|
argc--;
|
||||||
|
argv++;
|
||||||
|
|
||||||
|
fd = syscall(SYS_OPEN, argv[0], O_RDONLY);
|
||||||
|
if (fd < 0)
|
||||||
|
print_error_and_exit("could not open program", fd);
|
||||||
|
}
|
||||||
|
|
||||||
|
init_random();
|
||||||
|
auto elf = load_elf(argv[0], fd);
|
||||||
|
syscall(SYS_CLOSE, fd);
|
||||||
|
fini_random();
|
||||||
|
|
||||||
|
relocate_elf(elf, true);
|
||||||
|
call_init_funcs(elf, envp, true);
|
||||||
|
call_entry_point(argc, argv, envp, elf.base + elf.file_header.e_entry);
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,174 @@
|
||||||
|
#include "utils.h"
|
||||||
|
|
||||||
|
#include <errno.h>
|
||||||
|
#include <fcntl.h>
|
||||||
|
#include <unistd.h>
|
||||||
|
|
||||||
|
void print(int fd, const char* buffer)
|
||||||
|
{
|
||||||
|
size_t len = 0;
|
||||||
|
while (buffer[len])
|
||||||
|
len++;
|
||||||
|
syscall(SYS_WRITE, fd, buffer, len);
|
||||||
|
}
|
||||||
|
|
||||||
|
static const char* errno_to_string(int error);
|
||||||
|
|
||||||
|
[[noreturn]] void print_error_and_exit(const char* message, int error)
|
||||||
|
{
|
||||||
|
print(STDERR_FILENO, message);
|
||||||
|
if (error < 0)
|
||||||
|
{
|
||||||
|
print(STDERR_FILENO, ": ");
|
||||||
|
print(STDERR_FILENO, errno_to_string(-error));
|
||||||
|
}
|
||||||
|
print(STDERR_FILENO, "\n");
|
||||||
|
|
||||||
|
syscall(SYS_EXIT, 1);
|
||||||
|
__builtin_unreachable();
|
||||||
|
}
|
||||||
|
|
||||||
|
int strcmp(const char* s1, const char* s2)
|
||||||
|
{
|
||||||
|
const unsigned char* u1 = reinterpret_cast<const unsigned char*>(s1);
|
||||||
|
const unsigned char* u2 = reinterpret_cast<const unsigned char*>(s2);
|
||||||
|
for (; *u1 && *u2; u1++, u2++)
|
||||||
|
if (*u1 != *u2)
|
||||||
|
break;
|
||||||
|
return *u1 - *u2;
|
||||||
|
}
|
||||||
|
|
||||||
|
char* strcpy(char* __restrict s1, const char* __restrict s2)
|
||||||
|
{
|
||||||
|
size_t i = 0;
|
||||||
|
for (; s2[i]; i++)
|
||||||
|
s1[i] = s2[i];
|
||||||
|
s1[i] = '\0';
|
||||||
|
return s1;
|
||||||
|
}
|
||||||
|
|
||||||
|
void* memcpy(void* __restrict dstp, const void* __restrict srcp, size_t n)
|
||||||
|
{
|
||||||
|
unsigned char* dst = static_cast<unsigned char*>(dstp);
|
||||||
|
const unsigned char* src = static_cast<const unsigned char*>(srcp);
|
||||||
|
for (size_t i = 0; i < n; i++)
|
||||||
|
dst[i] = src[i];
|
||||||
|
return dstp;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int s_random_fd;
|
||||||
|
|
||||||
|
void init_random()
|
||||||
|
{
|
||||||
|
s_random_fd = syscall(SYS_OPEN, "/dev/random", O_RDONLY);
|
||||||
|
if (s_random_fd < 0)
|
||||||
|
print_error_and_exit("could not open /dev/random", s_random_fd);
|
||||||
|
}
|
||||||
|
|
||||||
|
void fini_random()
|
||||||
|
{
|
||||||
|
auto ret = syscall(SYS_CLOSE, s_random_fd);
|
||||||
|
if (ret < 0)
|
||||||
|
print_error_and_exit("could not close /dev/random", ret);
|
||||||
|
}
|
||||||
|
|
||||||
|
uintptr_t get_random_uptr()
|
||||||
|
{
|
||||||
|
uintptr_t result;
|
||||||
|
if (auto ret = syscall(SYS_READ, s_random_fd, &result, sizeof(result)); ret != sizeof(result))
|
||||||
|
print_error_and_exit("could not read from /dev/random", ret);
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
static const char* errno_to_string(int error)
|
||||||
|
{
|
||||||
|
switch (error)
|
||||||
|
{
|
||||||
|
case 0: return "Success";
|
||||||
|
case E2BIG: return "Argument list too long.";
|
||||||
|
case EACCES: return "Permission denied.";
|
||||||
|
case EADDRINUSE: return "Address in use.";
|
||||||
|
case EADDRNOTAVAIL: return "Address not available.";
|
||||||
|
case EAFNOSUPPORT: return "Address family not supported.";
|
||||||
|
case EAGAIN: return "Resource unavailable, try again.";
|
||||||
|
case EALREADY: return "Connection already in progress.";
|
||||||
|
case EBADF: return "Bad file descriptor.";
|
||||||
|
case EBADMSG: return "Bad message.";
|
||||||
|
case EBUSY: return "Device or resource busy.";
|
||||||
|
case ECANCELED: return "Operation canceled.";
|
||||||
|
case ECHILD: return "No child processes.";
|
||||||
|
case ECONNABORTED: return "Connection aborted.";
|
||||||
|
case ECONNREFUSED: return "Connection refused.";
|
||||||
|
case ECONNRESET: return "Connection reset.";
|
||||||
|
case EDEADLK: return "Resource deadlock would occur.";
|
||||||
|
case EDESTADDRREQ: return "Destination address required.";
|
||||||
|
case EDOM: return "Mathematics argument out of domain of function.";
|
||||||
|
case EDQUOT: return "Reserved.";
|
||||||
|
case EEXIST: return "File exists.";
|
||||||
|
case EFAULT: return "Bad address.";
|
||||||
|
case EFBIG: return "File too large.";
|
||||||
|
case EHOSTUNREACH: return "Host is unreachable.";
|
||||||
|
case EIDRM: return "Identifier removed.";
|
||||||
|
case EILSEQ: return "Illegal byte sequence.";
|
||||||
|
case EINPROGRESS: return "Operation in progress.";
|
||||||
|
case EINTR: return "Interrupted function.";
|
||||||
|
case EINVAL: return "Invalid argument.";
|
||||||
|
case EIO: return "I/O error.";
|
||||||
|
case EISCONN: return "Socket is connected.";
|
||||||
|
case EISDIR: return "Is a directory.";
|
||||||
|
case ELOOP: return "Too many levels of symbolic links.";
|
||||||
|
case EMFILE: return "File descriptor value too large.";
|
||||||
|
case EMLINK: return "Too many links.";
|
||||||
|
case EMSGSIZE: return "Message too large.";
|
||||||
|
case EMULTIHOP: return "Reserved.";
|
||||||
|
case ENAMETOOLONG: return "Filename too long.";
|
||||||
|
case ENETDOWN: return "Network is down.";
|
||||||
|
case ENETRESET: return "Connection aborted by network.";
|
||||||
|
case ENETUNREACH: return "Network unreachable.";
|
||||||
|
case ENFILE: return "Too many files open in system.";
|
||||||
|
case ENOBUFS: return "No buffer space available.";
|
||||||
|
case ENODATA: return "No message is available on the STREAM head read queue.";
|
||||||
|
case ENODEV: return "No such device.";
|
||||||
|
case ENOENT: return "No such file or directory.";
|
||||||
|
case ENOEXEC: return "Executable file format error.";
|
||||||
|
case ENOLCK: return "No locks available.";
|
||||||
|
case ENOLINK: return "Reserved.";
|
||||||
|
case ENOMEM: return "Not enough space.";
|
||||||
|
case ENOMSG: return "No message of the desired type.";
|
||||||
|
case ENOPROTOOPT: return "Protocol not available.";
|
||||||
|
case ENOSPC: return "No space left on device.";
|
||||||
|
case ENOSR: return "No STREAM resources.";
|
||||||
|
case ENOSTR: return "Not a STREAM.";
|
||||||
|
case ENOSYS: return "Functionality not supported.";
|
||||||
|
case ENOTCONN: return "The socket is not connected.";
|
||||||
|
case ENOTDIR: return "Not a directory or a symbolic link to a directory.";
|
||||||
|
case ENOTEMPTY: return "Directory not empty.";
|
||||||
|
case ENOTRECOVERABLE: return "State not recoverable.";
|
||||||
|
case ENOTSOCK: return "Not a socket.";
|
||||||
|
case ENOTSUP: return "Not supported.";
|
||||||
|
case ENOTTY: return "Inappropriate I/O control operation.";
|
||||||
|
case ENXIO: return "No such device or address.";
|
||||||
|
case EOPNOTSUPP: return "Operation not supported on socket .";
|
||||||
|
case EOVERFLOW: return "Value too large to be stored in data type.";
|
||||||
|
case EOWNERDEAD: return "Previous owner died.";
|
||||||
|
case EPERM: return "Operation not permitted.";
|
||||||
|
case EPIPE: return "Broken pipe.";
|
||||||
|
case EPROTO: return "Protocol error.";
|
||||||
|
case EPROTONOSUPPORT: return "Protocol not supported.";
|
||||||
|
case EPROTOTYPE: return "Protocol wrong type for socket.";
|
||||||
|
case ERANGE: return "Result too large.";
|
||||||
|
case EROFS: return "Read-only file system.";
|
||||||
|
case ESPIPE: return "Invalid seek.";
|
||||||
|
case ESRCH: return "No such process.";
|
||||||
|
case ESTALE: return "Reserved.";
|
||||||
|
case ETIME: return "Stream ioctl() timeout.";
|
||||||
|
case ETIMEDOUT: return "Connection timed out.";
|
||||||
|
case ETXTBSY: return "Text file busy.";
|
||||||
|
case EWOULDBLOCK: return "Operation would block.";
|
||||||
|
case EXDEV: return "Cross-device link.";
|
||||||
|
case EEXISTS: return "File exists";
|
||||||
|
case ENOTBLK: return "Block device required";
|
||||||
|
case EUNKNOWN: return "Unknown error";
|
||||||
|
}
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,49 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <BAN/Traits.h>
|
||||||
|
#include <kernel/Syscall.h>
|
||||||
|
|
||||||
|
#include <stddef.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
inline constexpr T min(T a, T b)
|
||||||
|
{
|
||||||
|
return a < b ? a : b;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename T>
|
||||||
|
inline constexpr T max(T a, T b)
|
||||||
|
{
|
||||||
|
return a > b ? a : b;
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename... Ts> requires (sizeof...(Ts) <= 5) && ((BAN::is_integral_v<Ts> || BAN::is_pointer_v<Ts>) && ...)
|
||||||
|
inline auto syscall(long syscall, Ts... args)
|
||||||
|
{
|
||||||
|
return Kernel::syscall(syscall, (uintptr_t)args...);
|
||||||
|
}
|
||||||
|
|
||||||
|
void print(int fd, const char* buffer);
|
||||||
|
|
||||||
|
[[noreturn]] void print_error_and_exit(const char* message, int error);
|
||||||
|
|
||||||
|
template<BAN::unsigned_integral T>
|
||||||
|
inline void print_uint(int fd, T val, uint8_t base = 10)
|
||||||
|
{
|
||||||
|
constexpr auto get_base_char = [](T val) { return ((val < 10) ? '0' : 'A' - 10) + val; };
|
||||||
|
|
||||||
|
char buffer[32];
|
||||||
|
char* ptr = buffer + sizeof(buffer);
|
||||||
|
*--ptr = '\0';
|
||||||
|
do { *--ptr = get_base_char(val % base); val /= base; } while (val);
|
||||||
|
print(fd, ptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
int strcmp(const char* s1, const char* s2);
|
||||||
|
char* strcpy(char* __restrict s1, const char* __restrict s2);
|
||||||
|
void* memcpy(void* __restrict s1, const void* __restrict s2, size_t n);
|
||||||
|
|
||||||
|
void init_random();
|
||||||
|
void fini_random();
|
||||||
|
uintptr_t get_random_uptr();
|
||||||
Loading…
Reference in New Issue