user: implement mlibc as the libc, finally.

It's finally done..

Signed-off-by: kaguya <vpshinomiya@protonmail.com>

user/include/mlibc/sysdeps/vinix/.clang-format

@@ -0,0 +1,2 @@
+---
+DisableFormat: true

user/include/mlibc/sysdeps/vinix/generic/entry.cpp

@@ -0,0 +1,100 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <bits/ensure.h>
+#include <mlibc/debug.hpp>
+#include <mlibc/elf/startup.h>
+#include <mlibc/all-sysdeps.hpp>
+#include <bits/posix/posix_signal.h>
+
+#include "syscall.h"
+
+extern "C" void __dlapi_enter(uintptr_t *);
+
+extern char **environ;
+
+struct GPRState {
+	uint64_t ds;
+	uint64_t es;
+	uint64_t rax;
+	uint64_t rbx;
+	uint64_t rcx;
+	uint64_t rdx;
+	uint64_t rsi;
+	uint64_t rdi;
+	uint64_t rbp;
+	uint64_t r8;
+	uint64_t r9;
+	uint64_t r10;
+	uint64_t r11;
+	uint64_t r12;
+	uint64_t r13;
+	uint64_t r14;
+	uint64_t r15;
+	uint64_t err;
+	uint64_t rip;
+	uint64_t cs;
+	uint64_t rflags;
+	uint64_t rsp;
+	uint64_t ss;
+};
+
+namespace mlibc {
+	int sys_sigentry(void *sigentry) {
+		__syscall_ret ret = __syscall(27, sigentry);
+		if (ret.errno != 0)
+			return ret.errno;
+		return 0;
+	}
+
+	[[noreturn]] int sys_sigreturn(void *context, sigset_t old_mask) {
+		__syscall(30, context, old_mask);
+		__builtin_unreachable();
+	}
+}
+
+static void __mlibc_sigentry(int which, siginfo_t *siginfo,
+		void (*sa)(int, siginfo_t *, void *),
+		GPRState *ret_context, sigset_t prev_mask) {
+
+/*
+	size_t *base_ptr = (size_t *)ret_context->rbp;
+	mlibc::infoLogger() << "Stacktrace:" << frg::endlog;
+	mlibc::infoLogger() << "  [" << (void *)ret_context->rip << "]" << frg::endlog;
+	for (;;) {
+		size_t old_bp = base_ptr[0];
+		size_t ret_addr = base_ptr[1];
+		if (!ret_addr)
+			break;
+		size_t off;
+		mlibc::infoLogger() << "  [" << (void *)ret_addr << "]" << frg::endlog;
+		if (!old_bp)
+			break;
+		base_ptr = (size_t *)old_bp;
+	}
+*/
+
+	switch ((uintptr_t)sa) {
+		// DFL
+		case (uintptr_t)(-2):
+			mlibc::infoLogger() << "mlibc: Unhandled signal " << which << frg::endlog;
+			mlibc::sys_exit(128 + which);
+		// IGN
+		case (uintptr_t)(-3):
+			break;
+		default:
+			sa(which, siginfo, NULL);
+			break;
+	}
+
+	mlibc::sys_sigreturn(ret_context, prev_mask);
+
+	__builtin_unreachable();
+}
+
+extern "C" void __mlibc_entry(uintptr_t *entry_stack, int (*main_fn)(int argc, char *argv[], char *env[])) {
+	mlibc::sys_sigentry((void *)__mlibc_sigentry);
+
+	__dlapi_enter(entry_stack);
+	auto result = main_fn(mlibc::entry_stack.argc, mlibc::entry_stack.argv, environ);
+	exit(result);
+}

user/include/mlibc/sysdeps/vinix/generic/generic.cpp

@@ -0,0 +1,913 @@
+#include <bits/ensure.h>
+#include <mlibc/debug.hpp>
+#include <mlibc/all-sysdeps.hpp>
+#include <errno.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <asm/ioctls.h>
+#include <stdlib.h>
+
+#include "syscall.h"
+
+#define STUB_ONLY {                             \
+	__ensure(!"STUB_ONLY function was called"); \
+	__builtin_unreachable();                    \
+}
+
+#ifndef MLIBC_BUILDING_RTLD
+
+namespace {
+
+int fcntl_helper(int fd, int request, int *result, ...) {
+	va_list args;
+	va_start(args, result);
+	if(!mlibc::sys_fcntl) {
+		return ENOSYS;
+	}
+	int ret = mlibc::sys_fcntl(fd, request, args, result);
+	va_end(args);
+	return ret;
+}
+
+}
+
+#endif
+
+namespace mlibc {
+
+void sys_libc_log(const char *message) {
+	__syscall(0, message);
+}
+
+void sys_libc_panic() {
+	sys_libc_log("\nMLIBC PANIC\n");
+	sys_exit(1);
+	__builtin_unreachable();
+}
+
+void sys_exit(int status) {
+	__syscall(15, status);
+	__builtin_unreachable();
+}
+
+#ifndef MLIBC_BUILDING_RTLD
+
+[[noreturn]] void sys_thread_exit() {
+	for (;;);
+	__builtin_unreachable();
+}
+
+extern "C" void __mlibc_thread_entry();
+
+int sys_clone(void *tcb, pid_t *pid_out, void *stack) {
+	(void)tcb;
+
+	__syscall_ret ret = __syscall(65, (uintptr_t)__mlibc_thread_entry, (uintptr_t)stack);
+	int ret_value = (int)ret.ret;
+	if (ret_value == -1) {
+		return ret.errno;
+	}
+
+	*pid_out = ret_value;
+	return 0;
+}
+
+int sys_kill(pid_t pid, int signal) {
+	__syscall_ret ret = __syscall(26, pid, signal);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+int sys_tcgetattr(int fd, struct termios *attr) {
+	int ret;
+
+	if (int r = sys_ioctl(fd, TCGETS, attr, &ret) != 0) {
+		return r;
+	}
+
+	return 0;
+}
+
+int sys_tcsetattr(int fd, int optional_action, const struct termios *attr) {
+	int ret;
+
+	switch (optional_action) {
+		case TCSANOW:
+			optional_action = TCSETS; break;
+		case TCSADRAIN:
+			optional_action = TCSETSW; break;
+		case TCSAFLUSH:
+			optional_action = TCSETSF; break;
+		default:
+			__ensure(!"Unsupported tcsetattr");
+	}
+
+	if (int r = sys_ioctl(fd, optional_action, (void *)attr, &ret) != 0) {
+		return r;
+	}
+
+	return 0;
+}
+
+#endif
+
+int sys_tcb_set(void *pointer) {
+	__syscall(7, pointer);
+	return 0;
+}
+
+#ifndef MLIBC_BUILDING_RTLD
+
+int sys_ppoll(struct pollfd *fds, int nfds, const struct timespec *timeout,
+		const sigset_t *sigmask, int *num_events) {
+	__syscall_ret ret = __syscall(36, fds, nfds, timeout, sigmask);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	*num_events = (int)ret.ret;
+	return 0;
+}
+
+int sys_poll(struct pollfd *fds, nfds_t count, int timeout, int *num_events) {
+	struct timespec ts;
+	ts.tv_sec = timeout / 1000;
+	ts.tv_nsec = (timeout % 1000) * 1000000;
+	return sys_ppoll(fds, count, timeout < 0 ? NULL : &ts, NULL, num_events);
+}
+
+int sys_pselect(int nfds, fd_set *read_set, fd_set *write_set,
+		fd_set *except_set, const struct timespec *timeout,
+		const sigset_t *sigmask, int *num_events) {
+	struct pollfd *fds = (struct pollfd *)calloc(nfds, sizeof(struct pollfd));
+	if (fds == NULL) {
+		return ENOMEM;
+	}
+
+	for (int i = 0; i < nfds; i++) {
+		struct pollfd *fd = &fds[i];
+
+		if (read_set && FD_ISSET(i, read_set))
+			fd->events |= POLLIN; // TODO: Additional events.
+		if (write_set && FD_ISSET(i, write_set))
+			fd->events |= POLLOUT; // TODO: Additional events.
+		if (except_set && FD_ISSET(i, except_set))
+			fd->events |= POLLPRI;
+
+		if (!fd->events) {
+			fd->fd = -1;
+			continue;
+		}
+
+		fd->fd = i;
+	}
+
+	int e = sys_ppoll(fds, nfds, timeout, sigmask, num_events);
+
+	if (e != 0) {
+		free(fds);
+		return e;
+	}
+
+	fd_set res_read_set;
+	fd_set res_write_set;
+	fd_set res_except_set;
+	FD_ZERO(&res_read_set);
+	FD_ZERO(&res_write_set);
+	FD_ZERO(&res_except_set);
+
+	for (int i = 0; i < nfds; i++) {
+		struct pollfd *fd = &fds[i];
+
+		if (read_set && FD_ISSET(i, read_set)
+				&& fd->revents & (POLLIN | POLLERR | POLLHUP)) {
+			FD_SET(i, &res_read_set);
+		}
+
+		if (write_set && FD_ISSET(i, write_set)
+				&& fd->revents & (POLLOUT | POLLERR | POLLHUP)) {
+			FD_SET(i, &res_write_set);
+		}
+
+		if (except_set && FD_ISSET(i, except_set)
+				&& fd->revents & POLLPRI) {
+			FD_SET(i, &res_except_set);
+		}
+	}
+
+	free(fds);
+
+	if (read_set)
+		*read_set = res_read_set;
+	if (write_set)
+		*write_set = res_write_set;
+	if (except_set)
+		*except_set = res_except_set;
+
+	return 0;
+}
+
+#endif
+
+int sys_futex_wait(int *pointer, int expected, const struct timespec *time) {
+	__syscall_ret ret = __syscall(23, pointer, expected, time);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+int sys_futex_wake(int *pointer) {
+	__syscall_ret ret = __syscall(24, pointer);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+#ifndef MLIBC_BUILDING_RTLD
+
+int sys_ioctl(int fd, unsigned long request, void *arg, int *result) {
+	__syscall_ret ret = __syscall(9, fd, request, arg);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	*result = (int)ret.ret;
+	return 0;
+}
+
+int sys_isatty(int fd) {
+	struct winsize ws;
+	int ret;
+
+	if (!sys_ioctl(fd, TIOCGWINSZ, &ws, &ret))
+		return 0;
+
+	return ENOTTY;
+}
+
+int sys_getcwd(char *buffer, size_t size) {
+	__syscall_ret ret = __syscall(25, buffer, size);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+#endif
+
+int sys_openat(int dirfd, const char *path, int flags, mode_t mode, int *fd) {
+	__syscall_ret ret = __syscall(2, dirfd, path, flags, mode);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	*fd = (int)ret.ret;
+	return 0;
+}
+
+int sys_open(const char *path, int flags, mode_t mode, int *fd) {
+	return sys_openat(AT_FDCWD, path, flags, mode, fd);
+}
+
+#ifndef MLIBC_BUILDING_RTLD
+
+int sys_open_dir(const char *path, int *handle) {
+	return sys_open(path, O_DIRECTORY, 0, handle);
+}
+
+int sys_read_entries(int fd, void *buffer, size_t max_size, size_t *bytes_read) {
+	(void)max_size;
+	__syscall_ret ret = __syscall(19, fd, buffer);
+
+	if (ret.ret == (uint64_t)-1 && ret.errno == 0) {
+		// End of directory.
+		*bytes_read = 0;
+		return 0;
+	} else if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	*bytes_read = sizeof(struct dirent);
+	return 0;
+}
+
+#endif
+
+int sys_close(int fd) {
+	__syscall_ret ret = __syscall(6, fd);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+int sys_seek(int fd, off_t offset, int whence, off_t *new_offset) {
+	__syscall_ret ret = __syscall(5, fd, offset, whence);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	*new_offset = (off_t)ret.ret;
+	return 0;
+}
+
+int sys_read(int fd, void *buf, size_t count, ssize_t *bytes_read) {
+	__syscall_ret ret = __syscall(3, fd, buf, count);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	*bytes_read = (ssize_t)ret.ret;
+	return 0;
+}
+
+#ifndef MLIBC_BUILDING_RTLD
+
+int sys_write(int fd, const void *buf, size_t count, ssize_t *bytes_written) {
+	__syscall_ret ret = __syscall(4, fd, buf, count);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	*bytes_written = (ssize_t)ret.ret;
+	return 0;
+}
+
+int sys_readlink(const char *path, void *data, size_t max_size, ssize_t *length) {
+	__syscall_ret ret = __syscall(33, AT_FDCWD, path, data, max_size);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	*length = (ssize_t)ret.ret;
+	return 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_linkat(int olddirfd, const char *old_path, int newdirfd, const char *new_path, int flags) {
+	__syscall_ret ret = __syscall(58, olddirfd, old_path, newdirfd, new_path, flags);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	return 0;
+}
+
+int sys_unlinkat(int fd, const char *path, int flags) {
+	__syscall_ret ret = __syscall(35, fd, path, flags);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	return 0;
+}
+
+int sys_fchmod(int fd, mode_t mode) {
+	__syscall_ret ret = __syscall(57, fd, mode);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	return 0;
+}
+
+int sys_rmdir(const char *path) {
+	__syscall_ret ret = __syscall(37, AT_FDCWD, path);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	return 0;
+}
+
+#endif
+
+int sys_vm_map(void *hint, size_t size, int prot, int flags,
+			   int fd, off_t offset, void **window) {
+	__syscall_ret ret = __syscall(1, hint, size,
+								  (uint64_t)prot << 32 | (uint64_t)flags, fd, offset);
+	if (ret.errno != 0)
+		return ret.errno;
+
+	*window = (void *)ret.ret;
+	return 0;
+}
+
+int sys_vm_unmap(void *pointer, size_t size) {
+	__syscall_ret ret = __syscall(34, pointer, size);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+int sys_vm_protect(void *pointer, size_t size, int prot) {
+	__syscall_ret ret = __syscall(48, pointer, size, prot);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+int sys_anon_allocate(size_t size, void **pointer) {
+	return sys_vm_map(NULL, size, PROT_EXEC | PROT_READ | PROT_WRITE,
+					  MAP_ANONYMOUS, -1, 0, pointer);
+}
+
+int sys_anon_free(void *pointer, size_t size) {
+	return sys_vm_unmap(pointer, size);
+}
+
+#ifndef MLIBC_BUILDING_RTLD
+
+pid_t sys_getpid() {
+	__syscall_ret ret = __syscall(31);
+
+	return ret.ret;
+}
+
+pid_t sys_getppid() {
+	__syscall_ret ret = __syscall(32);
+
+	return ret.ret;
+}
+
+uid_t sys_getuid() {
+	mlibc::infoLogger() << "mlibc: " << __func__ << " is a stub!\n" << frg::endlog;
+	return 0;
+}
+
+uid_t sys_geteuid() {
+	mlibc::infoLogger() << "mlibc: " << __func__ << " is a stub!\n" << frg::endlog;
+	return 0;
+}
+
+gid_t sys_getgid() {
+	mlibc::infoLogger() << "mlibc: " << __func__ << " is a stub!\n" << frg::endlog;
+	return 0;
+}
+
+int sys_setgid(gid_t gid) {
+	(void)gid;
+	mlibc::infoLogger() << "mlibc: " << __func__ << " is a stub!\n" << frg::endlog;
+	return 0;
+}
+
+pid_t sys_getpgid(pid_t pid, pid_t *pgid) {
+	(void)pid;
+	mlibc::infoLogger() << "mlibc: " << __func__ << " is a stub!\n" << frg::endlog;
+	*pgid = 0;
+	return 0;
+}
+
+gid_t sys_getegid() {
+	mlibc::infoLogger() << "mlibc: " << __func__ << " is a stub!\n" << frg::endlog;
+	return 0;
+}
+
+int sys_setpgid(pid_t pid, pid_t pgid) {
+	(void)pid; (void)pgid;
+	mlibc::infoLogger() << "mlibc: " << __func__ << " is a stub!\n" << frg::endlog;
+	return 0;
+}
+
+int sys_ttyname(int fd, char *buf, size_t size) {
+	(void)fd; (void)buf; (void)size;
+	mlibc::infoLogger() << "mlibc: " << __func__ << " is a stub!\n" << frg::endlog;
+	return ENOSYS;
+}
+
+int sys_clock_get(int clock, time_t *secs, long *nanos) {
+	struct timespec ts;
+	__syscall_ret ret = __syscall(50, clock, &ts);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	*secs = ts.tv_sec;
+	*nanos = ts.tv_nsec;
+
+	return 0;
+}
+
+int sys_stat(fsfd_target fsfdt, int fd, const char *path, int flags, struct stat *statbuf) {
+	__syscall_ret ret;
+	switch (fsfdt) {
+		case fsfd_target::fd: {
+			ret = __syscall(10, fd, statbuf);
+			break;
+		}
+		case fsfd_target::path: {
+			ret = __syscall(11, AT_FDCWD, path, statbuf, flags);
+			break;
+		}
+		case fsfd_target::fd_path: {
+			ret = __syscall(11, fd, path, statbuf, flags);
+			break;
+		}
+		default: {
+			__ensure(!"stat: Invalid fsfdt");
+			__builtin_unreachable();
+		}
+	}
+	if (ret.errno != 0)
+		return ret.errno;
+	return ret.ret;
+}
+
+int sys_faccessat(int dirfd, const char *pathname, int mode, int flags) {
+	__syscall_ret ret = __syscall(20, dirfd, pathname, mode, flags);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	return 0;
+}
+
+int sys_access(const char *path, int mode) {
+	return sys_faccessat(AT_FDCWD, path, mode, 0);
+}
+
+int sys_pipe(int *fds, int flags) {
+	__syscall_ret ret = __syscall(21, fds, flags);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	return 0;
+}
+
+int sys_chdir(const char *path) {
+	__syscall_ret ret = __syscall(18, path);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	return 0;
+}
+
+int sys_mkdir(const char *path, mode_t mode) {
+	return sys_mkdirat(AT_FDCWD, path, mode);
+}
+
+int sys_mkdirat(int dirfd, const char *path, mode_t mode) {
+	__syscall_ret ret = __syscall(22, dirfd, path, mode);
+
+	return ret.errno;
+}
+
+int sys_socket(int domain, int type_and_flags, int proto, int *fd) {
+	__syscall_ret ret = __syscall(39, domain, type_and_flags, proto);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	*fd = (int)ret.ret;
+	return 0;
+}
+
+int sys_socketpair(int domain, int type_and_flags, int proto, int *fds) {
+	__syscall_ret ret = __syscall(46, domain, type_and_flags, proto, fds);
+
+	return ret.errno;
+}
+
+int sys_bind(int fd, const struct sockaddr *addr_ptr, socklen_t addr_length) {
+	__syscall_ret ret = __syscall(40, fd, addr_ptr, addr_length);
+
+	return ret.errno;
+}
+
+int sys_connect(int fd, const struct sockaddr *addr_ptr, socklen_t addr_length) {
+	__syscall_ret ret = __syscall(59, fd, addr_ptr, addr_length);
+
+	return ret.errno;
+}
+
+int sys_accept(int fd, int *newfd, struct sockaddr *addr_ptr, socklen_t *addr_length, int flags) {
+	__syscall_ret ret = __syscall(61, fd, addr_ptr, addr_length);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	*newfd = ret.ret;
+
+	if(flags & SOCK_NONBLOCK) {
+		int fcntl_ret = 0;
+		fcntl_helper(*newfd, F_GETFL, &fcntl_ret);
+		fcntl_helper(*newfd, F_SETFL, &fcntl_ret, fcntl_ret | O_NONBLOCK);
+	}
+
+	if(flags & SOCK_CLOEXEC) {
+		int fcntl_ret = 0;
+		fcntl_helper(*newfd, F_GETFD, &fcntl_ret);
+		fcntl_helper(*newfd, F_SETFD, &fcntl_ret, fcntl_ret | FD_CLOEXEC);
+	}
+
+	return 0;
+}
+
+int sys_getsockopt(int fd, int layer, int number,
+		void *__restrict buffer, socklen_t *__restrict size) {
+	(void)fd; (void)size;
+	if(layer == SOL_SOCKET && number == SO_PEERCRED) {
+		mlibc::infoLogger() << "\e[31mmlibc: getsockopt() call with SOL_SOCKET and SO_PEERCRED is unimplemented\e[39m" << frg::endlog;
+		*(int *)buffer = 0;
+		return 0;
+	}else if(layer == SOL_SOCKET && number == SO_SNDBUF) {
+		mlibc::infoLogger() << "\e[31mmlibc: getsockopt() call with SOL_SOCKET and SO_SNDBUF is unimplemented\e[39m" << frg::endlog;
+		*(int *)buffer = 4096;
+		return 0;
+	}else if(layer == SOL_SOCKET && number == SO_TYPE) {
+		mlibc::infoLogger() << "\e[31mmlibc: getsockopt() call with SOL_SOCKET and SO_TYPE is unimplemented, hardcoding SOCK_STREAM\e[39m" << frg::endlog;
+		*(int *)buffer = SOCK_STREAM;
+		return 0;
+	}else if(layer == SOL_SOCKET && number == SO_ERROR) {
+		mlibc::infoLogger() << "\e[31mmlibc: getsockopt() call with SOL_SOCKET and SO_ERROR is unimplemented, hardcoding 0\e[39m" << frg::endlog;
+		*(int *)buffer = 0;
+		return 0;
+	}else if(layer == SOL_SOCKET && number == SO_KEEPALIVE) {
+		mlibc::infoLogger() << "\e[31mmlibc: getsockopt() call with SOL_SOCKET and SO_KEEPALIVE is unimplemented, hardcoding 0\e[39m" << frg::endlog;
+		*(int *)buffer = 0;
+		return 0;
+	}else{
+		mlibc::panicLogger() << "\e[31mmlibc: Unexpected getsockopt() call, layer: " << layer << " number: " << number << "\e[39m" << frg::endlog;
+		__builtin_unreachable();
+	}
+
+	return 0;
+}
+
+
+int sys_setsockopt(int fd, int layer, int number,
+		const void *buffer, socklen_t size) {
+	(void)fd; (void)buffer; (void)size;
+	if(layer == SOL_SOCKET && number == SO_PASSCRED) {
+		mlibc::infoLogger() << "\e[31mmlibc: setsockopt(SO_PASSCRED) is not implemented"
+				" correctly\e[39m" << frg::endlog;
+		return 0;
+	}else if(layer == SOL_SOCKET && number == SO_ATTACH_FILTER) {
+		mlibc::infoLogger() << "\e[31mmlibc: setsockopt(SO_ATTACH_FILTER) is not implemented"
+				" correctly\e[39m" << frg::endlog;
+		return 0;
+	}else if(layer == SOL_SOCKET && number == SO_RCVBUFFORCE) {
+		mlibc::infoLogger() << "\e[31mmlibc: setsockopt(SO_RCVBUFFORCE) is not implemented"
+				" correctly\e[39m" << frg::endlog;
+		return 0;
+	}else if(layer == SOL_SOCKET && number == SO_SNDBUF) {
+		mlibc::infoLogger() << "\e[31mmlibc: setsockopt() call with SOL_SOCKET and SO_SNDBUF is unimplemented\e[39m" << frg::endlog;
+		return 0;
+	}else if(layer == SOL_SOCKET && number == SO_KEEPALIVE) {
+		mlibc::infoLogger() << "\e[31mmlibc: setsockopt() call with SOL_SOCKET and SO_KEEPALIVE is unimplemented\e[39m" << frg::endlog;
+		return 0;
+	}else if(layer == SOL_SOCKET && number == SO_REUSEADDR) {
+		mlibc::infoLogger() << "\e[31mmlibc: setsockopt() call with SOL_SOCKET and SO_REUSEADDR is unimplemented\e[39m" << frg::endlog;
+		return 0;
+	}else if(layer == AF_NETLINK && number == SO_ACCEPTCONN) {
+		mlibc::infoLogger() << "\e[31mmlibc: setsockopt() call with AF_NETLINK and SO_ACCEPTCONN is unimplemented\e[39m" << frg::endlog;
+		return 0;
+	}else{
+		mlibc::panicLogger() << "\e[31mmlibc: Unexpected setsockopt() call, layer: " << layer << " number: " << number << "\e[39m" << frg::endlog;
+		__builtin_unreachable();
+	}
+}
+
+int sys_msg_recv(int sockfd, struct msghdr *hdr, int flags, ssize_t *length) {
+	__syscall_ret ret = __syscall(62, sockfd, hdr, flags);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	*length = (ssize_t)ret.ret;
+	return 0;
+}
+
+int sys_peername(int fd, struct sockaddr *addr_ptr, socklen_t max_addr_length, socklen_t *actual_length) {
+	__syscall_ret ret = __syscall(60, fd, addr_ptr, &max_addr_length);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	*actual_length = max_addr_length;
+	return 0;
+}
+
+int sys_listen(int fd, int backlog) {
+	__syscall_ret ret = __syscall(41, fd, backlog);
+
+	return ret.errno;
+}
+
+int sys_inotify_create(int flags, int *fd) {
+	__syscall_ret ret = __syscall(42, flags);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	*fd = (int)ret.ret;
+	return 0;
+}
+
+int sys_fork(pid_t *child) {
+	__syscall_ret ret = __syscall(14);
+
+	if (ret.errno != 0) {
+		return ret.errno;
+	}
+
+	*child = (pid_t)ret.ret;
+	return 0;
+}
+
+int sys_execve(const char *path, char *const argv[], char *const envp[]) {
+	__syscall_ret ret = __syscall(17, path, argv, envp);
+
+	return ret.errno;
+}
+
+int sys_fcntl(int fd, int request, va_list args, int *result) {
+	__syscall_ret ret = __syscall(12, fd, request, va_arg(args, uint64_t));
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	*result = (ssize_t)ret.ret;
+	return 0;
+}
+
+int sys_dup(int fd, int flags, int *newfd) {
+	(void)flags;
+	__syscall_ret ret = __syscall(12, fd, F_DUPFD, 0);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	*newfd = (ssize_t)ret.ret;
+	return 0;
+}
+
+int sys_dup2(int fd, int flags, int newfd) {
+	__syscall_ret ret = __syscall(13, fd, newfd, flags);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+int sys_sigprocmask(int how, const sigset_t *__restrict set, sigset_t *__restrict retrieve) {
+	__syscall_ret ret = __syscall(28, how, set, retrieve);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+int sys_sigaction(int signum, const struct sigaction *act, struct sigaction *oldact) {
+	__syscall_ret ret = __syscall(29, signum, act, oldact);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+int sys_signalfd_create(sigset_t mask, int flags, int *fd) {
+	__syscall_ret ret = __syscall(45, *fd, mask, flags);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	*fd = (int)ret.ret;
+	return 0;
+}
+
+int sys_waitpid(pid_t pid, int *status, int flags, struct rusage *ru, pid_t *ret_pid) {
+	if(ru) {
+		mlibc::infoLogger() << "mlibc: struct rusage in sys_waitpid is unsupported" << frg::endlog;
+		return ENOSYS;
+	}
+
+again:
+	__syscall_ret ret = __syscall(16, pid, status, flags);
+
+	if (ret.errno != 0) {
+		if (ret.errno == EINTR) {
+			goto again;
+		}
+
+		return ret.errno;
+	}
+
+	*ret_pid = (pid_t)ret.ret;
+	return 0;
+}
+
+int sys_getgroups(size_t size, gid_t *list, int *_ret) {
+	__syscall_ret ret = __syscall(38, size, list);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	*_ret = (int)ret.ret;
+	return 0;
+}
+
+int sys_mount(const char *source, const char *target, const char *fstype, unsigned long flags, const void *data) {
+	__syscall_ret ret = __syscall(43, source, target, fstype, flags, data);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+int sys_umount2(const char *target, int flags) {
+	__syscall_ret ret = __syscall(44, target, flags);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+int sys_gethostname(char *buffer, size_t bufsize) {
+	__syscall_ret ret = __syscall(51, buffer, bufsize);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+int sys_sethostname(const char *buffer, size_t bufsize) {
+	__syscall_ret ret = __syscall(52, buffer, bufsize);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	return 0;
+}
+
+int sys_sleep(time_t *secs, long *nanos) {
+	struct timespec req = {
+		.tv_sec = *secs,
+		.tv_nsec = *nanos
+	};
+	struct timespec rem = {0, 0};
+
+	__syscall_ret ret = __syscall(53, &req, &rem);
+
+	if (ret.errno != 0)
+		return ret.errno;
+
+	*secs = rem.tv_sec;
+	*nanos = rem.tv_nsec;
+	return 0;
+}
+
+int sys_getitimer(int, struct itimerval *) {
+	mlibc::infoLogger() << "mlibc: sys_getitimer() is unimplemented" << frg::endlog;
+	return ENOSYS;
+}
+
+int sys_setitimer(int, const struct itimerval *, struct itimerval *) {
+	mlibc::infoLogger() << "mlibc: sys_setitimer() is unimplemented" << frg::endlog;
+	return ENOSYS;
+}
+
+#endif
+
+} // namespace mlibc

user/include/mlibc/sysdeps/vinix/generic/mntent.cpp

@@ -0,0 +1,97 @@
+#include <errno.h>
+#include <mntent.h>
+#include <stdio.h>
+#include <limits.h>
+#include <string.h>
+#include <bits/ensure.h>
+
+namespace {
+
+char *internal_buf;
+size_t internal_bufsize;
+
+}
+
+#define SENTINEL (char *)&internal_buf
+
+FILE *setmntent(const char *name, const char *mode) {
+	return fopen(name, mode);
+}
+
+struct mntent *getmntent(FILE *f) {
+	static struct mntent mnt;
+	return getmntent_r(f, &mnt, SENTINEL, 0);
+}
+
+int addmntent(FILE *f, const struct mntent *mnt) {
+	if(fseek(f, 0, SEEK_END)) {
+		return 1;
+	}
+	return fprintf(f, "%s\t%s\t%s\t%s\t%d\t%d\n",
+		mnt->mnt_fsname, mnt->mnt_dir, mnt->mnt_type, mnt->mnt_opts,
+		mnt->mnt_freq, mnt->mnt_passno) < 0;
+}
+
+int endmntent(FILE *f) {
+	if(f) {
+		fclose(f);
+	}
+	return 1;
+}
+
+char *hasmntopt(const struct mntent *mnt, const char *opt) {
+	return strstr(mnt->mnt_opts, opt);
+}
+
+/* Adapted from musl */
+struct mntent *getmntent_r(FILE *f, struct mntent *mnt, char *linebuf, int buflen) {
+	int n[8];
+	bool use_internal = (linebuf == SENTINEL);
+	int len;
+	size_t i;
+
+	mnt->mnt_freq = 0;
+	mnt->mnt_passno = 0;
+
+	do {
+		if(use_internal) {
+			getline(&internal_buf, &internal_bufsize, f);
+			linebuf = internal_buf;
+		} else {
+			fgets(linebuf, buflen, f);
+		}
+		if(feof(f) || ferror(f)) {
+			return 0;
+		}
+		if(!strchr(linebuf, '\n')) {
+			fscanf(f, "%*[^\n]%*[\n]");
+			errno = ERANGE;
+			return 0;
+		}
+
+		len = strlen(linebuf);
+		if(len > INT_MAX) {
+			continue;
+		}
+
+		for(i = 0; i < sizeof n / sizeof *n; i++) {
+			n[i] = len;
+		}
+
+		sscanf(linebuf, " %n%*s%n %n%*s%n %n%*s%n %n%*s%n %d %d",
+			n, n + 1, n + 2, n + 3, n + 4, n + 5, n + 6, n + 7,
+			&mnt->mnt_freq, &mnt->mnt_passno);
+	} while(linebuf[n[0]] == '#' || n[1] == len);
+
+	linebuf[n[1]] = 0;
+	linebuf[n[3]] = 0;
+	linebuf[n[5]] = 0;
+	linebuf[n[7]] = 0;
+
+	mnt->mnt_fsname = linebuf + n[0];
+	mnt->mnt_dir = linebuf + n[2];
+	mnt->mnt_type = linebuf + n[4];
+	mnt->mnt_opts = linebuf + n[6];
+
+	return mnt;
+}

user/include/mlibc/sysdeps/vinix/generic/mount.cpp

@@ -0,0 +1,16 @@
+#include <errno.h>
+#include <sys/mount.h>
+#include <bits/ensure.h>
+
+int mount(const char *source, const char *target,
+		const char *fstype, unsigned long flags, const void *data) {
+	return 0;
+}
+
+int umount(const char *target) {
+	return umount2(target, 0);
+}
+
+int umount2(const char *target, int flags) {
+	return 0;
+}

user/include/mlibc/sysdeps/vinix/generic/reboot.cpp

@@ -0,0 +1,7 @@
+#include <errno.h>
+#include <sys/reboot.h>
+#include <bits/ensure.h>
+
+int reboot(int what) {
+	return 0;
+}

user/include/mlibc/sysdeps/vinix/generic/syscall.h

@@ -0,0 +1,16 @@
+#include <stdint.h>
+
+struct __syscall_ret {
+	uint64_t ret;
+	uint64_t errno;
+};
+
+__attribute__((naked))
+static __syscall_ret __syscall(int number, ...) {
+	asm (
+		"mov %rcx, %r10\n\t"
+		"syscall\n\t"
+		"ret"
+	);
+	(void)number;
+}

user/include/mlibc/sysdeps/vinix/generic/thread.S

@@ -0,0 +1,9 @@
+.section .text
+.global __mlibc_thread_entry
+__mlibc_thread_entry:
+	pop %rdi
+	pop %rsi
+	pop %rdx
+	call __mlibc_thread_trampoline
+
+.section .note.GNU-stack,"",%progbits

user/include/mlibc/sysdeps/vinix/generic/thread.cpp

@@ -0,0 +1,58 @@
+#include <sys/mman.h>
+#include <mlibc/debug.hpp>
+#include <errno.h>
+#include <mlibc/all-sysdeps.hpp>
+#include <bits/ensure.h>
+#include <mlibc/tcb.hpp>
+
+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<void *>(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;
+	}
+}

user/include/mlibc/sysdeps/vinix/include/abi-bits/access.h

@@ -0,0 +1 @@
+../../../../abis/linux/access.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/auxv.h

@@ -0,0 +1 @@
+../../../../abis/linux/auxv.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/blkcnt_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/blkcnt_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/blksize_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/blksize_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/clockid_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/clockid_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/dev_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/dev_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/errno.h

@@ -0,0 +1 @@
+../../../../abis/linux/errno.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/fcntl.h

@@ -0,0 +1 @@
+../../../../abis/linux/fcntl.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/fsblkcnt_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/fsblkcnt_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/fsfilcnt_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/fsfilcnt_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/gid_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/gid_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/in.h

@@ -0,0 +1 @@
+../../../../abis/linux/in.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/ino_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/ino_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/ioctls.h

@@ -0,0 +1 @@
+../../../../abis/linux/ioctls.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/ipc.h

@@ -0,0 +1 @@
+../../../../abis/linux/ipc.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/limits.h

@@ -0,0 +1 @@
+../../../../abis/linux/limits.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/mode_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/mode_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/mqueue.h

@@ -0,0 +1 @@
+../../../../abis/linux/mqueue.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/msg.h

@@ -0,0 +1 @@
+../../../../abis/linux/msg.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/nlink_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/nlink_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/packet.h

@@ -0,0 +1 @@
+../../../../abis/linux/packet.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/pid_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/pid_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/poll.h

@@ -0,0 +1 @@
+../../../../abis/linux/poll.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/reboot.h

@@ -0,0 +1 @@
+../../../../abis/vinix/reboot.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/resource.h

@@ -0,0 +1 @@
+../../../../abis/linux/resource.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/rlim_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/rlim_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/seek-whence.h

@@ -0,0 +1 @@
+../../../../abis/linux/seek-whence.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/shm.h

@@ -0,0 +1 @@
+../../../../abis/linux/shm.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/sigevent.h

@@ -0,0 +1 @@
+../../../../abis/vinix/sigevent.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/signal.h

@@ -0,0 +1 @@
+../../../../abis/vinix/signal.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/sigval.h

@@ -0,0 +1 @@
+../../../../abis/linux/sigval.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/socket.h

@@ -0,0 +1 @@
+../../../../abis/linux/socket.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/socklen_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/socklen_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/stat.h

@@ -0,0 +1 @@
+../../../../abis/linux/stat.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/statvfs.h

@@ -0,0 +1 @@
+../../../../abis/vinix/statvfs.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/suseconds_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/suseconds_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/termios.h

@@ -0,0 +1 @@
+../../../../abis/linux/termios.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/time.h

@@ -0,0 +1 @@
+../../../../abis/linux/time.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/uid_t.h

@@ -0,0 +1 @@
+../../../../abis/linux/uid_t.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/utmp-defines.h

@@ -0,0 +1 @@
+../../../../abis/vinix/utmp-defines.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/utmpx.h

@@ -0,0 +1 @@
+../../../../abis/vinix/utmpx.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/utsname.h

@@ -0,0 +1 @@
+../../../../abis/linux/utsname.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/vm-flags.h

@@ -0,0 +1 @@
+../../../../abis/linux/vm-flags.h

user/include/mlibc/sysdeps/vinix/include/abi-bits/wait.h

@@ -0,0 +1 @@
+../../../../abis/linux/wait.h

user/include/mlibc/sysdeps/vinix/include/asm/ioctl.h

@@ -0,0 +1,105 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+#ifndef _ASM_GENERIC_IOCTL_H
+#define _ASM_GENERIC_IOCTL_H
+
+/* ioctl command encoding: 32 bits total, command in lower 16 bits,
+ * size of the parameter structure in the lower 14 bits of the
+ * upper 16 bits.
+ * Encoding the size of the parameter structure in the ioctl request
+ * is useful for catching programs compiled with old versions
+ * and to avoid overwriting user space outside the user buffer area.
+ * The highest 2 bits are reserved for indicating the ``access mode''.
+ * NOTE: This limits the max parameter size to 16kB -1 !
+ */
+
+/*
+ * The following is for compatibility across the various Linux
+ * platforms.  The generic ioctl numbering scheme doesn't really enforce
+ * a type field.  De facto, however, the top 8 bits of the lower 16
+ * bits are indeed used as a type field, so we might just as well make
+ * this explicit here.  Please be sure to use the decoding macros
+ * below from now on.
+ */
+#define _IOC_NRBITS	8
+#define _IOC_TYPEBITS	8
+
+/*
+ * Let any architecture override either of the following before
+ * including this file.
+ */
+
+#ifndef _IOC_SIZEBITS
+# define _IOC_SIZEBITS	14
+#endif
+
+#ifndef _IOC_DIRBITS
+# define _IOC_DIRBITS	2
+#endif
+
+#define _IOC_NRMASK	((1 << _IOC_NRBITS)-1)
+#define _IOC_TYPEMASK	((1 << _IOC_TYPEBITS)-1)
+#define _IOC_SIZEMASK	((1 << _IOC_SIZEBITS)-1)
+#define _IOC_DIRMASK	((1 << _IOC_DIRBITS)-1)
+
+#define _IOC_NRSHIFT	0
+#define _IOC_TYPESHIFT	(_IOC_NRSHIFT+_IOC_NRBITS)
+#define _IOC_SIZESHIFT	(_IOC_TYPESHIFT+_IOC_TYPEBITS)
+#define _IOC_DIRSHIFT	(_IOC_SIZESHIFT+_IOC_SIZEBITS)
+
+/*
+ * Direction bits, which any architecture can choose to override
+ * before including this file.
+ *
+ * NOTE: _IOC_WRITE means userland is writing and kernel is
+ * reading. _IOC_READ means userland is reading and kernel is writing.
+ */
+
+#ifndef _IOC_NONE
+# define _IOC_NONE	0U
+#endif
+
+#ifndef _IOC_WRITE
+# define _IOC_WRITE	1U
+#endif
+
+#ifndef _IOC_READ
+# define _IOC_READ	2U
+#endif
+
+#define _IOC(dir,type,nr,size) \
+	(((dir)  << _IOC_DIRSHIFT) | \
+	 ((type) << _IOC_TYPESHIFT) | \
+	 ((nr)   << _IOC_NRSHIFT) | \
+	 ((size) << _IOC_SIZESHIFT))
+
+#define _IOC_TYPECHECK(t) (sizeof(t))
+
+/*
+ * Used to create numbers.
+ *
+ * NOTE: _IOW means userland is writing and kernel is reading. _IOR
+ * means userland is reading and kernel is writing.
+ */
+#define _IO(type,nr)		_IOC(_IOC_NONE,(type),(nr),0)
+#define _IOR(type,nr,size)	_IOC(_IOC_READ,(type),(nr),(_IOC_TYPECHECK(size)))
+#define _IOW(type,nr,size)	_IOC(_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
+#define _IOWR(type,nr,size)	_IOC(_IOC_READ|_IOC_WRITE,(type),(nr),(_IOC_TYPECHECK(size)))
+#define _IOR_BAD(type,nr,size)	_IOC(_IOC_READ,(type),(nr),sizeof(size))
+#define _IOW_BAD(type,nr,size)	_IOC(_IOC_WRITE,(type),(nr),sizeof(size))
+#define _IOWR_BAD(type,nr,size)	_IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
+
+/* used to decode ioctl numbers.. */
+#define _IOC_DIR(nr)		(((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK)
+#define _IOC_TYPE(nr)		(((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
+#define _IOC_NR(nr)		(((nr) >> _IOC_NRSHIFT) & _IOC_NRMASK)
+#define _IOC_SIZE(nr)		(((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)
+
+/* ...and for the drivers/sound files... */
+
+#define IOC_IN		(_IOC_WRITE << _IOC_DIRSHIFT)
+#define IOC_OUT		(_IOC_READ << _IOC_DIRSHIFT)
+#define IOC_INOUT	((_IOC_WRITE|_IOC_READ) << _IOC_DIRSHIFT)
+#define IOCSIZE_MASK	(_IOC_SIZEMASK << _IOC_SIZESHIFT)
+#define IOCSIZE_SHIFT	(_IOC_SIZESHIFT)
+
+#endif /* _ASM_GENERIC_IOCTL_H */

user/include/mlibc/sysdeps/vinix/include/asm/ioctls.h

@@ -0,0 +1,121 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+#ifndef __ASM_GENERIC_IOCTLS_H
+#define __ASM_GENERIC_IOCTLS_H
+
+#include <asm/ioctl.h>
+
+/*
+ * These are the most common definitions for tty ioctl numbers.
+ * Most of them do not use the recommended _IOC(), but there is
+ * probably some source code out there hardcoding the number,
+ * so we might as well use them for all new platforms.
+ *
+ * The architectures that use different values here typically
+ * try to be compatible with some Unix variants for the same
+ * architecture.
+ */
+
+/* 0x54 is just a magic number to make these relatively unique ('T') */
+
+#define TCGETS		0x5401
+#define TCSETS		0x5402
+#define TCSETSW		0x5403
+#define TCSETSF		0x5404
+#define TCGETA		0x5405
+#define TCSETA		0x5406
+#define TCSETAW		0x5407
+#define TCSETAF		0x5408
+#define TCSBRK		0x5409
+#define TCXONC		0x540A
+#define TCFLSH		0x540B
+#define TIOCEXCL	0x540C
+#define TIOCNXCL	0x540D
+#define TIOCSCTTY	0x540E
+#define TIOCGPGRP	0x540F
+#define TIOCSPGRP	0x5410
+#define TIOCOUTQ	0x5411
+#define TIOCSTI		0x5412
+#define TIOCGWINSZ	0x5413
+#define TIOCSWINSZ	0x5414
+#define TIOCMGET	0x5415
+#define TIOCMBIS	0x5416
+#define TIOCMBIC	0x5417
+#define TIOCMSET	0x5418
+#define TIOCGSOFTCAR	0x5419
+#define TIOCSSOFTCAR	0x541A
+#define FIONREAD	0x541B
+#define TIOCINQ		FIONREAD
+#define TIOCLINUX	0x541C
+#define TIOCCONS	0x541D
+#define TIOCGSERIAL	0x541E
+#define TIOCSSERIAL	0x541F
+#define TIOCPKT		0x5420
+#define FIONBIO		0x5421
+#define TIOCNOTTY	0x5422
+#define TIOCSETD	0x5423
+#define TIOCGETD	0x5424
+#define TCSBRKP		0x5425	/* Needed for POSIX tcsendbreak() */
+#define TIOCSBRK	0x5427  /* BSD compatibility */
+#define TIOCCBRK	0x5428  /* BSD compatibility */
+#define TIOCGSID	0x5429  /* Return the session ID of FD */
+#define TCGETS2		_IOR('T', 0x2A, struct termios2)
+#define TCSETS2		_IOW('T', 0x2B, struct termios2)
+#define TCSETSW2	_IOW('T', 0x2C, struct termios2)
+#define TCSETSF2	_IOW('T', 0x2D, struct termios2)
+#define TIOCGRS485	0x542E
+#ifndef TIOCSRS485
+#define TIOCSRS485	0x542F
+#endif
+#define TIOCGPTN	_IOR('T', 0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
+#define TIOCSPTLCK	_IOW('T', 0x31, int)  /* Lock/unlock Pty */
+#define TIOCGDEV	_IOR('T', 0x32, unsigned int) /* Get primary device node of /dev/console */
+#define TCGETX		0x5432 /* SYS5 TCGETX compatibility */
+#define TCSETX		0x5433
+#define TCSETXF		0x5434
+#define TCSETXW		0x5435
+#define TIOCSIG		_IOW('T', 0x36, int)  /* pty: generate signal */
+#define TIOCVHANGUP	0x5437
+#define TIOCGPKT	_IOR('T', 0x38, int) /* Get packet mode state */
+#define TIOCGPTLCK	_IOR('T', 0x39, int) /* Get Pty lock state */
+#define TIOCGEXCL	_IOR('T', 0x40, int) /* Get exclusive mode state */
+#define TIOCGPTPEER	_IO('T', 0x41) /* Safely open the slave */
+#define TIOCGISO7816	_IOR('T', 0x42, struct serial_iso7816)
+#define TIOCSISO7816	_IOWR('T', 0x43, struct serial_iso7816)
+
+#define FIONCLEX	0x5450
+#define FIOCLEX		0x5451
+#define FIOASYNC	0x5452
+#define TIOCSERCONFIG	0x5453
+#define TIOCSERGWILD	0x5454
+#define TIOCSERSWILD	0x5455
+#define TIOCGLCKTRMIOS	0x5456
+#define TIOCSLCKTRMIOS	0x5457
+#define TIOCSERGSTRUCT	0x5458 /* For debugging only */
+#define TIOCSERGETLSR   0x5459 /* Get line status register */
+#define TIOCSERGETMULTI 0x545A /* Get multiport config  */
+#define TIOCSERSETMULTI 0x545B /* Set multiport config */
+
+#define TIOCMIWAIT	0x545C	/* wait for a change on serial input line(s) */
+#define TIOCGICOUNT	0x545D	/* read serial port __inline__ interrupt counts */
+
+/*
+ * Some arches already define FIOQSIZE due to a historical
+ * conflict with a Hayes modem-specific ioctl value.
+ */
+#ifndef FIOQSIZE
+# define FIOQSIZE	0x5460
+#endif
+
+/* Used for packet mode */
+#define TIOCPKT_DATA		 0
+#define TIOCPKT_FLUSHREAD	 1
+#define TIOCPKT_FLUSHWRITE	 2
+#define TIOCPKT_STOP		 4
+#define TIOCPKT_START		 8
+#define TIOCPKT_NOSTOP		16
+#define TIOCPKT_DOSTOP		32
+#define TIOCPKT_IOCTL		64
+
+#define TIOCSER_TEMT	0x01	/* Transmitter physically empty */
+
+#endif /* __ASM_GENERIC_IOCTLS_H */

user/include/mlibc/sysdeps/vinix/include/linux/fb.h

@@ -0,0 +1,400 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+#ifndef _LINUX_FB_H
+#define _LINUX_FB_H
+
+#include <stddef.h>
+#include <asm/ioctl.h>
+
+/* Definitions of frame buffers						*/
+
+#define FB_MAX			32	/* sufficient for now */
+
+/* ioctls
+   0x46 is 'F'								*/
+#define FBIOGET_VSCREENINFO	0x4600
+#define FBIOPUT_VSCREENINFO	0x4601
+#define FBIOGET_FSCREENINFO	0x4602
+#define FBIOGETCMAP		0x4604
+#define FBIOPUTCMAP		0x4605
+#define FBIOPAN_DISPLAY		0x4606
+#define FBIO_CURSOR            _IOWR('F', 0x08, struct fb_cursor)
+/* 0x4607-0x460B are defined below */
+/* #define FBIOGET_MONITORSPEC	0x460C */
+/* #define FBIOPUT_MONITORSPEC	0x460D */
+/* #define FBIOSWITCH_MONIBIT	0x460E */
+#define FBIOGET_CON2FBMAP	0x460F
+#define FBIOPUT_CON2FBMAP	0x4610
+#define FBIOBLANK		0x4611		/* arg: 0 or vesa level + 1 */
+#define FBIOGET_VBLANK		_IOR('F', 0x12, struct fb_vblank)
+#define FBIO_ALLOC              0x4613
+#define FBIO_FREE               0x4614
+#define FBIOGET_GLYPH           0x4615
+#define FBIOGET_HWCINFO         0x4616
+#define FBIOPUT_MODEINFO        0x4617
+#define FBIOGET_DISPINFO        0x4618
+#define FBIO_WAITFORVSYNC	_IOW('F', 0x20, uint32_t)
+
+#define FB_TYPE_PACKED_PIXELS		0	/* Packed Pixels	*/
+#define FB_TYPE_PLANES			1	/* Non interleaved planes */
+#define FB_TYPE_INTERLEAVED_PLANES	2	/* Interleaved planes	*/
+#define FB_TYPE_TEXT			3	/* Text/attributes	*/
+#define FB_TYPE_VGA_PLANES		4	/* EGA/VGA planes	*/
+#define FB_TYPE_FOURCC			5	/* Type identified by a V4L2 FOURCC */
+
+#define FB_AUX_TEXT_MDA		0	/* Monochrome text */
+#define FB_AUX_TEXT_CGA		1	/* CGA/EGA/VGA Color text */
+#define FB_AUX_TEXT_S3_MMIO	2	/* S3 MMIO fasttext */
+#define FB_AUX_TEXT_MGA_STEP16	3	/* MGA Millenium I: text, attr, 14 reserved bytes */
+#define FB_AUX_TEXT_MGA_STEP8	4	/* other MGAs:      text, attr,  6 reserved bytes */
+#define FB_AUX_TEXT_SVGA_GROUP	8	/* 8-15: SVGA tileblit compatible modes */
+#define FB_AUX_TEXT_SVGA_MASK	7	/* lower three bits says step */
+#define FB_AUX_TEXT_SVGA_STEP2	8	/* SVGA text mode:  text, attr */
+#define FB_AUX_TEXT_SVGA_STEP4	9	/* SVGA text mode:  text, attr,  2 reserved bytes */
+#define FB_AUX_TEXT_SVGA_STEP8	10	/* SVGA text mode:  text, attr,  6 reserved bytes */
+#define FB_AUX_TEXT_SVGA_STEP16	11	/* SVGA text mode:  text, attr, 14 reserved bytes */
+#define FB_AUX_TEXT_SVGA_LAST	15	/* reserved up to 15 */
+
+#define FB_AUX_VGA_PLANES_VGA4		0	/* 16 color planes (EGA/VGA) */
+#define FB_AUX_VGA_PLANES_CFB4		1	/* CFB4 in planes (VGA) */
+#define FB_AUX_VGA_PLANES_CFB8		2	/* CFB8 in planes (VGA) */
+
+#define FB_VISUAL_MONO01		0	/* Monochr. 1=Black 0=White */
+#define FB_VISUAL_MONO10		1	/* Monochr. 1=White 0=Black */
+#define FB_VISUAL_TRUECOLOR		2	/* True color	*/
+#define FB_VISUAL_PSEUDOCOLOR		3	/* Pseudo color (like atari) */
+#define FB_VISUAL_DIRECTCOLOR		4	/* Direct color */
+#define FB_VISUAL_STATIC_PSEUDOCOLOR	5	/* Pseudo color readonly */
+#define FB_VISUAL_FOURCC		6	/* Visual identified by a V4L2 FOURCC */
+
+#define FB_ACCEL_NONE		0	/* no hardware accelerator	*/
+#define FB_ACCEL_ATARIBLITT	1	/* Atari Blitter		*/
+#define FB_ACCEL_AMIGABLITT	2	/* Amiga Blitter                */
+#define FB_ACCEL_S3_TRIO64	3	/* Cybervision64 (S3 Trio64)    */
+#define FB_ACCEL_NCR_77C32BLT	4	/* RetinaZ3 (NCR 77C32BLT)      */
+#define FB_ACCEL_S3_VIRGE	5	/* Cybervision64/3D (S3 ViRGE)	*/
+#define FB_ACCEL_ATI_MACH64GX	6	/* ATI Mach 64GX family		*/
+#define FB_ACCEL_DEC_TGA	7	/* DEC 21030 TGA		*/
+#define FB_ACCEL_ATI_MACH64CT	8	/* ATI Mach 64CT family		*/
+#define FB_ACCEL_ATI_MACH64VT	9	/* ATI Mach 64CT family VT class */
+#define FB_ACCEL_ATI_MACH64GT	10	/* ATI Mach 64CT family GT class */
+#define FB_ACCEL_SUN_CREATOR	11	/* Sun Creator/Creator3D	*/
+#define FB_ACCEL_SUN_CGSIX	12	/* Sun cg6			*/
+#define FB_ACCEL_SUN_LEO	13	/* Sun leo/zx			*/
+#define FB_ACCEL_IMS_TWINTURBO	14	/* IMS Twin Turbo		*/
+#define FB_ACCEL_3DLABS_PERMEDIA2 15	/* 3Dlabs Permedia 2		*/
+#define FB_ACCEL_MATROX_MGA2064W 16	/* Matrox MGA2064W (Millenium)	*/
+#define FB_ACCEL_MATROX_MGA1064SG 17	/* Matrox MGA1064SG (Mystique)	*/
+#define FB_ACCEL_MATROX_MGA2164W 18	/* Matrox MGA2164W (Millenium II) */
+#define FB_ACCEL_MATROX_MGA2164W_AGP 19	/* Matrox MGA2164W (Millenium II) */
+#define FB_ACCEL_MATROX_MGAG100	20	/* Matrox G100 (Productiva G100) */
+#define FB_ACCEL_MATROX_MGAG200	21	/* Matrox G200 (Myst, Mill, ...) */
+#define FB_ACCEL_SUN_CG14	22	/* Sun cgfourteen		 */
+#define FB_ACCEL_SUN_BWTWO	23	/* Sun bwtwo			*/
+#define FB_ACCEL_SUN_CGTHREE	24	/* Sun cgthree			*/
+#define FB_ACCEL_SUN_TCX	25	/* Sun tcx			*/
+#define FB_ACCEL_MATROX_MGAG400	26	/* Matrox G400			*/
+#define FB_ACCEL_NV3		27	/* nVidia RIVA 128              */
+#define FB_ACCEL_NV4		28	/* nVidia RIVA TNT		*/
+#define FB_ACCEL_NV5		29	/* nVidia RIVA TNT2		*/
+#define FB_ACCEL_CT_6555x	30	/* C&T 6555x			*/
+#define FB_ACCEL_3DFX_BANSHEE	31	/* 3Dfx Banshee			*/
+#define FB_ACCEL_ATI_RAGE128	32	/* ATI Rage128 family		*/
+#define FB_ACCEL_IGS_CYBER2000	33	/* CyberPro 2000		*/
+#define FB_ACCEL_IGS_CYBER2010	34	/* CyberPro 2010		*/
+#define FB_ACCEL_IGS_CYBER5000	35	/* CyberPro 5000		*/
+#define FB_ACCEL_SIS_GLAMOUR    36	/* SiS 300/630/540              */
+#define FB_ACCEL_3DLABS_PERMEDIA3 37	/* 3Dlabs Permedia 3		*/
+#define FB_ACCEL_ATI_RADEON	38	/* ATI Radeon family		*/
+#define FB_ACCEL_I810           39      /* Intel 810/815                */
+#define FB_ACCEL_SIS_GLAMOUR_2  40	/* SiS 315, 650, 740		*/
+#define FB_ACCEL_SIS_XABRE      41	/* SiS 330 ("Xabre")		*/
+#define FB_ACCEL_I830           42      /* Intel 830M/845G/85x/865G     */
+#define FB_ACCEL_NV_10          43      /* nVidia Arch 10               */
+#define FB_ACCEL_NV_20          44      /* nVidia Arch 20               */
+#define FB_ACCEL_NV_30          45      /* nVidia Arch 30               */
+#define FB_ACCEL_NV_40          46      /* nVidia Arch 40               */
+#define FB_ACCEL_XGI_VOLARI_V	47	/* XGI Volari V3XT, V5, V8      */
+#define FB_ACCEL_XGI_VOLARI_Z	48	/* XGI Volari Z7                */
+#define FB_ACCEL_OMAP1610	49	/* TI OMAP16xx                  */
+#define FB_ACCEL_TRIDENT_TGUI	50	/* Trident TGUI			*/
+#define FB_ACCEL_TRIDENT_3DIMAGE 51	/* Trident 3DImage		*/
+#define FB_ACCEL_TRIDENT_BLADE3D 52	/* Trident Blade3D		*/
+#define FB_ACCEL_TRIDENT_BLADEXP 53	/* Trident BladeXP		*/
+#define FB_ACCEL_CIRRUS_ALPINE   53	/* Cirrus Logic 543x/544x/5480	*/
+#define FB_ACCEL_NEOMAGIC_NM2070 90	/* NeoMagic NM2070              */
+#define FB_ACCEL_NEOMAGIC_NM2090 91	/* NeoMagic NM2090              */
+#define FB_ACCEL_NEOMAGIC_NM2093 92	/* NeoMagic NM2093              */
+#define FB_ACCEL_NEOMAGIC_NM2097 93	/* NeoMagic NM2097              */
+#define FB_ACCEL_NEOMAGIC_NM2160 94	/* NeoMagic NM2160              */
+#define FB_ACCEL_NEOMAGIC_NM2200 95	/* NeoMagic NM2200              */
+#define FB_ACCEL_NEOMAGIC_NM2230 96	/* NeoMagic NM2230              */
+#define FB_ACCEL_NEOMAGIC_NM2360 97	/* NeoMagic NM2360              */
+#define FB_ACCEL_NEOMAGIC_NM2380 98	/* NeoMagic NM2380              */
+#define FB_ACCEL_PXA3XX		 99	/* PXA3xx			*/
+
+#define FB_ACCEL_SAVAGE4        0x80	/* S3 Savage4                   */
+#define FB_ACCEL_SAVAGE3D       0x81	/* S3 Savage3D                  */
+#define FB_ACCEL_SAVAGE3D_MV    0x82	/* S3 Savage3D-MV               */
+#define FB_ACCEL_SAVAGE2000     0x83	/* S3 Savage2000                */
+#define FB_ACCEL_SAVAGE_MX_MV   0x84	/* S3 Savage/MX-MV              */
+#define FB_ACCEL_SAVAGE_MX      0x85	/* S3 Savage/MX                 */
+#define FB_ACCEL_SAVAGE_IX_MV   0x86	/* S3 Savage/IX-MV              */
+#define FB_ACCEL_SAVAGE_IX      0x87	/* S3 Savage/IX                 */
+#define FB_ACCEL_PROSAVAGE_PM   0x88	/* S3 ProSavage PM133           */
+#define FB_ACCEL_PROSAVAGE_KM   0x89	/* S3 ProSavage KM133           */
+#define FB_ACCEL_S3TWISTER_P    0x8a	/* S3 Twister                   */
+#define FB_ACCEL_S3TWISTER_K    0x8b	/* S3 TwisterK                  */
+#define FB_ACCEL_SUPERSAVAGE    0x8c    /* S3 Supersavage               */
+#define FB_ACCEL_PROSAVAGE_DDR  0x8d	/* S3 ProSavage DDR             */
+#define FB_ACCEL_PROSAVAGE_DDRK 0x8e	/* S3 ProSavage DDR-K           */
+
+#define FB_ACCEL_PUV3_UNIGFX	0xa0	/* PKUnity-v3 Unigfx		*/
+
+#define FB_CAP_FOURCC		1	/* Device supports FOURCC-based formats */
+
+struct fb_fix_screeninfo {
+	char id[16];			/* identification string eg "TT Builtin" */
+	unsigned long smem_start;	/* Start of frame buffer mem */
+					/* (physical address) */
+	uint32_t smem_len;			/* Length of frame buffer mem */
+	uint32_t type;			/* see FB_TYPE_*		*/
+	uint32_t type_aux;			/* Interleave for interleaved Planes */
+	uint32_t visual;			/* see FB_VISUAL_*		*/ 
+	uint16_t xpanstep;			/* zero if no hardware panning  */
+	uint16_t ypanstep;			/* zero if no hardware panning  */
+	uint16_t ywrapstep;		/* zero if no hardware ywrap    */
+	uint32_t line_length;		/* length of a line in bytes    */
+	unsigned long mmio_start;	/* Start of Memory Mapped I/O   */
+					/* (physical address) */
+	uint32_t mmio_len;			/* Length of Memory Mapped I/O  */
+	uint32_t accel;			/* Indicate to driver which	*/
+					/*  specific chip/card we have	*/
+	uint16_t capabilities;		/* see FB_CAP_*			*/
+	uint16_t reserved[2];		/* Reserved for future compatibility */
+};
+
+/* Interpretation of offset for color fields: All offsets are from the right,
+ * inside a "pixel" value, which is exactly 'bits_per_pixel' wide (means: you
+ * can use the offset as right argument to <<). A pixel afterwards is a bit
+ * stream and is written to video memory as that unmodified.
+ *
+ * For pseudocolor: offset and length should be the same for all color
+ * components. Offset specifies the position of the least significant bit
+ * of the palette index in a pixel value. Length indicates the number
+ * of available palette entries (i.e. # of entries = 1 << length).
+ */
+struct fb_bitfield {
+	uint32_t offset;			/* beginning of bitfield	*/
+	uint32_t length;			/* length of bitfield		*/
+	uint32_t msb_right;		/* != 0 : Most significant bit is */ 
+					/* right */ 
+};
+
+#define FB_NONSTD_HAM		1	/* Hold-And-Modify (HAM)        */
+#define FB_NONSTD_REV_PIX_IN_B	2	/* order of pixels in each byte is reversed */
+
+#define FB_ACTIVATE_NOW		0	/* set values immediately (or vbl)*/
+#define FB_ACTIVATE_NXTOPEN	1	/* activate on next open	*/
+#define FB_ACTIVATE_TEST	2	/* don't set, round up impossible */
+#define FB_ACTIVATE_MASK       15
+					/* values			*/
+#define FB_ACTIVATE_VBL	       16	/* activate values on next vbl  */
+#define FB_CHANGE_CMAP_VBL     32	/* change colormap on vbl	*/
+#define FB_ACTIVATE_ALL	       64	/* change all VCs on this fb	*/
+#define FB_ACTIVATE_FORCE     128	/* force apply even when no change*/
+#define FB_ACTIVATE_INV_MODE  256       /* invalidate videomode */
+#define FB_ACTIVATE_KD_TEXT   512       /* for KDSET vt ioctl */
+
+#define FB_ACCELF_TEXT		1	/* (OBSOLETE) see fb_info.flags and vc_mode */
+
+#define FB_SYNC_HOR_HIGH_ACT	1	/* horizontal sync high active	*/
+#define FB_SYNC_VERT_HIGH_ACT	2	/* vertical sync high active	*/
+#define FB_SYNC_EXT		4	/* external sync		*/
+#define FB_SYNC_COMP_HIGH_ACT	8	/* composite sync high active   */
+#define FB_SYNC_BROADCAST	16	/* broadcast video timings      */
+					/* vtotal = 144d/288n/576i => PAL  */
+					/* vtotal = 121d/242n/484i => NTSC */
+#define FB_SYNC_ON_GREEN	32	/* sync on green */
+
+#define FB_VMODE_NONINTERLACED  0	/* non interlaced */
+#define FB_VMODE_INTERLACED	1	/* interlaced	*/
+#define FB_VMODE_DOUBLE		2	/* double scan */
+#define FB_VMODE_ODD_FLD_FIRST	4	/* interlaced: top line first */
+#define FB_VMODE_MASK		255
+
+#define FB_VMODE_YWRAP		256	/* ywrap instead of panning     */
+#define FB_VMODE_SMOOTH_XPAN	512	/* smooth xpan possible (internally used) */
+#define FB_VMODE_CONUPDATE	512	/* don't update x/yoffset	*/
+
+/*
+ * Display rotation support
+ */
+#define FB_ROTATE_UR      0
+#define FB_ROTATE_CW      1
+#define FB_ROTATE_UD      2
+#define FB_ROTATE_CCW     3
+
+#define PICOS2KHZ(a) (1000000000UL/(a))
+#define KHZ2PICOS(a) (1000000000UL/(a))
+
+struct fb_var_screeninfo {
+	uint32_t xres;			/* visible resolution		*/
+	uint32_t yres;
+	uint32_t xres_virtual;		/* virtual resolution		*/
+	uint32_t yres_virtual;
+	uint32_t xoffset;			/* offset from virtual to visible */
+	uint32_t yoffset;			/* resolution			*/
+
+	uint32_t bits_per_pixel;		/* guess what			*/
+	uint32_t grayscale;		/* 0 = color, 1 = grayscale,	*/
+					/* >1 = FOURCC			*/
+	struct fb_bitfield red;		/* bitfield in fb mem if true color, */
+	struct fb_bitfield green;	/* else only length is significant */
+	struct fb_bitfield blue;
+	struct fb_bitfield transp;	/* transparency			*/	
+
+	uint32_t nonstd;			/* != 0 Non standard pixel format */
+
+	uint32_t activate;			/* see FB_ACTIVATE_*		*/
+
+	uint32_t height;			/* height of picture in mm    */
+	uint32_t width;			/* width of picture in mm     */
+
+	uint32_t accel_flags;		/* (OBSOLETE) see fb_info.flags */
+
+	/* Timing: All values in pixclocks, except pixclock (of course) */
+	uint32_t pixclock;			/* pixel clock in ps (pico seconds) */
+	uint32_t left_margin;		/* time from sync to picture	*/
+	uint32_t right_margin;		/* time from picture to sync	*/
+	uint32_t upper_margin;		/* time from sync to picture	*/
+	uint32_t lower_margin;
+	uint32_t hsync_len;		/* length of horizontal sync	*/
+	uint32_t vsync_len;		/* length of vertical sync	*/
+	uint32_t sync;			/* see FB_SYNC_*		*/
+	uint32_t vmode;			/* see FB_VMODE_*		*/
+	uint32_t rotate;			/* angle we rotate counter clockwise */
+	uint32_t colorspace;		/* colorspace for FOURCC-based modes */
+	uint32_t reserved[4];		/* Reserved for future compatibility */
+};
+
+struct fb_cmap {
+	uint32_t start;			/* First entry	*/
+	uint32_t len;			/* Number of entries */
+	uint16_t *red;			/* Red values	*/
+	uint16_t *green;
+	uint16_t *blue;
+	uint16_t *transp;			/* transparency, can be NULL */
+};
+
+struct fb_con2fbmap {
+	uint32_t console;
+	uint32_t framebuffer;
+};
+
+/* VESA Blanking Levels */
+#define VESA_NO_BLANKING        0
+#define VESA_VSYNC_SUSPEND      1
+#define VESA_HSYNC_SUSPEND      2
+#define VESA_POWERDOWN          3
+
+
+enum {
+	/* screen: unblanked, hsync: on,  vsync: on */
+	FB_BLANK_UNBLANK       = VESA_NO_BLANKING,
+
+	/* screen: blanked,   hsync: on,  vsync: on */
+	FB_BLANK_NORMAL        = VESA_NO_BLANKING + 1,
+
+	/* screen: blanked,   hsync: on,  vsync: off */
+	FB_BLANK_VSYNC_SUSPEND = VESA_VSYNC_SUSPEND + 1,
+
+	/* screen: blanked,   hsync: off, vsync: on */
+	FB_BLANK_HSYNC_SUSPEND = VESA_HSYNC_SUSPEND + 1,
+
+	/* screen: blanked,   hsync: off, vsync: off */
+	FB_BLANK_POWERDOWN     = VESA_POWERDOWN + 1
+};
+
+#define FB_VBLANK_VBLANKING	0x001	/* currently in a vertical blank */
+#define FB_VBLANK_HBLANKING	0x002	/* currently in a horizontal blank */
+#define FB_VBLANK_HAVE_VBLANK	0x004	/* vertical blanks can be detected */
+#define FB_VBLANK_HAVE_HBLANK	0x008	/* horizontal blanks can be detected */
+#define FB_VBLANK_HAVE_COUNT	0x010	/* global retrace counter is available */
+#define FB_VBLANK_HAVE_VCOUNT	0x020	/* the vcount field is valid */
+#define FB_VBLANK_HAVE_HCOUNT	0x040	/* the hcount field is valid */
+#define FB_VBLANK_VSYNCING	0x080	/* currently in a vsync */
+#define FB_VBLANK_HAVE_VSYNC	0x100	/* verical syncs can be detected */
+
+struct fb_vblank {
+	uint32_t flags;			/* FB_VBLANK flags */
+	uint32_t count;			/* counter of retraces since boot */
+	uint32_t vcount;			/* current scanline position */
+	uint32_t hcount;			/* current scandot position */
+	uint32_t reserved[4];		/* reserved for future compatibility */
+};
+
+/* Internal HW accel */
+#define ROP_COPY 0
+#define ROP_XOR  1
+
+struct fb_copyarea {
+	uint32_t dx;
+	uint32_t dy;
+	uint32_t width;
+	uint32_t height;
+	uint32_t sx;
+	uint32_t sy;
+};
+
+struct fb_fillrect {
+	uint32_t dx;	/* screen-relative */
+	uint32_t dy;
+	uint32_t width;
+	uint32_t height;
+	uint32_t color;
+	uint32_t rop;
+};
+
+struct fb_image {
+	uint32_t dx;		/* Where to place image */
+	uint32_t dy;
+	uint32_t width;		/* Size of image */
+	uint32_t height;
+	uint32_t fg_color;		/* Only used when a mono bitmap */
+	uint32_t bg_color;
+	uint8_t  depth;		/* Depth of the image */
+	const char *data;	/* Pointer to image data */
+	struct fb_cmap cmap;	/* color map info */
+};
+
+/*
+ * hardware cursor control
+ */
+
+#define FB_CUR_SETIMAGE 0x01
+#define FB_CUR_SETPOS   0x02
+#define FB_CUR_SETHOT   0x04
+#define FB_CUR_SETCMAP  0x08
+#define FB_CUR_SETSHAPE 0x10
+#define FB_CUR_SETSIZE	0x20
+#define FB_CUR_SETALL   0xFF
+
+struct fbcurpos {
+	uint16_t x, y;
+};
+
+struct fb_cursor {
+	uint16_t set;		/* what to set */
+	uint16_t enable;		/* cursor on/off */
+	uint16_t rop;		/* bitop operation */
+	const char *mask;	/* cursor mask bits */
+	struct fbcurpos hot;	/* cursor hot spot */
+	struct fb_image	image;	/* Cursor image */
+};
+
+/* Settings for the generic backlight code */
+#define FB_BACKLIGHT_LEVELS	128
+#define FB_BACKLIGHT_MAX	0xFF
+
+
+#endif /* _LINUX_FB_H */

user/include/mlibc/sysdeps/vinix/include/mntent.h

@@ -0,0 +1,50 @@
+#ifndef _MNTENT_H
+#define _MNTENT_H
+
+#include <stdio.h>
+
+/* TODO: Refer to _PATH_MOUNTED */
+#define MOUNTED "/etc/mtab"
+
+/* Generic mount options */
+#define MNTOPT_DEFAULTS "defaults"		/* Use all default options. */
+#define MNTOPT_RO       "ro"			/* Read only. */
+#define MNTOPT_RW       "rw"			/* Read/write. */
+#define MNTOPT_SUID     "suid"			/* Set uid allowed. */
+#define MNTOPT_NOSUID   "nosuid"		/* No set uid allowed. */
+#define MNTOPT_NOAUTO   "noauto"		/* Do not auto mount. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct mntent {
+	char *mnt_fsname;
+	char *mnt_dir;
+	char *mnt_type;
+	char *mnt_opts;
+	int mnt_freq;
+	int mnt_passno;
+};
+
+#ifndef __MLIBC_ABI_ONLY
+
+FILE *setmntent(const char *, const char *);
+
+struct mntent *getmntent(FILE *);
+
+int addmntent(FILE *, const struct mntent *);
+
+int endmntent(FILE *);
+
+char *hasmntopt(const struct mntent *, const char *);
+
+struct mntent *getmntent_r(FILE *, struct mntent *,  char *, int);
+
+#endif /* !__MLIBC_ABI_ONLY */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MNTENT_H */

user/include/mlibc/sysdeps/vinix/include/sys/mount.h

@@ -0,0 +1,54 @@
+#ifndef _SYS_MOUNT_H
+#define _SYS_MOUNT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MS_RDONLY 1
+#define MS_NOSUID 2
+#define MS_NODEV 4
+#define MS_NOEXEC 8
+#define MS_SYNCHRONOUS 16
+#define MS_REMOUNT 32
+#define MS_MANDLOCK 64
+#define MS_DIRSYNC 128
+#define MS_NOSYMFOLLOW 256
+#define MS_NOATIME 1024
+#define MS_NODIRATIME 2048
+#define MS_BIND 4096
+#define MS_MOVE 8192
+#define MS_REC 16384
+#define MS_SILENT 32768
+#define MS_POSIXACL (1 << 16)
+#define MS_UNBINDABLE (1 << 17)
+#define MS_PRIVATE (1 << 18)
+#define MS_SLAVE (1 << 19)
+#define MS_SHARED (1 << 20)
+#define MS_RELATIME (1 << 21)
+#define MS_KERNMOUNT (1 << 22)
+#define MS_I_VERSION (1 << 23)
+#define MS_STRICTATIME (1 << 24)
+#define MS_LAZYTIME (1 << 25)
+#define MS_NOREMOTELOCK (1 << 27)
+#define MS_NOSEC (1 << 28)
+#define MS_BORN (1 << 29)
+#define MS_ACTIVE (1 << 30)
+#define MS_NOUSER (1 << 31)
+
+#define MNT_FORCE 1
+
+#ifndef __MLIBC_ABI_ONLY
+
+int mount(const char *source, const char *target,
+		const char *fstype, unsigned long flags, const void *data);
+int umount(const char *target);
+int umount2(const char *target, int flags);
+
+#endif /* !__MLIBC_ABI_ONLY */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SYS_MOUNT_H */

user/include/mlibc/sysdeps/vinix/include/sys/reboot.h

@@ -0,0 +1,20 @@
+#ifndef MLIBC_SYS_REBOOT_H
+#define MLIBC_SYS_REBOOT_H
+
+#include <abi-bits/reboot.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef __MLIBC_ABI_ONLY
+
+int reboot(int arg);
+
+#endif /* !__MLIBC_ABI_ONLY */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MLIBC_SYS_REBOOT_H */

user/include/mlibc/sysdeps/vinix/include/sys/sysmacros.h

@@ -0,0 +1,33 @@
+#ifndef _SYS_SYSMACROS_H
+#define _SYS_SYSMACROS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static unsigned int __mlibc_dev_major(
+		unsigned long long int __dev) {
+  return ((__dev >> 8) & 0xfff) | ((unsigned int)(__dev >> 32) & ~0xfff);
+}
+
+static unsigned int __mlibc_dev_minor(
+		unsigned long long int __dev) {
+  return (__dev & 0xff) | ((unsigned int)(__dev >> 12) & ~0xff);
+}
+
+static unsigned long long int __mlibc_dev_makedev(
+		unsigned int __major, unsigned int __minor) {
+  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
+	  | (((unsigned long long int)(__minor & ~0xff)) << 12)
+	  | (((unsigned long long int)(__major & ~0xfff)) << 32));
+}
+
+#define major(dev) __mlibc_dev_major(dev)
+#define minor(dev) __mlibc_dev_minor(dev)
+#define makedev(major, minor) __mlibc_dev_makedev(major, minor)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SYS_SYSMACROS_H */

user/include/mlibc/sysdeps/vinix/meson.build

@@ -0,0 +1,123 @@
+sysdep_supported_options = {
+	'posix': true,
+	'linux': false,
+	'glibc': true,
+	'bsd': true,
+}
+
+rtld_sources += files(
+	'generic/generic.cpp'
+)
+
+libc_sources += files(
+	'generic/entry.cpp',
+	'generic/generic.cpp',
+	'generic/mntent.cpp',
+	'generic/mount.cpp',
+	'generic/reboot.cpp',
+	'generic/thread.cpp',
+	'generic/thread.S',
+)
+
+if not no_headers
+	install_headers(
+		'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/reboot.h',
+		'include/abi-bits/resource.h',
+		'include/abi-bits/stat.h',
+		'include/abi-bits/signal.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/access.h',
+		'include/abi-bits/wait.h',
+		'include/abi-bits/limits.h',
+		'include/abi-bits/utsname.h',
+		'include/abi-bits/poll.h',
+		'include/abi-bits/packet.h',
+		'include/abi-bits/clockid_t.h',
+		'include/abi-bits/ipc.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/statvfs.h',
+		'include/abi-bits/ioctls.h',
+		'include/abi-bits/msg.h',
+		'include/abi-bits/rlim_t.h',
+		'include/abi-bits/sigval.h',
+		'include/abi-bits/sigevent.h',
+		'include/abi-bits/utmpx.h',
+		'include/abi-bits/utmp-defines.h',
+		subdir: 'abi-bits',
+		follow_symlinks: true
+	)
+
+	install_headers(
+		'include/asm/ioctl.h',
+		'include/asm/ioctls.h',
+		subdir: 'asm',
+	)
+
+	install_headers(
+		'include/linux/fb.h',
+		subdir: 'linux',
+	)
+
+	install_headers(
+		'include/sys/reboot.h',
+		'include/sys/mount.h',
+		'include/sys/sysmacros.h',
+		subdir: 'sys',
+	)
+
+	install_headers(
+		'include/mntent.h',
+	)
+endif
+
+if not headers_only
+	crt = custom_target('crt0',
+		build_by_default: true,
+		command: c_compiler.cmd_array() + ['-c', '-o', '@OUTPUT@', '@INPUT@'],
+		input: host_machine.cpu_family() / 'crt-src/crt0.S',
+		output: 'crt0.o',
+		install: true,
+		install_dir: get_option('libdir')
+	)
+
+	custom_target('crti',
+		build_by_default: true,
+		command: c_compiler.cmd_array() + ['-c', '-o', '@OUTPUT@', '@INPUT@'],
+		input: host_machine.cpu_family() / 'crt-src/crti.S',
+		output: 'crti.o',
+		install: true,
+		install_dir: get_option('libdir')
+	)
+
+	custom_target('crtn',
+		build_by_default: true,
+		command: c_compiler.cmd_array() + ['-c', '-o', '@OUTPUT@', '@INPUT@'],
+		input: host_machine.cpu_family() / 'crt-src/crtn.S',
+		output: 'crtn.o',
+		install: true,
+		install_dir: get_option('libdir')
+	)
+endif
+

user/include/mlibc/sysdeps/vinix/x86_64/crt-src/crt0.S

@@ -0,0 +1,8 @@
+.section .text
+.global _start
+_start:
+	mov %rsp, %rdi
+	lea main(%rip), %rsi
+	call __mlibc_entry
+.section .note.GNU-stack,"",%progbits
+

user/include/mlibc/sysdeps/vinix/x86_64/crt-src/crti.S

@@ -0,0 +1,11 @@
+.section .init
+.global _init
+_init:
+	push %rax
+
+.section .fini
+.global _fini
+_fini:
+	push %rax
+.section .note.GNU-stack,"",%progbits
+

user/include/mlibc/sysdeps/vinix/x86_64/crt-src/crtn.S

@@ -0,0 +1,9 @@
+.section .init
+	pop %rax
+	ret
+
+.section .fini
+	pop %rax
+	ret
+.section .note.GNU-stack,"",%progbits
+