From bd5969fc876a10b18613302db7087ef3c40f18e1 Mon Sep 17 00:00:00 2001 From: Ian Moffett Date: Thu, 7 Mar 2024 17:28:00 -0500 Subject: lib: Add mlibc Signed-off-by: Ian Moffett --- lib/mlibc/sysdeps/dripos/generic/entry.cpp | 35 +++ lib/mlibc/sysdeps/dripos/generic/generic.cpp | 298 ++++++++++++++++++++++++ lib/mlibc/sysdeps/dripos/generic/thread.cpp | 53 +++++ lib/mlibc/sysdeps/dripos/generic/thread_entry.S | 11 + 4 files changed, 397 insertions(+) create mode 100644 lib/mlibc/sysdeps/dripos/generic/entry.cpp create mode 100644 lib/mlibc/sysdeps/dripos/generic/generic.cpp create mode 100644 lib/mlibc/sysdeps/dripos/generic/thread.cpp create mode 100644 lib/mlibc/sysdeps/dripos/generic/thread_entry.S (limited to 'lib/mlibc/sysdeps/dripos/generic') diff --git a/lib/mlibc/sysdeps/dripos/generic/entry.cpp b/lib/mlibc/sysdeps/dripos/generic/entry.cpp new file mode 100644 index 0000000..2b8b914 --- /dev/null +++ b/lib/mlibc/sysdeps/dripos/generic/entry.cpp @@ -0,0 +1,35 @@ + +#include +#include +#include +#include + +// defined by the POSIX library +void __mlibc_initLocale(); + +extern "C" uintptr_t *__dlapi_entrystack(); + +extern char **environ; +static mlibc::exec_stack_data __mlibc_stack_data; + +struct LibraryGuard { + LibraryGuard(); +}; + +static LibraryGuard guard; + +LibraryGuard::LibraryGuard() { + __mlibc_initLocale(); + + // Parse the exec() stack. + mlibc::parse_exec_stack(__dlapi_entrystack(), &__mlibc_stack_data); + mlibc::set_startup_data(__mlibc_stack_data.argc, __mlibc_stack_data.argv, + __mlibc_stack_data.envp); +} + +extern "C" void __mlibc_entry(int (*main_fn)(int argc, char *argv[], char *env[])) { + // TODO: call __dlapi_enter, otherwise static builds will break (see Linux sysdeps) + auto result = main_fn(__mlibc_stack_data.argc, __mlibc_stack_data.argv, environ); + exit(result); +} + diff --git a/lib/mlibc/sysdeps/dripos/generic/generic.cpp b/lib/mlibc/sysdeps/dripos/generic/generic.cpp new file mode 100644 index 0000000..89203c3 --- /dev/null +++ b/lib/mlibc/sysdeps/dripos/generic/generic.cpp @@ -0,0 +1,298 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +namespace mlibc { + +void sys_libc_log(const char *message) { + unsigned long res; + asm volatile ("syscall" : "=a"(res) + : "a"(50), "D"(message) + : "rcx", "r11", "rdx"); +} + +void sys_libc_panic() { + mlibc::infoLogger() << "\e[31mmlibc: panic!" << frg::endlog; + asm volatile ("syscall" : + : "a"(12), "D"(1) + : "rcx", "r11", "rdx"); +} + +int sys_tcb_set(void *pointer) { + int res; + asm volatile ("syscall" : "=a"(res) + : "a"(300), "D"(pointer) + : "rcx", "r11", "rdx"); + return res; +} + +int sys_anon_allocate(size_t size, void **pointer) { + void *ret; + int sys_errno; + + asm volatile ("syscall" + : "=a"(ret), "=d"(sys_errno) + : "a"(9), "D"(0), "S"(size) + : "rcx", "r11"); + + if (!ret) + return sys_errno; + + *pointer = ret; + return 0; +} + +int sys_anon_free(void *pointer, size_t size) { + int unused_return; + int sys_errno; + + asm volatile ("syscall" + : "=a"(unused_return), "=d"(sys_errno) + : "a"(11), "D"(pointer), "S"(size) + : "rcx", "r11"); + + if (unused_return) + return sys_errno; + + return 0; +} + +#ifndef MLIBC_BUILDING_RTDL +void sys_exit(int status) { + asm volatile ("syscall" : + : "a"(12), "D"(status) + : "rcx", "r11", "rdx"); +} +#endif + +#ifndef MLIBC_BUILDING_RTDL +int sys_clock_get(int clock, time_t *secs, long *nanos) { + return 0; +} +#endif + +int sys_open(const char *path, int flags, mode_t mode, int *fd) { + int ret; + int sys_errno; + + asm volatile ("syscall" + : "=a"(ret), "=d"(sys_errno) + : "a"(2), "D"(path), "S"(flags), "d"(0) + : "rcx", "r11"); + + if (ret == -1) + return sys_errno; + + *fd = ret; + return 0; +} + +int sys_close(int fd) { + int ret; + int sys_errno; + + asm volatile ("syscall" + : "=a"(ret), "=d"(sys_errno) + : "a"(3), "D"(fd) + : "rcx", "r11"); + + if (ret == -1) + return sys_errno; + + return 0; +} + +int sys_read(int fd, void *buf, size_t count, ssize_t *bytes_read) { + ssize_t ret; + int sys_errno; + + asm volatile ("syscall" + : "=a"(ret), "=d"(sys_errno) + : "a"(0), "D"(fd), "S"(buf), "d"(count) + : "rcx", "r11"); + + if (ret == -1) + return sys_errno; + + *bytes_read = ret; + return 0; +} + +#ifndef MLIBC_BUILDING_RTDL +int sys_write(int fd, const void *buf, size_t count, ssize_t *bytes_written) { + ssize_t ret; + int sys_errno; + + asm volatile ("syscall" + : "=a"(ret), "=d"(sys_errno) + : "a"(1), "D"(fd), "S"(buf), "d"(count) + : "rcx", "r11"); + + if (ret == -1) + return sys_errno; + + *bytes_written = ret; + return 0; +} +#endif + + +int sys_seek(int fd, off_t offset, int whence, off_t *new_offset) { + off_t ret; + int sys_errno; + + asm volatile ("syscall" + : "=a"(ret), "=d"(sys_errno) + : "a"(8), "D"(fd), "S"(offset), "d"(whence) + : "rcx", "r11"); + + if (ret == -1) + return sys_errno; + + *new_offset = ret; + return 0; +} + +int sys_vm_map(void *hint, size_t size, int prot, int flags, + int fd, off_t offset, void **window) { + __ensure(flags & MAP_ANONYMOUS); + void *ret; + int sys_errno; + + // mlibc::infoLogger() << "calling sys_vm_map with size: " << size << frg::endlog; + + asm volatile ("syscall" + : "=a"(ret), "=d"(sys_errno) + : "a"(9), "D"(hint), "S"(size) + : "rcx", "r11"); + + if (!ret) + return sys_errno; + + *window = ret; + + return 0; +} + +int sys_vm_unmap(void *pointer, size_t size) { + return sys_anon_free(pointer, size); +} + +int sys_futex_wait(int *pointer, int expected, const struct timespec *time) { + uint64_t err; + asm volatile ("syscall" + : "=d"(err) + : "a"(66), "D"(pointer), "S"(expected) + : "rcx", "r11"); + + if (err) { + return -1; + } + + return 0; +} + +int sys_futex_wake(int *pointer) { + uint64_t err; + asm volatile ("syscall" + : "=d"(err) + : "a"(65), "D"(pointer) + : "rcx", "r11"); + + if (err) { + return -1; + } + + return 0; +} + +// All remaining functions are disabled in ldso. +#ifndef MLIBC_BUILDING_RTDL + +int sys_clone(void *tcb, pid_t *tid_out, void *stack) { + int tid; + + asm volatile ("syscall" + : "=a"(tid) + : "a"(67), "D"(__mlibc_start_thread), "S"(stack), "d"(tcb) + : "rcx", "r11"); + + if (tid_out) + *tid_out = tid; + + return 0; +} + +void sys_thread_exit() { + asm volatile ("syscall" + : + : "a"(68) + : "rcx", "r11"); + __builtin_trap(); +} + +int sys_sleep(time_t *secs, long *nanos) { + long ms = (*nanos / 1000000) + (*secs * 1000); + asm volatile ("syscall" + : + : "a"(6), "D"(ms) + : "rcx", "r11"); + *secs = 0; + *nanos = 0; + return 0; +} + +int sys_fork(pid_t *child) { + pid_t ret; + int sys_errno; + + asm volatile ("syscall" + : "=a"(ret), "=d"(sys_errno) + : "a"(57) + : "rcx", "r11"); + + if (ret == -1) + return sys_errno; + + *child = ret; + return 0; +} + +int sys_execve(const char *path, char *const argv[], char *const envp[]) { + int ret; + int sys_errno; + + asm volatile ("syscall" + : "=a"(ret), "=d"(sys_errno) + : "a"(59), "D"(path), "S"(argv), "d"(envp) + : "rcx", "r11"); + + if (sys_errno != 0) + return sys_errno; + + return 0; +} + +pid_t sys_getpid() { + pid_t pid; + asm volatile ("syscall" : "=a"(pid) + : "a"(5) + : "rcx", "r11", "rdx"); + return pid; +} +pid_t sys_getppid() { + pid_t ppid; + asm volatile ("syscall" : "=a"(ppid) + : "a"(14) + : "rcx", "r11", "rdx"); + return ppid; +} + +#endif // MLIBC_BUILDING_RTDL + +} // namespace mlibc diff --git a/lib/mlibc/sysdeps/dripos/generic/thread.cpp b/lib/mlibc/sysdeps/dripos/generic/thread.cpp new file mode 100644 index 0000000..42cd758 --- /dev/null +++ b/lib/mlibc/sysdeps/dripos/generic/thread.cpp @@ -0,0 +1,53 @@ +#include +#include +#include +#include +#include +#include +#include + +extern "C" void __mlibc_enter_thread(void *entry, void *user_arg, Tcb *tcb) { + // Wait until our parent sets up the TID. + while(!__atomic_load_n(&tcb->tid, __ATOMIC_RELAXED)) + mlibc::sys_futex_wait(&tcb->tid, 0, nullptr); + + if(mlibc::sys_tcb_set(tcb)) + __ensure(!"sys_tcb_set() failed"); + + tcb->invokeThreadFunc(entry, user_arg); + + auto self = reinterpret_cast(tcb); + + __atomic_store_n(&self->didExit, 1, __ATOMIC_RELEASE); + mlibc::sys_futex_wake(&self->didExit); + + mlibc::sys_thread_exit(); +} + +namespace mlibc { + +static constexpr size_t default_stacksize = 0x200000; + +int sys_prepare_stack(void **stack, void *entry, void *user_arg, void *tcb, size_t *stack_size, size_t *guard_size, void **stack_base) { + if (!*stack_size) + *stack_size = default_stacksize; + *guard_size = 0; + + if (*stack) { + *stack_base = *stack; + } else { + *stack_base = mmap(nullptr, *stack_size, + PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + } + + uintptr_t *sp = reinterpret_cast(reinterpret_cast(*stack_base) + *stack_size); + + *--sp = reinterpret_cast(tcb); + *--sp = reinterpret_cast(user_arg); + *--sp = reinterpret_cast(entry); + *stack = reinterpret_cast(sp); + return 0; +} + +} //namespace mlibc diff --git a/lib/mlibc/sysdeps/dripos/generic/thread_entry.S b/lib/mlibc/sysdeps/dripos/generic/thread_entry.S new file mode 100644 index 0000000..51e703b --- /dev/null +++ b/lib/mlibc/sysdeps/dripos/generic/thread_entry.S @@ -0,0 +1,11 @@ + +.section .text +.global __mlibc_start_thread +__mlibc_start_thread: + pop %rdi + pop %rsi + pop %rdx + call __mlibc_enter_thread + +.section .note.GNU-stack,"",%progbits + -- cgit v1.2.3