bumbread
/
ciabatta
mirror of https://github.com/flysand7/ciabatta.git
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity

make thread locals work

This commit is contained in:
flysand7 2023-09-02 11:45:00 +11:00
parent d8dc35c083
commit e1b7a84ba6
6 changed files with 138 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
build.py
View File

@ -115,7 +115,7 @@ target_arch = 'x86-64'
target_os = 'linux'
cc_defines.append(f'_CIA_OS_CONF=\\"os/{target_os}/conf.h\\"')
cc_flags.extend(['-nostdlib', '-fno-stack-protector'])
cc_flags.extend(['-nostdlib'])
if build_mode == 'debug':
cc_flags.extend(['-g', '-O0'])
@ -131,6 +131,7 @@ cc_includes.append('include/linux')
cc_flags_push()
cc_defines_push()
cc_flags.extend([
'-fno-stack-protector',
'-fno-builtin',
'-Wl,-e,_dlstart',
'-Wl,--sort-section,alignment',

17
include/linux/asm/prctl.h Normal file
View File

@ -0,0 +1,17 @@
#pragma once
#define ARCH_GET_CPUID 0x1011
#define ARCH_GET_FS 0x1003
#define ARCH_GET_GS 0x1004
#define ARCH_GET_XCOMP_GUEST_PERM 0x1024
#define ARCH_GET_XCOMP_PERM 0x1022
#define ARCH_GET_XCOMP_SUPP 0x1021
#define ARCH_MAP_VDSO_32 0x2002
#define ARCH_MAP_VDSO_64 0x2003
#define ARCH_MAP_VDSO_X32 0x2001
#define ARCH_REQ_XCOMP_GUEST_PERM 0x1025
#define ARCH_REQ_XCOMP_PERM 0x1023
#define ARCH_SET_CPUID 0x1012
#define ARCH_SET_FS 0x1002
#define ARCH_SET_GS 0x1001

6
include/linux/sys/syscall.h
View File

@ -413,11 +413,7 @@ _Noreturn static inline void sys_exit(int code) {
__builtin_unreachable();
}
static inline i64 sys_arch_prctl_set(int code, u64 value) {
return syscall(SYS_arch_prctl, code, value);
}
static inline i64 sys_arch_prctl_get(int code, u64 *value) {
static inline i64 sys_arch_prctl(int code, u64 value) {
return syscall(SYS_arch_prctl, code, value);
}

30
loader/loader-self-reloc.c
View File

@ -97,6 +97,11 @@ void ld_stage1_entry(u64 *sp, Elf64_Dyn *dynv) {
if(symtab == NULL) {
_dbg_printf("ERROR: No .dynsym found\n");
}
// Find the string table
char *strtab = (void *)(base + dyn[DT_STRTAB]);
if(dyn[DT_STRTAB] == 0) {
strtab = NULL;
}
// Use memory fences, to MAKE SURE the compiler won't reorder code and
// accidentally use relocations when they are not ready. The code before
// this point is carefully written to avoid generating relocations.
@ -128,26 +133,31 @@ void ld_stage1_entry(u64 *sp, Elf64_Dyn *dynv) {
Elf64_Rela *rela = (void *)(rela_ents + rela_offs);
u64 reloc_offs = rela->r_offset;
u64 addend = rela->r_addend;
u32 sym_idx = ELF64_R_SYM(rela->r_info);
Elf64_Sym *sym = &symtab[ELF64_R_SYM(rela->r_info)];
u32 type = ELF64_R_TYPE(rela->r_info);
_dbg_printf(" %x+%d, @%x (%d)\n", sym_idx, addend, reloc_offs, type);
void *sym_addr = (void *)(base + sym->st_value);
void **reloc_addr = (void *)(base + reloc_offs);
{
u32 sym_name_offset = sym->st_name;
if(sym_name_offset == 0) {
_dbg_printf(" %x+%d, @%x (%d)", sym_addr, addend, reloc_offs, type);
}
else {
char *sym_name = &strtab[sym_name_offset];
_dbg_printf(" %s+%d, @%x (%d)", sym_name, addend, reloc_offs, type);
}
}
if(type == R_X86_64_GLOB_DAT) {
Elf64_Sym *sym = &symtab[sym_idx];
void *sym_addr = (void *)(base + sym->st_value);
void **reloc_addr = (void *)(base + reloc_offs);
_dbg_printf(" -> %x\n", sym_addr);
*reloc_addr = sym_addr;
}
else if(type == R_X86_64_RELATIVE) {
void *addr = (void *)(base + addend);
void **reloc_addr = (void *)(base + reloc_offs);
*reloc_addr = addr;
_dbg_printf(" -> %x\n", addr);
*reloc_addr = (void *)(base + addend);
}
else {
printf("ERROR: unhandled relocation type: %d\n", type);
sys_exit(1);
}
_dbg_printf(" -> %x\n", *reloc_addr);
rela_offs += rela_ent;
}
}

103
loader/loader.c
View File

@ -6,6 +6,7 @@
#include <stdarg.h>
#include "loader.h"
#include <asm/prctl.h>
#include <futex.h>
#include <sys/mman.h>
#include <sched.h>
@ -22,6 +23,14 @@
#include "stack.c"
struct Thread_Control_Block typedef Thread_Control_Block;
struct Thread_Control_Block {
u64 thread_id;
u64 pad0[4];
u64 stack_canary;
u64 pad1[2];
};
struct Elf_Image typedef Elf_Image;
struct Elf_Image {
Cia_Arena arena;
@ -96,6 +105,9 @@ struct Stage3_Info_Struct typedef Stage3_Info_Struct;
struct Stage3_Info_Struct {
Elf_Image *app;
Elf_Image *ldso;
void *stack_base;
u64 stack_size;
u64 tls_size;
};
static void ld_stage3_entry(u64 has_new_stack, void *ctx);
@ -209,9 +221,11 @@ void ld_stage2_entry(Loader_Info *ld_info) {
_dbg_printf("Relocating app\n");
Elf64_Ehdr *eh = (void *)app->base;
// Resolve relocations
Elf64_Sym *symtab = (void *)app->dyn[DT_SYMTAB];
Elf64_Sym *symtab = elf_addr(app, (void *)app->dyn[DT_SYMTAB]);
char *strtab = elf_addr(app, app->dyn[DT_STRTAB]);
_dbg_printf("APP STRTAB: %x\n", strtab);
if(app->dyn[DT_REL] != 0) {
_dbg_printf("REL Relocations found. This part isn't implemented\n");
printf("REL Relocations found. This part isn't implemented\n");
u8 *rel_ents = elf_addr(app, app->dyn[DT_REL]);
u64 rel_ent = app->dyn[DT_RELENT];
u64 rel_size = app->dyn[DT_RELSZ];
@ -222,6 +236,7 @@ void ld_stage2_entry(Loader_Info *ld_info) {
u32 sym = ELF64_R_SYM(rel->r_info);
u32 type = ELF64_R_TYPE(rel->r_info);
_dbg_printf(" %d @ %d (%d)\n", sym, offs, type);
sys_exit(0);
// TODO: if needed
rel_offs += rel_ent;
}
@ -236,26 +251,31 @@ void ld_stage2_entry(Loader_Info *ld_info) {
Elf64_Rela *rela = (void *)(rela_ents + rela_offs);
u64 reloc_offs = rela->r_offset;
u64 addend = rela->r_addend;
u32 sym_idx = ELF64_R_SYM(rela->r_info);
u32 type = ELF64_R_TYPE(rela->r_info);
_dbg_printf(" %x+%d, @%x (%d)\n", sym_idx, addend, reloc_offs, type);
Elf64_Sym *sym = &symtab[ELF64_R_SYM(rela->r_info)];
void *sym_addr = elf_addr(app, (u64)sym->st_value);
void **reloc_addr = elf_addr(app, reloc_offs);
{
u32 sym_name_offset = sym->st_name;
if(sym_name_offset == 0) {
_dbg_printf(" %x+%d, @%x (%d)", sym_addr, addend, reloc_offs, type);
}
else {
char *sym_name = &strtab[sym_name_offset];
_dbg_printf(" %s+%d, @%x (%d)", sym_name, addend, reloc_offs, type);
}
}
if(type == R_X86_64_GLOB_DAT) {
Elf64_Sym *sym = &symtab[sym_idx];
void *sym_addr = elf_addr(app, sym->st_value);
void **reloc_addr = elf_addr(app, reloc_offs);
*reloc_addr = sym_addr;
_dbg_printf(" -> %x\n", sym_addr);
}
else if(type == R_X86_64_RELATIVE) {
void *addr = elf_addr(app, addend);
void **reloc_addr = elf_addr(app, reloc_offs);
*reloc_addr = addr;
_dbg_printf(" -> %x\n", addr);
*reloc_addr = elf_addr(app, addend);
}
else {
printf("ERROR: unhandled relocation type: %d\n", type);
sys_exit(1);
}
_dbg_printf(" -> %x\n", *reloc_addr);
rela_offs += rela_ent;
}
}
@ -292,9 +312,22 @@ void ld_stage2_entry(Loader_Info *ld_info) {
}
}
_dbg_printf("%x\n", 0);
// Get the app main
// Elf64_Sym *app_main = elf_symbol_by_name(app, "main");
// _dbg_printf("app main: %x\n", app_main);
// Get the size of the TLS initialization image for the main modules
u64 tls_size = 0;
{
Elf64_Phdr *ph_tls = NULL;
for(u64 i = 0; i < app->ph_num; ++i) {
Elf64_Phdr *ph = (void *)(app->phdr + i*app->ph_ent);
if(ph->p_type == PT_TLS) {
ph_tls = ph;
break;
}
}
if(ph_tls != NULL) {
tls_size += ph_tls->p_memsz;
}
}
_dbg_printf("TLS image size: %x\n", tls_size);
// Get the information about the main thread stack
if(linux_read_stack_info()) {
printf("ERROR: failed to read /proc/self/maps to get the stack info\n");
@ -303,8 +336,11 @@ void ld_stage2_entry(Loader_Info *ld_info) {
_dbg_printf("Found default stack at: %x-%x\n", stack_info.start_addr, stack_info.end_addr);
void *old_stack_base = (void *)stack_info.start_addr;
u64 old_stack_size = (u64)stack_info.end_addr - (u64)stack_info.start_addr;
u64 stack_size = 0x10000;
u64 stack_size = 2*MB;
void *stack_base = sys_mmap(0, stack_size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_NORESERVE, -1, 0);
stage3->stack_size = stack_size;
stage3->stack_base = stack_base;
stage3->tls_size = tls_size;
_dbg_printf("stage3 info struct: %x\n", stage3);
// Will jump to ld_stage3_entry
ld_stack_trampoline(stack_base, old_stack_base, stack_size, old_stack_size, &ld_stage3_entry, stage3);
@ -318,9 +354,38 @@ static void ld_stage3_entry(u64 has_new_stack, void *ctx) {
sys_exit(1);
}
Stage3_Info_Struct *info = ctx;
_dbg_printf("Entered loader stage 3. Try entering main executable\n");
_dbg_printf("stage3 info struct: %x\n", info);
_dbg_printf("Stack: %x-%x\n", info->stack_base, (u8 *)info->stack_base+info->stack_size);
// Set up the thread control block
Thread_Control_Block *tcb = cia_ptr_alignf((u8*)info->stack_base + info->tls_size, 1*MB);
tcb->thread_id = 0;
tcb->stack_canary = 0x12345678fedcba98;
// Copy TLS initialization image below TCB
{
Elf_Image *app = info->app;
Elf64_Phdr *ph_tls = NULL;
for(u64 i = 0; i < app->ph_num; ++i) {
Elf64_Phdr *ph = (void *)(app->phdr + i*app->ph_ent);
if(ph->p_type == PT_TLS) {
ph_tls = ph;
break;
}
}
if(ph_tls != NULL) {
u8 *tls_image_base = elf_addr(app, ph_tls->p_vaddr);
u64 tls_image_size = ph_tls->p_memsz;
u8 *tls_image = (u8*)tcb - tls_image_size;
for(int i = 0; i < tls_image_size; ++i) {
tls_image[i] = tls_image_base[i];
}
}
}
// Set up the thread pointer
int err = sys_arch_prctl(ARCH_SET_FS, (u64)tcb);
if(err < 0) {
printf("ERROR: failed to set up the thread pointer\n");
sys_exit(1);
}
_dbg_printf("Entered loader stage 3. Entering main executable\n");
void (*crt_entry)() = elf_addr(info->app, ((Elf64_Ehdr *)info->app->base)->e_entry);
_dbg_printf("Entry at: %x\n", crt_entry);
crt_entry();
}

14
tests/tls.c Normal file
View File

@ -0,0 +1,14 @@
#include <cia/def.h>
#include <stdio.h>
_Thread_local u64 my_thread_local;
int main(void) {
int arr[16] = {0};
my_thread_local = 2;
arr[3] = 5;
char string[] = "Hello, world!\n";
fwrite(string, 1, sizeof string-1, stdout);
return 0;
}