253 lines
8.4 KiB
C
253 lines
8.4 KiB
C
#include <zinnia/alloc.h>
|
|
#include <zinnia/assert.h>
|
|
#include <zinnia/elf.h>
|
|
#include <zinnia/errno.h>
|
|
#include <zinnia/mman.h>
|
|
#include <zinnia/percpu.h>
|
|
#include <zinnia/pmap.h>
|
|
#include <zinnia/print.h>
|
|
#include <zinnia/sched.h>
|
|
#include <zinnia/utils.h>
|
|
#include <zinnia/vfs.h>
|
|
#include <zinnia/vma.h>
|
|
#include <zinnia/vmo.h>
|
|
#include <bits/elf.h>
|
|
#include <stdckdint.h>
|
|
|
|
errno_t elf_load(struct exec_info* info, struct task** out) {
|
|
errno_t err;
|
|
|
|
size_t read;
|
|
elf_ehdr_t ehdr = {};
|
|
err = vmo_read(info->file_obj, 0, &ehdr, sizeof(ehdr), &read);
|
|
if (err)
|
|
return err;
|
|
if (read != sizeof(ehdr))
|
|
return ENOEXEC;
|
|
|
|
// Check if the file is an ELF.
|
|
if (memcmp(ehdr.e_ident, ELF_MAG, sizeof(ELF_MAG)) != 0)
|
|
return EINVAL;
|
|
if (ehdr.e_ident[EI_VERSION] != EV_CURRENT)
|
|
return EINVAL;
|
|
if (ehdr.e_ident[EI_CLASS] != ELF_ARCH_CLASS)
|
|
return EINVAL;
|
|
if (ehdr.e_ident[EI_DATA] != ELF_ARCH_DATA)
|
|
return EINVAL;
|
|
if (ehdr.e_machine != ELF_ARCH_MACHINE)
|
|
return EINVAL;
|
|
if (ehdr.e_type != ET_EXEC)
|
|
return EINVAL;
|
|
if (!arch_mem_addr_is_user(ehdr.e_entry))
|
|
return ENOEXEC;
|
|
|
|
const size_t phdrs_size = (size_t)ehdr.e_phnum * ehdr.e_phentsize;
|
|
uintptr_t phdrs_end;
|
|
if (ehdr.e_phentsize < sizeof(elf_phdr_t) || ehdr.e_phnum == 0 || phdrs_size > 64 * 1024)
|
|
return ENOEXEC;
|
|
if (ckd_add(&phdrs_end, ehdr.e_phoff, phdrs_size))
|
|
return ENOEXEC;
|
|
|
|
const size_t page_size = arch_mem_page_size();
|
|
uintptr_t phdr_addr = 0;
|
|
|
|
for (size_t i = 0; i < ehdr.e_phnum; i++) {
|
|
elf_phdr_t phdr = {};
|
|
err = vmo_read(info->file_obj, (ehdr.e_phoff + (i * ehdr.e_phentsize)), &phdr, sizeof(phdr), &read);
|
|
if (err)
|
|
return err;
|
|
if (read != sizeof(phdr))
|
|
return ENOEXEC;
|
|
|
|
if (phdr.p_type == PT_PHDR)
|
|
phdr_addr = phdr.p_vaddr;
|
|
|
|
if (phdr.p_type == PT_LOAD) {
|
|
if (phdr.p_memsz == 0)
|
|
continue;
|
|
if (phdr.p_filesz > phdr.p_memsz)
|
|
return ENOEXEC;
|
|
|
|
uintptr_t seg_end;
|
|
if (ckd_add(&seg_end, phdr.p_vaddr, phdr.p_memsz))
|
|
return ENOEXEC;
|
|
if (!arch_mem_addr_is_user(phdr.p_vaddr) || !arch_mem_addr_is_user(seg_end - 1))
|
|
return ENOEXEC;
|
|
|
|
if (phdr.p_align > 1 && phdr.p_offset % phdr.p_align != phdr.p_vaddr % phdr.p_align)
|
|
return ENOEXEC;
|
|
|
|
if (phdr_addr == 0 && ehdr.e_phoff >= phdr.p_offset && phdrs_end - phdr.p_offset <= phdr.p_filesz)
|
|
phdr_addr = phdr.p_vaddr + (ehdr.e_phoff - phdr.p_offset);
|
|
|
|
enum prot_flags prot = 0;
|
|
if (phdr.p_flags & PF_R)
|
|
prot |= PROT_READ;
|
|
if (phdr.p_flags & PF_W)
|
|
prot |= PROT_WRITE;
|
|
if (phdr.p_flags & PF_X)
|
|
prot |= PROT_EXEC;
|
|
|
|
const uintptr_t misalign = phdr.p_vaddr & (page_size - 1);
|
|
const uintptr_t map_address = phdr.p_vaddr - misalign;
|
|
const size_t backed_map_size = (phdr.p_filesz + misalign + page_size - 1) & ~(page_size - 1);
|
|
const size_t total_map_size = (phdr.p_memsz + misalign + page_size - 1) & ~(page_size - 1);
|
|
|
|
// Copy the file data into its own mapping.
|
|
struct paged_vmo* phdr_obj;
|
|
err = vmo_new_phys(&phdr_obj);
|
|
if (err)
|
|
return err;
|
|
|
|
err = vmo_copy(&phdr_obj->object, phdr.p_offset, info->file_obj, phdr.p_offset, phdr.p_filesz, nullptr);
|
|
if (err) {
|
|
vmo_unref(&phdr_obj->object);
|
|
return err;
|
|
}
|
|
|
|
// We map more than we copied so the rest is filled with zeroed pages.
|
|
err = vma_map(info->space, &phdr_obj->object, phdr.p_vaddr, phdr.p_memsz, prot, phdr.p_offset);
|
|
vmo_unref(&phdr_obj->object);
|
|
if (err)
|
|
return err;
|
|
}
|
|
}
|
|
|
|
const uintptr_t highest = ((uintptr_t)1 << (mem_high_shift() - 1)) - page_size;
|
|
const size_t stack_size = 2 * 1024 * 1024; // 2MiB
|
|
const uintptr_t stack_start = highest - stack_size;
|
|
|
|
// Allocate stack.
|
|
struct paged_vmo* stack;
|
|
err = vmo_new_phys(&stack);
|
|
if (err)
|
|
return err;
|
|
|
|
// Fill in stack info.
|
|
uintptr_t stack_off = stack_size;
|
|
|
|
// TODO: Instead of allocating, calculate it on the fly.
|
|
size_t num_envp = 0;
|
|
for (const char** ptr = info->envp; *ptr != nullptr; ptr++) {
|
|
num_envp++;
|
|
}
|
|
size_t num_argv = 0;
|
|
for (const char** ptr = info->argv; *ptr != nullptr; ptr++) {
|
|
num_argv++;
|
|
}
|
|
|
|
size_t strings_size = 0;
|
|
for (size_t env = 0; env < num_envp; env++)
|
|
strings_size += strlen(info->envp[env]) + 1;
|
|
for (size_t arg = 0; arg < num_argv; arg++)
|
|
strings_size += strlen(info->argv[arg]) + 1;
|
|
|
|
uintptr_t* envp_offsets = mem_alloc(num_envp * sizeof(uintptr_t), 0);
|
|
uintptr_t* argv_offsets = mem_alloc(num_argv * sizeof(uintptr_t), 0);
|
|
if ((num_envp && !envp_offsets) || (num_argv && !argv_offsets)) {
|
|
mem_free(envp_offsets);
|
|
mem_free(argv_offsets);
|
|
vmo_unref(&stack->object);
|
|
return ENOMEM;
|
|
}
|
|
|
|
for (size_t env = 0; env < num_envp; env++) {
|
|
const char nul = 0;
|
|
stack_off -= 1;
|
|
vmo_write(&stack->object, stack_off, &nul, sizeof(nul), nullptr);
|
|
|
|
const size_t len = strlen(info->envp[env]);
|
|
stack_off -= len;
|
|
vmo_write(&stack->object, stack_off, info->envp[env], len, nullptr);
|
|
|
|
envp_offsets[env] = stack_start + stack_off;
|
|
}
|
|
|
|
for (size_t arg = 0; arg < num_argv; arg++) {
|
|
const char nul = 0;
|
|
stack_off -= 1;
|
|
vmo_write(&stack->object, stack_off, &nul, sizeof(nul), nullptr);
|
|
|
|
const size_t len = strlen(info->argv[arg]);
|
|
stack_off -= len;
|
|
vmo_write(&stack->object, stack_off, info->argv[arg], len, nullptr);
|
|
|
|
argv_offsets[arg] = stack_start + stack_off;
|
|
}
|
|
|
|
stack_off = ALIGN_DOWN(stack_off, 16);
|
|
|
|
// Align the stack if argc + argv + envp does not add up to 16 byte alignment.
|
|
if ((1 + num_argv + num_envp) & 1) {
|
|
stack_off -= sizeof(uintptr_t);
|
|
uintptr_t zero = 0;
|
|
vmo_write(&stack->object, stack_off, &zero, sizeof(zero), nullptr);
|
|
}
|
|
|
|
#define WRITE_AUXV(auxv, value) \
|
|
do { \
|
|
stack_off -= sizeof(uintptr_t); \
|
|
uintptr_t auxv_val = value; \
|
|
vmo_write(&stack->object, stack_off, &auxv_val, sizeof(uintptr_t), nullptr); \
|
|
stack_off -= sizeof(uintptr_t); \
|
|
auxv_val = auxv; \
|
|
vmo_write(&stack->object, stack_off, &auxv_val, sizeof(uintptr_t), nullptr); \
|
|
} while (0)
|
|
|
|
// Write auxiliary values.
|
|
WRITE_AUXV(AT_NULL, 0);
|
|
WRITE_AUXV(AT_SECURE, 0);
|
|
WRITE_AUXV(AT_PHNUM, ehdr.e_phnum);
|
|
WRITE_AUXV(AT_PHENT, ehdr.e_phentsize);
|
|
WRITE_AUXV(AT_ENTRY, ehdr.e_entry);
|
|
if (phdr_addr)
|
|
WRITE_AUXV(AT_PHDR, phdr_addr);
|
|
|
|
// envp pointers.
|
|
stack_off -= sizeof(uintptr_t);
|
|
const uintptr_t zero = 0;
|
|
vmo_write(&stack->object, stack_off, &zero, sizeof(zero), nullptr);
|
|
for (size_t env = num_envp; env > 0; env--) {
|
|
stack_off -= sizeof(uintptr_t);
|
|
vmo_write(&stack->object, stack_off, &envp_offsets[env - 1], sizeof(envp_offsets[env - 1]), nullptr);
|
|
}
|
|
|
|
// argv pointers.
|
|
stack_off -= sizeof(uintptr_t);
|
|
vmo_write(&stack->object, stack_off, &zero, sizeof(zero), nullptr);
|
|
for (size_t arg = num_argv; arg > 0; arg--) {
|
|
stack_off -= sizeof(uintptr_t);
|
|
vmo_write(&stack->object, stack_off, &argv_offsets[arg - 1], sizeof(argv_offsets[arg - 1]), nullptr);
|
|
}
|
|
|
|
mem_free(envp_offsets);
|
|
mem_free(argv_offsets);
|
|
|
|
// argc
|
|
stack_off -= sizeof(uintptr_t);
|
|
uintptr_t argc = num_argv;
|
|
vmo_write(&stack->object, stack_off, &argc, sizeof(argc), nullptr);
|
|
|
|
err = vma_map(info->space, &stack->object, stack_start, stack_size, PROT_READ | PROT_WRITE, 0);
|
|
vmo_unref(&stack->object);
|
|
if (err)
|
|
return err;
|
|
|
|
struct task_start_info* start_info = mem_alloc(sizeof(struct task_start_info), 0);
|
|
if (!start_info)
|
|
return ENOMEM;
|
|
start_info->ip = ehdr.e_entry;
|
|
start_info->sp = highest - stack_size + stack_off;
|
|
start_info->arg = 0;
|
|
|
|
struct task* result;
|
|
err = task_create(info->argv[0], info->space, sched_to_user, (uintptr_t)start_info, &result);
|
|
if (err) {
|
|
mem_free(start_info);
|
|
return err;
|
|
}
|
|
|
|
*out = result;
|
|
return 0;
|
|
}
|