From cf9890ede421681b8dde6c0877d7ad9178da18ad Mon Sep 17 00:00:00 2001 From: Matheus Date: Fri, 4 Oct 2024 18:46:59 -0300 Subject: [PATCH] ports: use upstream mlibc astral sysdep --- patches/mlibc/jinx-working-patch.patch | 1435 +----------------------- recipes/cxxshim | 15 - recipes/freestnd-c-hdrs | 12 + recipes/freestnd-cxx-hdrs | 12 + recipes/mlibc | 4 +- recipes/mlibc-headers | 2 +- recipes/nano | 2 +- recipes/ncurses | 2 +- recipes/tar | 4 +- source-recipes/cxxshim | 9 - source-recipes/freestnd-c-hdrs | 9 + source-recipes/freestnd-cxx-hdrs | 9 + source-recipes/frigg | 4 +- source-recipes/libtool | 4 +- source-recipes/mlibc | 7 +- 15 files changed, 57 insertions(+), 1473 deletions(-) delete mode 100644 recipes/cxxshim create mode 100644 recipes/freestnd-c-hdrs create mode 100644 recipes/freestnd-cxx-hdrs delete mode 100644 source-recipes/cxxshim create mode 100644 source-recipes/freestnd-c-hdrs create mode 100644 source-recipes/freestnd-cxx-hdrs diff --git a/patches/mlibc/jinx-working-patch.patch b/patches/mlibc/jinx-working-patch.patch index d20dae72..5b6a76c5 100644 --- a/patches/mlibc/jinx-working-patch.patch +++ b/patches/mlibc/jinx-working-patch.patch @@ -12,26 +12,6 @@ index 87bc25f..d7370d0 100644 #define IPPROTO_IP 0 #define IPPROTO_HOPOPTS 0 #define IPPROTO_ICMP 1 -diff --git mlibc-clean/meson.build mlibc-workdir/meson.build -index bb8928f..969145b 100644 ---- mlibc-clean/meson.build -+++ mlibc-workdir/meson.build -@@ -256,6 +256,15 @@ elif host_machine.system() == 'dripos' - rtld_include_dirs += include_directories('sysdeps/dripos/include') - libc_include_dirs += include_directories('sysdeps/dripos/include') - subdir('sysdeps/dripos') -+elif host_machine.system() == 'astral' -+ disable_crypt_option = true -+ disable_iconv_option = true -+ disable_intl_option = true -+ rtld_include_dirs += include_directories('sysdeps/astral/include') -+ libc_include_dirs += include_directories('sysdeps/astral/include') -+ internal_conf.set10('MLIBC_MAP_DSO_SEGMENTS', true) -+ internal_conf.set10('MLIBC_MAP_FILE_WINDOWS', true) -+ subdir('sysdeps/astral') - else - error('No sysdeps defined for OS: ' + host_machine.system()) - endif diff --git mlibc-clean/options/ansi/generic/environment.cpp mlibc-workdir/options/ansi/generic/environment.cpp index 5625592..36b42ee 100644 --- mlibc-clean/options/ansi/generic/environment.cpp @@ -103,7 +83,7 @@ index fc34a3b..b1a95a9 100644 #include diff --git mlibc-clean/options/posix/generic/unistd-stubs.cpp mlibc-workdir/options/posix/generic/unistd-stubs.cpp -index 444ad22..0f1b125 100644 +index 444ad22..d1ca86e 100644 --- mlibc-clean/options/posix/generic/unistd-stubs.cpp +++ mlibc-workdir/options/posix/generic/unistd-stubs.cpp @@ -484,8 +484,9 @@ int lockf(int fd, int op, off_t size) { @@ -118,21 +98,8 @@ index 444ad22..0f1b125 100644 } long pathconf(const char *, int name) { -@@ -1297,6 +1298,7 @@ void encrypt(char[64], int) { - } - #endif - -+#if 0 - #if __MLIBC_BSD_OPTION - void *sbrk(intptr_t increment) { - if(increment) { -@@ -1313,3 +1315,4 @@ void *sbrk(intptr_t increment) { - return out; - } - #endif -+#endif diff --git mlibc-clean/options/rtld/generic/main.cpp mlibc-workdir/options/rtld/generic/main.cpp -index 0f5f1a3..c66ef93 100644 +index 9219ef0..1ff679c 100644 --- mlibc-clean/options/rtld/generic/main.cpp +++ mlibc-workdir/options/rtld/generic/main.cpp @@ -17,6 +17,8 @@ @@ -144,1401 +111,3 @@ index 0f5f1a3..c66ef93 100644 #if __MLIBC_POSIX_OPTION #include #endif -diff --git mlibc-workdir/sysdeps/astral/crt-x86_64/crt0.S mlibc-workdir/sysdeps/astral/crt-x86_64/crt0.S -new file mode 100644 -index 0000000..0a0a4a0 ---- /dev/null -+++ mlibc-workdir/sysdeps/astral/crt-x86_64/crt0.S -@@ -0,0 +1,7 @@ -+ -+.section .text -+.global _start -+_start: -+ mov $main, %rdi -+ call __mlibc_entry -+ -diff --git mlibc-workdir/sysdeps/astral/generic/astral.cpp mlibc-workdir/sysdeps/astral/generic/astral.cpp -new file mode 100644 -index 0000000..f1edacc ---- /dev/null -+++ mlibc-workdir/sysdeps/astral/generic/astral.cpp -@@ -0,0 +1,17 @@ -+#include -+#include -+ -+#define ARCH_CTL_GSBASE 0 -+#define ARCH_CTL_FSBASE 1 -+ -+#ifndef MLIBC_BUILDING_RTLD -+ -+int syscall_archctl(int func, void *arg) { -+ long ret; -+ long error = syscall(SYSCALL_ARCHCTL, &ret, func, (uint64_t)arg); -+ if (error) -+ errno = error; -+ return error ? -1 : ret; -+} -+ -+#endif -diff --git mlibc-workdir/sysdeps/astral/generic/entry.cpp mlibc-workdir/sysdeps/astral/generic/entry.cpp -new file mode 100644 -index 0000000..e5b087a ---- /dev/null -+++ mlibc-workdir/sysdeps/astral/generic/entry.cpp -@@ -0,0 +1,33 @@ -+#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[])) { -+ auto result = main_fn(__mlibc_stack_data.argc, __mlibc_stack_data.argv, environ); -+ exit(result); -+} -+ -diff --git mlibc-workdir/sysdeps/astral/generic/generic.cpp mlibc-workdir/sysdeps/astral/generic/generic.cpp -new file mode 100644 -index 0000000..b73c420 ---- /dev/null -+++ mlibc-workdir/sysdeps/astral/generic/generic.cpp -@@ -0,0 +1,1007 @@ -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+#include -+ -+#ifndef MLIBC_BUILDING_RTLD -+// (s)brk is emulated in the libc rather than being -+// an actual system call. -+#define SBRK_BUFFER_SIZE (1024 * 1024 * 16) -+static void *sbrkbuffer; -+static off_t sbrkoffset; -+ -+extern "C" void *sbrk(intptr_t increment) { -+ // allocate the buffer if its the first time sbrk is called -+ if (sbrkbuffer == NULL) { -+ int e = mlibc::sys_vm_map(NULL, SBRK_BUFFER_SIZE, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0, &sbrkbuffer); -+ if (e) { -+ errno = e; -+ return NULL; -+ } -+ } -+ -+ if (increment == 0) -+ return sbrkbuffer; -+ -+ off_t newoffset = sbrkoffset + increment; -+ if (newoffset < 0) { -+ // offset goes below what we allocated, this is bad -+ errno = EINVAL; -+ return NULL; -+ } -+ -+ if (newoffset >= SBRK_BUFFER_SIZE) { -+ // new offset goes past what was allocated -+ errno = ENOMEM; -+ return NULL; -+ } -+ -+ void *ret = (void *)((uintptr_t)sbrkbuffer + increment); -+ sbrkoffset = newoffset; -+ return ret; -+} -+#endif -+ -+namespace mlibc { -+ int sys_getsockopt(int fd, int layer, int number, -+ void *__restrict buffer, socklen_t *__restrict size) { -+ // TODO unstub -+ mlibc::infoLogger() << "getsockopt: " << fd << " " << layer << " " << number << frg::endlog; -+ return 0; -+ } -+ -+ int sys_setgroups(size_t size, const gid_t *list) { -+ // TODO unstub -+ return 0; -+ } -+ -+ int sys_getgroups(size_t size, gid_t *list, int *ret) { -+ // TODO unstub -+ *ret = 0; -+ return 0; -+ } -+ -+ int sys_tgkill(int pid, int tid, int sig) { -+ long ret; -+ return syscall(SYSCALL_KILLTHREAD, &ret, pid, tid, sig); -+ } -+ -+ int sys_sigpending(sigset_t *set) { -+ long ret; -+ return syscall(SYSCALL_SIGPENDING, &ret, (uint64_t)set); -+ } -+ -+ int sys_sigtimedwait(const sigset_t *__restrict set, siginfo_t *__restrict info, const struct timespec *__restrict timeout, int *out_signal) { -+ long ret; -+ long err = syscall(SYSCALL_SIGTIMEDWAIT, &ret, (uint64_t)set, (uint64_t)info, (uint64_t)timeout); -+ *out_signal = ret; -+ return err; -+ } -+ -+ int sys_sigsuspend(const sigset_t *set) { -+ long ret; -+ return syscall(SYSCALL_SIGSUSPEND, &ret, (uint64_t)set); -+ } -+ -+ int sys_vm_protect(void *pointer, size_t size, int prot) { -+ long ret; -+ return syscall(SYSCALL_MPROTECT, &ret, (uint64_t)pointer, size, prot); -+ } -+ -+ int sys_setuid(uid_t id) { -+ long ret; -+ return syscall(SYSCALL_SETUID, &ret, id); -+ } -+ -+ int sys_setgid(gid_t id) { -+ long ret; -+ return syscall(SYSCALL_SETGID, &ret, id); -+ } -+ -+ int sys_seteuid(uid_t id) { -+ long ret; -+ return syscall(SYSCALL_SETEUID, &ret, id); -+ } -+ -+ int sys_setegid(gid_t id) { -+ long ret; -+ return syscall(SYSCALL_SETEGID, &ret, id); -+ } -+ -+ uid_t sys_getuid() { -+ uid_t r, e, s; -+ sys_getresuid(&r, &e, &s); -+ -+ return r; -+ } -+ -+ uid_t sys_geteuid() { -+ uid_t r, e, s; -+ sys_getresuid(&r, &e, &s); -+ -+ return e; -+ } -+ -+ gid_t sys_getgid() { -+ gid_t r, e, s; -+ sys_getresgid(&r, &e, &s); -+ -+ return r; -+ } -+ -+ gid_t sys_getegid() { -+ gid_t r, e, s; -+ sys_getresgid(&r, &e, &s); -+ -+ return e; -+ } -+ -+ int sys_setresuid(uid_t _ruid, uid_t _euid, uid_t _suid) { -+ long ret; -+ return syscall(SYSCALL_SETRESUID, &ret, _ruid, _euid, _suid); -+ } -+ -+ int sys_setresgid(gid_t _rgid, gid_t _egid, gid_t _sgid) { -+ long ret; -+ return syscall(SYSCALL_SETRESGID, &ret, _rgid, _egid, _sgid); -+ } -+ -+ int sys_getresuid(uid_t *ruid, uid_t *euid, uid_t *suid) { -+ long ret; -+ return syscall(SYSCALL_GETRESUID, &ret, (uint64_t)ruid, (uint64_t)euid, (uint64_t)suid); -+ } -+ -+ int sys_getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid) { -+ long ret; -+ return syscall(SYSCALL_GETRESGID, &ret, (uint64_t)rgid, (uint64_t)egid, (uint64_t)sgid); -+ } -+ -+ int sys_mknodat(int dirfd, const char *path, int mode, int dev) { -+ long ret; -+ return syscall(SYSCALL_MKNODAT, &ret, dirfd, (uint64_t)path, mode, dev); -+ } -+ -+ int sys_mkfifoat(int dirfd, const char *path, mode_t mode) { -+ return sys_mknodat(dirfd, path, S_IFIFO | mode, 0); -+ } -+ -+ int sys_rmdir(const char *path) { -+ return sys_unlinkat(AT_FDCWD, path, AT_REMOVEDIR); -+ } -+ -+ int sys_pread(int fd, void *buf, size_t n, off_t off, ssize_t *bytes_read) { -+ long readc; -+ long error = syscall(SYSCALL_PREAD, &readc, fd, (uint64_t)buf, n, off); -+ *bytes_read = readc; -+ return error; -+ } -+ -+ int sys_pwrite(int fd, const void *buf, size_t n, off_t off, ssize_t *bytes_written) { -+ long writec; -+ long error = syscall(SYSCALL_PWRITE, &writec, fd, (uint64_t)buf, n, off); -+ *bytes_written = writec; -+ return error; -+ } -+ -+ #ifndef MLIBC_BUILDING_RTLD -+ -+ typedef struct { -+ ino_t d_ino; -+ off_t d_off; -+ unsigned short d_reclen; -+ unsigned char d_type; -+ char d_name[1024]; -+ } dent_t; -+ -+ // TODO at least cache the results and invalidade on a chdir -+ int sys_getcwd(char *buffer, size_t size) { -+ // cwd implemented in userspace -+ // -+ // note: not thread safe if the other threads chroot -+ -+ char path[PATH_MAX]; -+ int curroffset = PATH_MAX - 1; -+ path[curroffset] = '\0'; -+ -+ -+ struct stat rootdir; // we will use dev and inode to find files and determine when the root dir has been hit -+ if (fstatat(-1, "/", &rootdir, 0)) -+ return errno; -+ -+ int dirfd = open(".", O_RDONLY); -+ if (dirfd < 0) -+ return errno; -+ -+ struct stat dirstat; -+ -+ if (fstat(dirfd, &dirstat)) { -+ close(dirfd); -+ return errno; -+ } -+ -+ if (dirstat.st_dev == rootdir.st_dev && dirstat.st_ino == rootdir.st_ino) { -+ // cwd is root dir -+ close(dirfd); -+ if (size < 2) -+ return ERANGE; -+ -+ buffer[0] = '/'; -+ buffer[1] = '\0'; -+ return 0; -+ } -+ -+ struct stat upstat; -+ do { -+ if (fstat(dirfd, &dirstat)) { -+ close(dirfd); -+ return errno; -+ } -+ -+ int upfd = openat(dirfd, "..", O_RDONLY); -+ -+ if (fstat(upfd, &upstat)) { -+ close(upfd); -+ close(dirfd); -+ return errno; -+ } -+ -+ close(dirfd); -+ -+ dent_t dent; -+ size_t readcount; -+ while (sys_read_entries(upfd, &dent, sizeof(dent), &readcount) == 0) { -+ if (readcount == 0) -+ break; -+ -+ if (strcmp(".", dent.d_name) == 0 || strcmp("..", dent.d_name) == 0) -+ continue; -+ -+ int tmp = openat(upfd, dent.d_name, O_RDONLY); -+ // could have been deleted, continue -+ if (tmp < 0) -+ continue; -+ -+ struct stat dentstat; -+ if (fstat(tmp, &dentstat)) { -+ close(tmp); -+ return errno; -+ } -+ -+ close(tmp); -+ -+ if (dentstat.st_dev == dirstat.st_dev && dentstat.st_ino == dirstat.st_ino) -+ break; -+ } -+ -+ // didn't find the directory -+ if (readcount == 0) { -+ close(upfd); -+ return ENOENT; -+ } -+ -+ dirfd = upfd; -+ -+ // add it to the path to be returned -+ size_t namelen = strlen(dent.d_name); -+ curroffset -= namelen + 1; // + 1 as we add the leading '/' as well -+ // passed the start of the buffer -+ if (curroffset <= 1) { -+ close (dirfd); -+ return ENAMETOOLONG; -+ } -+ -+ memcpy(&path[curroffset + 1], dent.d_name, namelen); -+ path[curroffset] = '/'; -+ } while (upstat.st_dev != rootdir.st_dev || upstat.st_ino != rootdir.st_ino); -+ -+ close(dirfd); -+ -+ if (size < PATH_MAX - curroffset) -+ return ERANGE; -+ -+ strcpy(buffer, &path[curroffset]); -+ -+ mlibc::infoLogger() << "mlibc: sys_getcwd returning value " << buffer << frg::endlog; -+ return 0; -+ } -+ -+ #endif -+ -+ int sys_pause() { -+ long ret; -+ return syscall(SYSCALL_PAUSE, &ret); -+ } -+ -+ int sys_chroot(const char *path) { -+ long ret; -+ return syscall(SYSCALL_CHROOT, &ret, (uint64_t)path); -+ } -+ -+ int sys_peername(int fd, struct sockaddr *addr_ptr, socklen_t max_addr_length, socklen_t *actual_length) { -+ long ret; -+ int len = max_addr_length; -+ long error = syscall(SYSCALL_GETPEERNAME, &ret, fd, (uint64_t)addr_ptr, (uint64_t)&len); -+ *actual_length = len; -+ return error; -+ } -+ -+ int sys_sockname(int fd, struct sockaddr *addr_ptr, socklen_t max_addr_length, socklen_t *actual_length) { -+ long ret; -+ int len = max_addr_length; -+ long error = syscall(SYSCALL_GETSOCKNAME, &ret, fd, (uint64_t)addr_ptr, (uint64_t)&len); -+ *actual_length = len; -+ return error; -+ } -+ -+ int sys_socketpair(int domain, int type_and_flags, int proto, int *fds) { -+ long ret = 0; -+ long err = syscall(SYSCALL_SOCKETPAIR, &ret, domain, type_and_flags, proto); -+ if (err) -+ return err; -+ -+ fds[0] = ret & 0xffffffff; -+ fds[1] = (ret >> 32) & 0xffffffff; -+ return err; -+ } -+ -+ int sys_getitimer(int which, struct itimerval *curr_value) { -+ long ret; -+ return syscall(SYSCALL_GETITIMER, &ret, which, (uint64_t)curr_value); -+ } -+ -+ int sys_setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value) { -+ long ret; -+ return syscall(SYSCALL_SETITIMER, &ret, which, (uint64_t)new_value, (uint64_t)old_value); -+ } -+ -+ #ifndef MLIBC_BUILDING_RTLD -+ #define TTY_IOCTL_NAME 0x771101141113l -+ #define TTY_NAME_MAX 32 -+ #define TTY_PREFIX "/dev/" -+ -+ -+ int sys_ttyname(int fd, char * buffer, size_t size) { -+ size_t prefixlen = strlen(TTY_PREFIX); -+ if (size < TTY_NAME_MAX + prefixlen) { -+ mlibc::panicLogger() << "ttyname size too small" << frg::endlog; -+ __builtin_unreachable(); -+ } -+ -+ strcpy(buffer, TTY_PREFIX); -+ -+ int res; -+ return sys_ioctl(fd, TTY_IOCTL_NAME, (void *)(buffer + prefixlen), &res); -+ } -+ #endif -+ -+ int sys_fsync(int fd) { -+ long ret; -+ return syscall(SYSCALL_FSYNC, &ret, fd); -+ } -+ -+ int sys_fdatasync(int fd) { -+ // TODO proper datasync syscall -+ return sys_fsync(fd); -+ } -+ -+ -+ pid_t sys_getppid() { -+ long ret; -+ syscall(SYSCALL_GETPPID, &ret); -+ return ret; -+ } -+ -+ int sys_getsid(pid_t pid, pid_t *pgid) { -+ long ret; -+ long error = syscall(SYSCALL_GETSID, &ret, pid); -+ *pgid = ret; -+ return error; -+ } -+ -+ int sys_getpgid(pid_t pid, pid_t *pgid) { -+ long ret; -+ long error = syscall(SYSCALL_GETPGID, &ret, pid); -+ *pgid = ret; -+ return error; -+ } -+ -+ int sys_gethostname(char *buffer, size_t bufsize) { -+ long ret; -+ return syscall(SYSCALL_HOSTNAME, &ret, NULL, 0, (uint64_t)buffer, bufsize); -+ } -+ -+ int sys_sethostname(const char *buffer, size_t bufsize) { -+ long ret; -+ return syscall(SYSCALL_HOSTNAME, &ret, (uint64_t)buffer, bufsize, NULL, 0), NULL, 0; -+ } -+ -+ int sys_uname(struct utsname *buf) { -+ long ret; -+ return syscall(SYSCALL_UNAME, &ret, (uint64_t)buf); -+ } -+ -+ void sys_sync() { -+ long ret; -+ syscall(SYSCALL_SYNC, &ret); -+ } -+ -+ #ifndef MLIBC_BUILDING_RTLD -+ int sys_getentropy(void *buffer, size_t length) { -+ int fd; -+ int error = sys_open("/dev/urandom", O_RDONLY, 0, &fd); -+ if (error) -+ mlibc::panicLogger() << "/dev/urandom open error " << strerror(error) << frg::endlog; -+ -+ ssize_t bytes; -+ error = sys_read(fd, buffer, length, &bytes); -+ if (error) { -+ mlibc::infoLogger() << "/dev/urandom read error " << strerror(error) << frg::endlog; -+ return error; -+ } -+ -+ sys_close(fd); -+ return 0; -+ } -+ #endif -+ -+ int sys_kill(int pid, int signal) { -+ long ret; -+ return syscall(SYSCALL_KILL, &ret, pid, signal); -+ } -+ -+ int sys_sigprocmask(int how, const sigset_t *__restrict set, sigset_t *__restrict retrieve) { -+ long ret; -+ return syscall(SYSCALL_SIGPROCMASK, &ret, how, (uint64_t)set, (uint64_t)retrieve); -+ } -+ -+ int sys_sigaltstack(const stack_t *ss, stack_t *oss) { -+ long ret; -+ return syscall(SYSCALL_SIGALTSTACK, &ret, (uint64_t)ss, (uint64_t)oss); -+ } -+ -+ #ifndef MLIBC_BUILDING_RTLD -+ extern "C" void __mlibc_restorer(); -+ -+ int sys_sigaction(int sig, const struct sigaction *__restrict act, -+ struct sigaction *__restrict oldact) { -+ long ret; -+ -+ struct sigaction newact; -+ if (act) -+ memcpy(&newact, act, sizeof(struct sigaction)); -+ -+ if (act && (newact.sa_flags & SA_RESTORER) == 0) { -+ newact.sa_restorer = __mlibc_restorer; -+ newact.sa_flags |= SA_RESTORER; -+ } -+ -+ return syscall(SYSCALL_SIGACTION, &ret, sig, act ? (uint64_t)&newact : 0, (uint64_t)oldact); -+ } -+ -+ int sys_ptsname(int fd, char *buffer, size_t length) { -+ int index; -+ int tmp; -+ if (int e = sys_ioctl(fd, TIOCGPTN, &index, &tmp); e) -+ return e; -+ -+ if ((size_t)snprintf(buffer, length, "/dev/pts/%d", index) >= length) { -+ return ERANGE; -+ } -+ -+ return 0; -+ } -+ #endif -+ -+ int sys_setpgid(pid_t pid, pid_t pgid) { -+ long ret; -+ return syscall(SYSCALL_SETPGID, &ret, pid, pgid); -+ } -+ -+ int sys_setsid(pid_t *out) { -+ long ret; -+ long error = syscall(SYSCALL_SETSID, &ret); -+ *out = ret; -+ return error; -+ } -+ -+ int sys_futex_tid() { -+ long ret; -+ syscall(SYSCALL_GETTID, &ret); -+ return ret; -+ } -+ -+ #ifndef MLIBC_BUILDING_RTLD -+ -+ [[noreturn]] void sys_thread_exit() { -+ syscall(SYSCALL_THREADEXIT, nullptr); -+ } -+ -+ extern "C" void __mlibc_thread_entry(); -+ -+ int sys_clone(void *tcb, pid_t *pid_out, void *stack) { -+ long ret; -+ long err = syscall(SYSCALL_NEWTHREAD, &ret, (uintptr_t)__mlibc_thread_entry, (uintptr_t)stack); -+ *pid_out = ret; -+ return err; -+ } -+ -+ #endif -+ -+ int sys_listen(int fd, int backlog) { -+ long ret; -+ return syscall(SYSCALL_LISTEN, &ret, fd, backlog); -+ } -+ -+ int sys_accept(int fd, int *newfd, struct sockaddr *addr_ptr, socklen_t *addr_length, int flags) { -+ long ret; -+ long error = syscall(SYSCALL_ACCEPT, &ret, fd, (uint64_t)addr_ptr, (uint64_t)addr_length, flags); -+ *newfd = ret; -+ return error; -+ } -+ -+ int sys_connect(int fd, const struct sockaddr *addr_ptr, socklen_t addr_length) { -+ long ret; -+ return syscall(SYSCALL_CONNECT, &ret, fd, (uint64_t)addr_ptr, addr_length); -+ } -+ -+ int sys_msg_recv(int fd, struct msghdr *hdr, int flags, ssize_t *length) { -+ long ret; -+ long err = syscall(SYSCALL_RECVMSG, &ret, fd, (uint64_t)hdr, flags); -+ *length = ret; -+ return err; -+ } -+ -+ int sys_setsockopt(int fd, int layer, int number, const void *buffer, socklen_t size) { -+ long ret; -+ return syscall(SYSCALL_SETSOCKOPT, &ret, fd, layer, number, (uint64_t)buffer, size); -+ } -+ -+ int sys_msg_send(int fd, const struct msghdr *hdr, int flags, ssize_t *length) { -+ long ret; -+ long err = syscall(SYSCALL_SENDMSG, &ret, fd, (uint64_t)hdr, flags); -+ *length = ret; -+ return err; -+ } -+ -+ int sys_bind(int fd, const struct sockaddr *addr_ptr, socklen_t addr_length) { -+ long ret; -+ return syscall(SYSCALL_BIND, &ret, fd, (uint64_t)addr_ptr, addr_length); -+ } -+ -+ int sys_socket(int family, int type, int protocol, int *fd) { -+ long ret; -+ long err = syscall(SYSCALL_SOCKET, &ret, family, type, protocol); -+ *fd = ret; -+ return err; -+ } -+ -+ int sys_renameat(int olddirfd, const char *old_path, int newdirfd, const char *new_path) { -+ long ret; -+ return syscall(SYSCALL_RENAMEAT, &ret, olddirfd, (uint64_t)old_path, newdirfd, (uint64_t)new_path); -+ } -+ -+ int sys_rename(const char *path, const char *new_path) { -+ return sys_renameat(AT_FDCWD, path, AT_FDCWD, new_path); -+ } -+ -+ int sys_utimensat(int dirfd, const char *pathname, const struct timespec times[2], int flags) { -+ long ret; -+ return syscall(SYSCALL_UTIMENSAT, &ret, dirfd, (uint64_t)pathname, (uint64_t)times, flags); -+ } -+ -+ int sys_fchownat(int dirfd, const char *pathname, uid_t owner, gid_t group, int flags) { -+ long ret; -+ return syscall(SYSCALL_FCHOWNAT, &ret, dirfd, (uint64_t)pathname, owner, group, flags); -+ } -+ -+ int sys_mount(const char *source, const char *target, const char *fstype, unsigned long flags, const void *data) { -+ long ret; -+ return syscall(SYSCALL_MOUNT, &ret, (uint64_t)source, (uint64_t)target, (uint64_t)fstype, flags, (uint64_t)data); -+ } -+ -+ int sys_ftruncate(int fd, size_t size) { -+ long ret; -+ return syscall(SYSCALL_FTRUNCATE, &ret, fd, size); -+ } -+ -+ int sys_sleep(time_t *secs, long *nanos) { -+ struct timespec ts; -+ ts.tv_sec = *secs; -+ ts.tv_nsec = *nanos; -+ long ret; -+ long err = syscall(SYSCALL_NANOSLEEP, &ret, (uintptr_t)&ts, (uintptr_t)&ts); -+ *secs = ts.tv_sec; -+ *nanos = ts.tv_nsec; -+ return err; -+ } -+ -+ int sys_tcgetattr(int fd, struct termios *attr){ -+ int res; -+ return sys_ioctl(fd, TCGETS, (void *)attr, &res); -+ } -+ -+ int sys_tcsetattr(int fd, int act, const struct termios *attr){ -+ int res; -+ return sys_ioctl(fd, TCSETS, (void *)attr, &res); -+ } -+ -+ int sys_poll(struct pollfd *fds, nfds_t count, int timeout, int *num_events) { -+ long ret; -+ long error = syscall(SYSCALL_POLL, &ret, (uint64_t)fds, count, timeout); -+ *num_events = ret; -+ return error; -+ } -+ -+ int sys_ppoll(struct pollfd *fds, nfds_t nfds, const struct timespec *timeout, const sigset_t *sigmask, int *num_events) { -+ long ret; -+ long error = syscall(SYSCALL_PPOLL, &ret, (uint64_t)fds, nfds, (uint64_t)timeout, (uint64_t)sigmask); -+ *num_events = ret; -+ return error; -+ } -+ -+#ifndef MLIBC_BUILDING_RTLD -+ int sys_pselect(int num_fds, fd_set *read_set, fd_set *write_set, fd_set *except_set, const struct timespec *timeout, const sigset_t *sigmask, int *num_events) { -+ pollfd *fds = (pollfd *)malloc(num_fds * sizeof(pollfd)); -+ -+ if(fds == NULL) -+ return ENOMEM; -+ -+ int actualcount = 0; -+ -+ for (int fd = 0; fd < num_fds; ++fd) { -+ short events = 0; -+ if (read_set && FD_ISSET(fd, read_set)) { -+ events |= POLLIN; -+ } -+ -+ if (write_set && FD_ISSET(fd, write_set)) { -+ events |= POLLOUT; -+ } -+ -+ if (except_set && FD_ISSET(fd, except_set)) { -+ events |= POLLPRI; -+ } -+ -+ if (events) { -+ fds[actualcount].fd = fd; -+ fds[actualcount].events = events; -+ fds[actualcount].revents = 0; -+ actualcount++; -+ } -+ } -+ -+ int num; -+ int err = sys_ppoll(fds, actualcount, timeout, sigmask, &num); -+ -+ if (err) { -+ free(fds); -+ return err; -+ } -+ -+ #define READ_SET_POLLSTUFF (POLLIN | POLLHUP | POLLERR) -+ #define WRITE_SET_POLLSTUFF (POLLOUT | POLLERR) -+ #define EXCEPT_SET_POLLSTUFF (POLLPRI) -+ -+ int returncount = 0; -+ for (int fd = 0; fd < actualcount; ++fd) { -+ int events = fds[fd].events; -+ if ((events & POLLIN) && (fds[fd].revents & READ_SET_POLLSTUFF) == 0) { -+ FD_CLR(fds[fd].fd, read_set); -+ events &= ~POLLIN; -+ } -+ -+ if ((events & POLLOUT) && (fds[fd].revents & WRITE_SET_POLLSTUFF) == 0) { -+ FD_CLR(fds[fd].fd, write_set); -+ events &= ~POLLOUT; -+ } -+ -+ if ((events & POLLPRI) && (fds[fd].revents & EXCEPT_SET_POLLSTUFF) == 0) { -+ FD_CLR(fds[fd].fd, except_set); -+ events &= ~POLLPRI; -+ } -+ -+ if (events) -+ returncount++; -+ } -+ *num_events = returncount; -+ free(fds); -+ return 0; -+ } -+#endif -+ -+ int sys_umask(mode_t mode, mode_t *old) { -+ long ret; -+ long error = syscall(SYSCALL_UMASK, &ret, mode); -+ *old = ret; -+ return error; -+ } -+ -+ int sys_fchmod(int fd, mode_t mode) { -+ long ret; -+ return syscall(SYSCALL_FCHMOD, &ret, fd, mode); -+ } -+ -+ int sys_fchmodat(int fd, const char *pathname, mode_t mode, int flags) { -+ long ret; -+ return syscall(SYSCALL_FCHMODAT, &ret, fd, (uint64_t)pathname, mode, flags); -+ } -+ -+ int sys_chmod(const char *pathname, mode_t mode) { -+ return sys_fchmodat(AT_FDCWD, pathname, mode, 0); -+ } -+ -+ int sys_readlinkat(int dirfd, const char *path, void *buffer, size_t max_size, ssize_t *length) { -+ long ret; -+ long error = syscall(SYSCALL_READLINKAT, &ret, dirfd, (uint64_t)path, (uint64_t)buffer, max_size); -+ *length = ret; -+ return error; -+ } -+ -+ int sys_readlink(const char *path, void *buffer, size_t max_size, ssize_t *length) { -+ return sys_readlinkat(AT_FDCWD, path, buffer, max_size, length); -+ } -+ -+ static int dolink(int oldfd, const char *oldpath, int newfd, const char *newpath, int flags, int type) { -+ long ret; -+ return syscall(SYSCALL_LINKAT, &ret, oldfd, (uint64_t)oldpath, newfd, (uint64_t)newpath, flags, type); -+ } -+ -+ int sys_linkat(int olddirfd, const char *old_path, int newdirfd, const char *new_path, int flags) { -+ return dolink(olddirfd, old_path, newdirfd, new_path, flags, 0); -+ } -+ -+ int sys_link(const char *old_path, const char *new_path) { -+ return sys_linkat(AT_FDCWD, old_path, AT_FDCWD, new_path, 0); -+ } -+ -+ int sys_symlinkat(const char *target_path, int dirfd, const char *link_path) { -+ return dolink(AT_FDCWD, target_path, dirfd, link_path, 0, 1); -+ } -+ -+ int sys_symlink(const char *target_path, const char *link_path) { -+ return sys_symlinkat(target_path, AT_FDCWD, link_path); -+ } -+ -+ int sys_mkdirat(int dirfd, const char *path, mode_t mode) { -+ long ret; -+ return syscall(SYSCALL_MKDIRAT, &ret, dirfd, (uint64_t)path, mode); -+ } -+ -+ int sys_mkdir(const char *path, mode_t mode) { -+ return sys_mkdirat(AT_FDCWD, path, mode); -+ } -+ -+ int sys_ioctl(int fd, unsigned long request, void *arg, int *result) { -+ long ret; -+ long err = syscall(SYSCALL_IOCTL, &ret, fd, request, (uint64_t)arg); -+ *result = ret; -+ return err; -+ } -+ -+ int sys_unlinkat(int fd, const char *path, int flags) { -+ long ret; -+ return syscall(SYSCALL_UNLINKAT, &ret, fd, (uint64_t)path, flags); -+ } -+ -+ int sys_faccessat(int dirfd, const char *pathname, int mode, int flags){ -+ long ret; -+ return syscall(SYSCALL_FACCESSAT, &ret, dirfd, (uint64_t)pathname, mode, flags); -+ } -+ -+ int sys_access(const char *path, int mode){ -+ return sys_faccessat(AT_FDCWD, path, mode, 0); -+ } -+ -+ int sys_pipe(int *fds, int flags) { -+ long ret = 0; -+ long err = syscall(SYSCALL_PIPE2, &ret, flags); -+ if (err) -+ return err; -+ -+ fds[0] = ret & 0xffffffff; -+ fds[1] = (ret >> 32) & 0xffffffff; -+ return err; -+ } -+ -+ int sys_chdir(const char *path) { -+ long ret; -+ return syscall(SYSCALL_CHDIR, &ret, (uint64_t)path); -+ } -+ -+ int sys_fchdir(int fd) { -+ long ret; -+ return syscall(SYSCALL_FCHDIR, &ret, fd); -+ } -+ -+ int sys_fcntl(int fd, int request, va_list args, int *result) { -+ long arg = va_arg(args, uint64_t); -+ long ret; -+ long err = syscall(SYSCALL_FCNTL, &ret, fd, request, arg); -+ *result = ret; -+ return err; -+ } -+ -+ int sys_dup(int fd, int flags, int *newfd) { -+ long ret; -+ long err = syscall(SYSCALL_DUP, &ret, fd); -+ *newfd = ret; -+ return err; -+ } -+ -+ int sys_dup2(int fd, int flags, int newfd) { -+ long ret; -+ return syscall(SYSCALL_DUP2, &ret, fd, newfd); -+ } -+ -+ int sys_read_entries(int handle, void *buffer, size_t max_size, size_t *bytes_read) { -+ long ret; -+ long err = syscall(SYSCALL_GETDENTS, &ret, handle, (uint64_t)buffer, max_size); -+ if (err) -+ return err; -+ *bytes_read = ret; -+ return err; -+ } -+ -+ int sys_waitpid(pid_t pid, int *status, int flags, struct rusage *ru, pid_t *ret_pid) { -+ long ret; -+ long err = syscall(SYSCALL_WAITPID, &ret, pid, (uint64_t)status, flags); -+ *ret_pid = ret; -+ return err; -+ } -+ -+ int sys_execve(const char *path, char *const argv[], char *const envp[]) { -+ long ret; -+ return syscall(SYSCALL_EXECVE, &ret, (uint64_t)path, (uint64_t)argv, (uint64_t)envp); -+ } -+ -+ int sys_fork(pid_t *pid) { -+ long ret = 0; -+ long error = syscall(SYSCALL_FORK, &ret); -+ *pid = ret; -+ return error; -+ } -+ -+ int sys_stat(fsfd_target fsfdt, int fd, const char *path, int flags, struct stat *statbuf) { -+ long ret; -+ switch (fsfdt) { -+ case fsfd_target::path: -+ return syscall(SYSCALL_FSTATAT, &ret, AT_FDCWD, (uint64_t)path, (uint64_t)statbuf, flags); -+ case fsfd_target::fd: -+ return syscall(SYSCALL_FSTAT, &ret, fd, (uint64_t)statbuf); -+ case fsfd_target::fd_path: -+ return syscall(SYSCALL_FSTATAT, &ret, fd, (uint64_t)path, (uint64_t)statbuf, flags); -+ default: -+ mlibc::infoLogger() << "mlibc: stat: Unknown fsfd_target: " << (int)fsfdt << frg::endlog; -+ return ENOSYS; -+ } -+ } -+ -+ pid_t sys_getpid() { -+ long ret; -+ syscall(SYSCALL_GETPID, &ret); -+ return ret; -+ } -+ -+ void sys_libc_log(const char *message) { -+ long ret; -+ syscall(SYSCALL_PRINT, &ret, (uint64_t)message); -+ } -+ -+ [[noreturn]] void sys_libc_panic() { -+ sys_libc_log("mlibc: panic"); -+ sys_exit(1); -+ } -+ -+ [[noreturn]] void sys_exit(int status) { -+ syscall(SYSCALL_EXIT, NULL, status); -+ __builtin_unreachable(); -+ } -+ -+ int sys_tcb_set(void *pointer) { -+ long r; -+ return syscall(SYSCALL_ARCHCTL, &r, ARCH_CTL_FSBASE, (uint64_t)pointer); -+ } -+ -+ #define FUTEX_WAIT 0 -+ #define FUTEX_WAKE 1 -+ -+ int sys_futex_wait(int *pointer, int expected, const struct timespec *time) { -+ long ret; -+ return syscall(SYSCALL_FUTEX, &ret, (uint64_t)pointer, FUTEX_WAIT, expected, (uint64_t)time); -+ } -+ -+ int sys_futex_wake(int *pointer) { -+ long ret; -+ return syscall(SYSCALL_FUTEX, &ret, (uint64_t)pointer, FUTEX_WAKE, INT_MAX, NULL); -+ } -+ -+ int sys_anon_allocate(size_t size, void **pointer) { -+ size += 4096 - (size % 4096); -+ return sys_vm_map(NULL, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, 0, 0, pointer); -+ } -+ int sys_anon_free(void *pointer, size_t size) { -+ size += 4096 - (size % 4096); -+ return sys_vm_unmap(pointer, size); -+ } -+ -+ int sys_openat(int dirfd, const char *path, int flags, mode_t mode, int *fd) { -+ long ret; -+ long err = syscall(SYSCALL_OPENAT, &ret, dirfd, (uint64_t)path, flags, mode); -+ if (err) -+ return err; -+ *fd = ret; -+ return 0; -+ } -+ -+ int sys_open(const char *pathname, int flags, mode_t mode, int *fd) { -+ return sys_openat(AT_FDCWD, pathname, flags, mode, fd); -+ }; -+ -+ int sys_open_dir(const char *path, int *handle) { -+ return sys_open(path, O_DIRECTORY, 0, handle); -+ } -+ -+ int sys_read(int fd, void *buff, size_t count, ssize_t *bytes_read) { -+ long readc; -+ long error = syscall(SYSCALL_READ, &readc, fd, (uint64_t)buff, count); -+ *bytes_read = readc; -+ return error; -+ } -+ -+ int sys_write(int fd, const void *buff, size_t count, ssize_t *bytes_written) { -+ long writec; -+ long error = syscall(SYSCALL_WRITE, &writec, fd, (uint64_t)buff, count); -+ *bytes_written = writec; -+ return error; -+ } -+ -+ int sys_seek(int fd, off_t offset, int whence, off_t *new_offset) { -+ long ret = 0; -+ long error = syscall(SYSCALL_SEEK, &ret, fd, offset, whence); -+ *new_offset = ret; -+ return error; -+ } -+ -+ int sys_close(int fd) { -+ long r; -+ return syscall(SYSCALL_CLOSE, &r, fd); -+ } -+ -+ int sys_vm_map(void *hint, size_t size, int prot, int flags, int fd, off_t offset, void **window) { -+ long ret; -+ long err = syscall(SYSCALL_MMAP, &ret, (uint64_t)hint, size, prot, flags, fd, offset); -+ *window = (void *)ret; -+ return err; -+ } -+ -+ int sys_vm_unmap(void *pointer, size_t size) { -+ long ret; -+ return syscall(SYSCALL_MUNMAP, &ret, (uintptr_t)pointer, size); -+ } -+ -+ int sys_isatty(int fd) { -+ long ret; -+ return syscall(SYSCALL_ISATTY, &ret, fd); -+ } -+ -+ int sys_clock_get(int clock, time_t *secs, long *nanos) { -+ struct timespec ts; -+ long ret; -+ int err = syscall(SYSCALL_CLOCKGET, &ret, clock, (uint64_t)&ts); -+ *secs = ts.tv_sec; -+ *nanos = ts.tv_nsec; -+ return err; -+ } -+ -+} // namespace mlibc -diff --git mlibc-workdir/sysdeps/astral/include/astral/archctl.h mlibc-workdir/sysdeps/astral/include/astral/archctl.h -new file mode 100644 -index 0000000..990eca0 ---- /dev/null -+++ mlibc-workdir/sysdeps/astral/include/astral/archctl.h -@@ -0,0 +1,11 @@ -+#ifndef _ASTRAL_SYSCALL_ARCHCTL_INCLUDE -+#define _ASTRAL_SYSCALL_ARCHCTL_INCLUDE -+ -+#include -+ -+#define ARCH_CTL_GSBASE 0 -+#define ARCH_CTL_FSBASE 1 -+ -+int arch_ctl(int func, void *arg); -+ -+#endif -diff --git mlibc-workdir/sysdeps/astral/include/astral/syscall.h mlibc-workdir/sysdeps/astral/include/astral/syscall.h -new file mode 100644 -index 0000000..4d603e8 ---- /dev/null -+++ mlibc-workdir/sysdeps/astral/include/astral/syscall.h -@@ -0,0 +1,115 @@ -+#ifndef _SYSCALL_H_INCLUDE -+#define _SYSCALL_H_INCLUDE -+ -+#define SYSCALL_PRINT 0 -+#define SYSCALL_MMAP 1 -+#define SYSCALL_OPENAT 2 -+#define SYSCALL_READ 3 -+#define SYSCALL_SEEK 4 -+#define SYSCALL_CLOSE 5 -+#define SYSCALL_ARCHCTL 6 -+#define SYSCALL_WRITE 7 -+#define SYSCALL_GETPID 8 -+#define SYSCALL_FSTAT 9 -+#define SYSCALL_FSTATAT 10 -+#define SYSCALL_FORK 11 -+#define SYSCALL_EXECVE 12 -+#define SYSCALL_EXIT 13 -+#define SYSCALL_WAITPID 14 -+#define SYSCALL_MUNMAP 15 -+#define SYSCALL_GETDENTS 16 -+#define SYSCALL_DUP 17 -+#define SYSCALL_DUP2 18 -+#define SYSCALL_DUP3 19 -+#define SYSCALL_FCNTL 20 -+#define SYSCALL_CHDIR 21 -+#define SYSCALL_PIPE2 22 -+#define SYSCALL_ISATTY 23 -+#define SYSCALL_FACCESSAT 24 -+#define SYSCALL_UNLINKAT 25 -+#define SYSCALL_IOCTL 26 -+#define SYSCALL_MKDIRAT 27 -+#define SYSCALL_CLOCKGET 28 -+#define SYSCALL_LINKAT 29 -+#define SYSCALL_READLINKAT 30 -+#define SYSCALL_FCHMOD 31 -+#define SYSCALL_FCHMODAT 32 -+#define SYSCALL_UMASK 33 -+#define SYSCALL_POLL 34 -+#define SYSCALL_NANOSLEEP 35 -+#define SYSCALL_FTRUNCATE 36 -+#define SYSCALL_MOUNT 37 -+#define SYSCALL_FCHOWNAT 38 -+#define SYSCALL_UTIMENSAT 39 -+#define SYSCALL_RENAMEAT 40 -+#define SYSCALL_SOCKET 41 -+#define SYSCALL_BIND 42 -+#define SYSCALL_SENDMSG 43 -+#define SYSCALL_SETSOCKOPT 44 -+#define SYSCALL_RECVMSG 45 -+#define SYSCALL_LISTEN 46 -+#define SYSCALL_CONNECT 47 -+#define SYSCALL_ACCEPT 48 -+#define SYSCALL_NEWTHREAD 49 -+#define SYSCALL_THREADEXIT 50 -+#define SYSCALL_FUTEX 51 -+#define SYSCALL_GETTID 52 -+#define SYSCALL_GETPPID 53 -+#define SYSCALL_GETPGID 54 -+#define SYSCALL_GETSID 55 -+#define SYSCALL_SETSID 56 -+#define SYSCALL_SETPGID 57 -+#define SYSCALL_SIGACTION 58 -+#define SYSCALL_SIGALTSTACK 59 -+#define SYSCALL_SIGPROCMASK 60 -+#define SYSCALL_KILL 61 -+#define SYSCALL_SIGRETURN 62 -+#define SYSCALL_UNAME 63 -+#define SYSCALL_HOSTNAME 64 -+#define SYSCALL_SYNC 65 -+#define SYSCALL_FSYNC 66 -+#define SYSCALL_FCHDIR 67 -+#define SYSCALL_SETITIMER 68 -+#define SYSCALL_GETITIMER 69 -+#define SYSCALL_SOCKETPAIR 70 -+#define SYSCALL_GETSOCKNAME 71 -+#define SYSCALL_GETPEERNAME 72 -+#define SYSCALL_CHROOT 73 -+#define SYSCALL_PAUSE 74 -+#define SYSCALL_PPOLL 75 -+#define SYSCALL_PREAD 76 -+#define SYSCALL_PWRITE 77 -+#define SYSCALL_MKNODAT 78 -+#define SYSCALL_GETRESUID 79 -+#define SYSCALL_GETRESGID 80 -+#define SYSCALL_SETRESUID 81 -+#define SYSCALL_SETRESGID 82 -+#define SYSCALL_MPROTECT 83 -+#define SYSCALL_SETUID 84 -+#define SYSCALL_SETEUID 85 -+#define SYSCALL_SETGID 86 -+#define SYSCALL_SETEGID 87 -+#define SYSCALL_SIGSUSPEND 88 -+#define SYSCALL_SIGTIMEDWAIT 89 -+#define SYSCALL_SIGPENDING 90 -+#define SYSCALL_KILLTHREAD 91 -+ -+#include -+#include -+ -+static long syscall(long func, long* ret, uint64_t p1 = 0, uint64_t p2 = 0, uint64_t p3 = 0, uint64_t p4 = 0, uint64_t p5 = 0, uint64_t p6 = 0) { -+ volatile long err; -+ -+ register uint64_t r4 asm("r10") = p4; -+ register uint64_t r5 asm("r8") = p5; -+ register uint64_t r6 asm("r9") = p6; -+ -+ asm volatile("syscall" -+ : "=a"(*ret), "=d"(err) -+ : "a"(func), "D"(p1), "S"(p2), "d"(p3), "r"(r4), -+ "r"(r5), "r"(r6) -+ : "memory", "rcx", "r11"); -+ return err; -+} -+ -+#endif -diff --git mlibc-workdir/sysdeps/astral/meson.build mlibc-workdir/sysdeps/astral/meson.build -new file mode 100644 -index 0000000..f7c5b72 ---- /dev/null -+++ mlibc-workdir/sysdeps/astral/meson.build -@@ -0,0 +1,76 @@ -+ -+rtld_sources += files( -+ 'generic/generic.cpp', -+ 'generic/astral.cpp', -+) -+ -+libc_sources += files( -+ 'generic/entry.cpp', -+ 'generic/astral.cpp', -+ 'generic/generic.cpp', -+ 'threading/x86_64-thread.cpp', -+ 'threading/x86_64-thread-entry.S', -+ 'signal/x86_64-restorer.S', -+) -+ -+if not no_headers -+ install_headers( -+ 'include/abi-bits/access.h', -+ 'include/abi-bits/auxv.h', -+ 'include/abi-bits/seek-whence.h', -+ 'include/abi-bits/vm-flags.h', -+ 'include/abi-bits/errno.h', -+ 'include/abi-bits/fcntl.h', -+ 'include/abi-bits/in.h', -+ 'include/abi-bits/stat.h', -+ 'include/abi-bits/statx.h', -+ 'include/abi-bits/signal.h', -+ 'include/abi-bits/reboot.h', -+ 'include/abi-bits/resource.h', -+ 'include/abi-bits/socket.h', -+ 'include/abi-bits/termios.h', -+ 'include/abi-bits/time.h', -+ 'include/abi-bits/blkcnt_t.h', -+ 'include/abi-bits/blksize_t.h', -+ 'include/abi-bits/dev_t.h', -+ 'include/abi-bits/gid_t.h', -+ 'include/abi-bits/ino_t.h', -+ 'include/abi-bits/mode_t.h', -+ 'include/abi-bits/nlink_t.h', -+ 'include/abi-bits/pid_t.h', -+ 'include/abi-bits/uid_t.h', -+ 'include/abi-bits/wait.h', -+ 'include/abi-bits/limits.h', -+ 'include/abi-bits/utsname.h', -+ 'include/abi-bits/ptrace.h', -+ 'include/abi-bits/poll.h', -+ 'include/abi-bits/epoll.h', -+ 'include/abi-bits/packet.h', -+ 'include/abi-bits/inotify.h', -+ 'include/abi-bits/clockid_t.h', -+ 'include/abi-bits/shm.h', -+ 'include/abi-bits/mqueue.h', -+ 'include/abi-bits/suseconds_t.h', -+ 'include/abi-bits/fsfilcnt_t.h', -+ 'include/abi-bits/fsblkcnt_t.h', -+ 'include/abi-bits/socklen_t.h', -+ 'include/abi-bits/statfs.h', -+ 'include/abi-bits/statvfs.h', -+ 'include/abi-bits/ioctls.h', -+ 'include/abi-bits/xattr.h', -+ 'include/abi-bits/msg.h', -+ 'include/abi-bits/vt.h', -+ subdir: 'abi-bits' -+ ) -+endif -+ -+if not headers_only -+ crt = custom_target('crt0', -+ build_by_default: true, -+ command: c_compiler.cmd_array() + ['-c', '-o', '@OUTPUT@', '@INPUT@'], -+ input: 'crt-x86_64/crt0.S', -+ output: 'crt0.o', -+ install: true, -+ install_dir: get_option('libdir') -+ ) -+endif -diff --git mlibc-workdir/sysdeps/astral/signal/x86_64-restorer.S mlibc-workdir/sysdeps/astral/signal/x86_64-restorer.S -new file mode 100644 -index 0000000..dd33a36 ---- /dev/null -+++ mlibc-workdir/sysdeps/astral/signal/x86_64-restorer.S -@@ -0,0 +1,6 @@ -+.section .text -+.global __mlibc_restorer -+__mlibc_restorer: -+ sub $8, %rsp -+ mov $62, %rax -+ syscall -diff --git mlibc-workdir/sysdeps/astral/threading/x86_64-thread-entry.S mlibc-workdir/sysdeps/astral/threading/x86_64-thread-entry.S -new file mode 100644 -index 0000000..4cb3ae0 ---- /dev/null -+++ mlibc-workdir/sysdeps/astral/threading/x86_64-thread-entry.S -@@ -0,0 +1,7 @@ -+ .section .text -+.global __mlibc_thread_entry -+__mlibc_thread_entry: -+ pop %rdi -+ pop %rsi -+ pop %rdx -+ call __mlibc_thread_trampoline -diff --git mlibc-workdir/sysdeps/astral/threading/x86_64-thread.cpp mlibc-workdir/sysdeps/astral/threading/x86_64-thread.cpp -new file mode 100644 -index 0000000..3b893f0 ---- /dev/null -+++ mlibc-workdir/sysdeps/astral/threading/x86_64-thread.cpp -@@ -0,0 +1,59 @@ -+#include -+#include -+#include -+#include -+#include -+#include -+ -+extern "C" void __mlibc_thread_trampoline(void *(*fn)(void *), Tcb *tcb, void *arg) { -+ if (mlibc::sys_tcb_set(tcb)) { -+ __ensure(!"failed to set tcb for new thread"); -+ } -+ -+ while (__atomic_load_n(&tcb->tid, __ATOMIC_RELAXED) == 0) { -+ mlibc::sys_futex_wait(&tcb->tid, 0, nullptr); -+ } -+ -+ tcb->invokeThreadFunc(reinterpret_cast(fn), arg); -+ -+ __atomic_store_n(&tcb->didExit, 1, __ATOMIC_RELEASE); -+ mlibc::sys_futex_wake(&tcb->didExit); -+ -+ mlibc::sys_thread_exit(); -+} -+ -+#define DEFAULT_STACK 0x400000 -+ -+namespace mlibc { -+ int sys_prepare_stack(void **stack, void *entry, void *arg, void *tcb, size_t *stack_size, size_t *guard_size, void **stack_base) { -+ // TODO guard -+ -+ mlibc::infoLogger() << "mlibc: sys_prepare_stack() does not setup a guard!" << frg::endlog; -+ -+ *guard_size = 0; -+ -+ *stack_size = *stack_size ? *stack_size : DEFAULT_STACK; -+ -+ if (!*stack) { -+ *stack_base = mmap(NULL, *stack_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); -+ if (*stack_base == MAP_FAILED) { -+ return errno; -+ } -+ } else { -+ *stack_base = *stack; -+ } -+ -+ *stack = (void *)((char *)*stack_base + *stack_size); -+ -+ void **stack_it = (void **)*stack; -+ -+ *--stack_it = arg; -+ *--stack_it = tcb; -+ *--stack_it = entry; -+ -+ *stack = (void *)stack_it; -+ -+ return 0; -+ } -+ -+} diff --git a/recipes/cxxshim b/recipes/cxxshim deleted file mode 100644 index 7dbb55c9..00000000 --- a/recipes/cxxshim +++ /dev/null @@ -1,15 +0,0 @@ -name=cxxshim -from_source=cxxshim -revision=1 -hostdeps="xgcc xbinutils pkgconfig" -imagedeps="meson ninja base-devel" - -build() { - meson --cross-file ${base_dir}/util/crossfile --prefix=${prefix} -Dinstall_headers=true ${source_dir} --includedir="share/mlibc-build/cxxshim/include" - ninja -} - -package() { - DESTDIR=${dest_dir} ninja install -} - diff --git a/recipes/freestnd-c-hdrs b/recipes/freestnd-c-hdrs new file mode 100644 index 00000000..57112b72 --- /dev/null +++ b/recipes/freestnd-c-hdrs @@ -0,0 +1,12 @@ +name=freestnd-c-hdrs +from_source=freestnd-c-hdrs +revision=1 + +build() { + cp -rp "${source_dir}"/. ./ +} + +package() { + make install DESTDIR="${dest_dir}" PREFIX="${prefix}" +} + diff --git a/recipes/freestnd-cxx-hdrs b/recipes/freestnd-cxx-hdrs new file mode 100644 index 00000000..35df86ef --- /dev/null +++ b/recipes/freestnd-cxx-hdrs @@ -0,0 +1,12 @@ +name=freestnd-cxx-hdrs +from_source=freestnd-cxx-hdrs +revision=1 + +build() { + cp -rp "${source_dir}"/. ./ +} + +package() { + make install DESTDIR="${dest_dir}" PREFIX="${prefix}" +} + diff --git a/recipes/mlibc b/recipes/mlibc index 14e784fe..c3d8830f 100644 --- a/recipes/mlibc +++ b/recipes/mlibc @@ -2,12 +2,12 @@ name=mlibc from_source=mlibc revision=1 hostdeps="xgcc xbinutils pkgconfig" -builddeps="cxxshim frigg" +builddeps="freestnd-c-hdrs freestnd-cxx-hdrs frigg" imagedeps="meson ninja git base-devel binutils" deps="mlibc-headers" build() { - meson --cross-file ${base_dir}/util/crossfile -Dmlibc_no_headers=true --prefix=${prefix} ${source_dir} -Dlinux_kernel_headers=${sysroot_dir}/${prefix}/include + meson --cross-file ${base_dir}/util/crossfile -Dmlibc_no_headers=true --prefix=${prefix} ${source_dir} -Dlinux_kernel_headers=${sysroot_dir}/${prefix}/include -Ddisable_crypt_option=true -Ddisable_iconv_option=true -Ddisable_intl_option=true ninja } diff --git a/recipes/mlibc-headers b/recipes/mlibc-headers index 846b5418..c4873fcf 100644 --- a/recipes/mlibc-headers +++ b/recipes/mlibc-headers @@ -5,7 +5,7 @@ imagedeps="ninja meson base-devel rsync" builddeps="linux-headers" build() { - meson setup --cross-file "${base_dir}/util/crossfile" --prefix="${prefix}" -Dheaders_only=true "${source_dir}" + meson setup --cross-file "${base_dir}/util/crossfile" --prefix="${prefix}" -Dheaders_only=true "${source_dir}" -Ddisable_crypt_option=true -Ddisable_iconv_option=true -Ddisable_intl_option=true ninja mkdir linux cp -rp ${base_dir}/sources/linux/* linux diff --git a/recipes/nano b/recipes/nano index baf555fc..94461cbc 100644 --- a/recipes/nano +++ b/recipes/nano @@ -2,7 +2,7 @@ name=nano revision=1 from_source=nano imagedeps="base-devel" -hostdeps="xgcc xbinutils" +hostdeps="xgcc xbinutils pkgconfig libtool" deps="base ncurses" build() { diff --git a/recipes/ncurses b/recipes/ncurses index 2fed883e..1f95908e 100644 --- a/recipes/ncurses +++ b/recipes/ncurses @@ -2,7 +2,7 @@ name=ncurses revision=1 from_source=ncurses imagedeps="base-devel" -hostdeps="xgcc xbinutils libstdc++-v3" +hostdeps="xgcc xbinutils libstdc++-v3 pkgconfig libtool" deps="base" build() { diff --git a/recipes/tar b/recipes/tar index db824ffc..8c9fcb7a 100644 --- a/recipes/tar +++ b/recipes/tar @@ -7,8 +7,8 @@ deps="base bzip2 zlib gzip" build() { cp -rpf ${source_dir}/* . - ./configure --host=x86_64-astral --prefix=${prefix} - make -j ${parallelism} LDFLAGS="-lintl -liconv" + LDFLAGS="${LDFLAGS} -lintl -liconv" ./configure --host=x86_64-astral --prefix=${prefix} + make -j ${parallelism} } package() { diff --git a/source-recipes/cxxshim b/source-recipes/cxxshim deleted file mode 100644 index a2c0d686..00000000 --- a/source-recipes/cxxshim +++ /dev/null @@ -1,9 +0,0 @@ -name=cxxshim -version=9325f9f75672e50a4fbab5bef3b57c9c02705725 -source_method=tarball -tarball_url="https://github.com/managarm/cxxshim/archive/${version}.tar.gz" -tarball_sha512=9f7f5d1b8ec1ca5281be622e28798395a5e3246601be7e59d511b57b20f7be80b9be8c06df42db71c1cbb00f7d85cea87ce34ca22acb56ed6ab49f1bba46409e - -regenerate() { - true -} diff --git a/source-recipes/freestnd-c-hdrs b/source-recipes/freestnd-c-hdrs new file mode 100644 index 00000000..d2678354 --- /dev/null +++ b/source-recipes/freestnd-c-hdrs @@ -0,0 +1,9 @@ +name=freestnd-c-hdrs +version=2a75fc37ab374e52bd5862adb785169cc26cdb50 +source_method=tarball +tarball_url="https://github.com/osdev0/freestnd-c-hdrs/archive/${version}.tar.gz" +tarball_sha512=87f5e1d98539142da216766a269792ae4ee0a02abd02e8af45c33514866a408e01eca03bd6122574b3000b2234ab40f31c846a99d882162c6ecd89d0b08779e8 + +regenerate() { + true +} diff --git a/source-recipes/freestnd-cxx-hdrs b/source-recipes/freestnd-cxx-hdrs new file mode 100644 index 00000000..f29f77b6 --- /dev/null +++ b/source-recipes/freestnd-cxx-hdrs @@ -0,0 +1,9 @@ +name=freestnd-cxx-hdrs +version=34b801a8d6b601bf17b00df36fa82614e5be811d +source_method=tarball +tarball_url="https://github.com/osdev0/freestnd-cxx-hdrs/archive/${version}.tar.gz" +tarball_sha512=39e25168ba5dcfad0b222c82d84d9c01337c989afb3aaaf61be4bef71cde0e7f618e7a6ab475b0b6372ef95b47ab915c4f4c61182a1292f04083fa4b24714569 + +regenerate() { + true +} diff --git a/source-recipes/frigg b/source-recipes/frigg index 986aa55a..2282fd9e 100644 --- a/source-recipes/frigg +++ b/source-recipes/frigg @@ -1,8 +1,8 @@ name=frigg -version=edf7b21dc7b5db709ef41f895a252a50c3db87e3 +version=91ada7d4e12b9e73a454e7be13919e989444faa2 source_method=tarball tarball_url="https://github.com/managarm/frigg/archive/${version}.tar.gz" -tarball_sha512=9a552e227ea7395916ac1edac7dd43b3ee2d7fb8ebc8ede400be40c57e36f80a577e087ecee7f10df062f7b66da0050ff29d24d0e61574303f6c7f06ecac8e5e +tarball_sha512=d7011bcb0b2adfe88968de7cf9080fc71664725784491e66266b34b7fd83c2e3005f8ba7b530116075a7f5f7b31103af9aef1b32dab3143ed9ae3a247d2aa655 regenerate() { true diff --git a/source-recipes/libtool b/source-recipes/libtool index 433b5de0..5cd827b6 100644 --- a/source-recipes/libtool +++ b/source-recipes/libtool @@ -8,7 +8,5 @@ imagedeps="base-devel help2man wget" allow_network="yes" regenerate() { - wget https://git.savannah.gnu.org/cgit/gnulib.git/snapshot/gnulib-4b17a1ae49e69df1ac5dc35a4f60b20ab958baf2.tar.gz - tar -xf gnulib-4b17a1ae49e69df1ac5dc35a4f60b20ab958baf2.tar.gz - ./bootstrap --force --skip-git --skip-po --gnulib-srcdir=`pwd`/gnulib-4b17a1ae49e69df1ac5dc35a4f60b20ab958baf2 + true } diff --git a/source-recipes/mlibc b/source-recipes/mlibc index a493c2c5..9f3468d3 100644 --- a/source-recipes/mlibc +++ b/source-recipes/mlibc @@ -1,10 +1,9 @@ name=mlibc -version=fee1ca4a2e6a397040ea2647875c1146e5f0e564 +version=b842be7802f53dea7c5700512d20d6471831e3c7 source_method=tarball tarball_url="https://github.com/managarm/mlibc/archive/${version}.tar.gz" -tarball_sha512="01834b5f109f6040a991c8edfa96dcab7d33fe3dae06738230af16ecfa402dc4219d4c3e79ff8d6deafa52a498bd4781848b42becf316f206385b20092e9f24f" +tarball_sha512="0fe5f95771f37d6d57eb2f5b22d156dbd746b77c444e7c7cc065ae6fe51c646c2e03575960ab16fba79abb447fce30950d2201a09c6e0290d405e1eab94d3ffd" regenerate() { - mkdir -p ${source_dir}/sysdeps/astral/include/ - ln -sv ../../../abis/linux/ ${source_dir}/sysdeps/astral/include/abi-bits + true }