Fennix/Kernel
1
0
Fork 0
mirror of https://github.com/Fennix-Project/Kernel.git synced 2025-08-25 21:15:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update kernel

Browse Source
This commit is contained in:
Alex
2023-08-06 04:53:14 +03:00
parent 3b65386399
commit 2c51e4432f
181 changed files with 21873 additions and 21475 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2458
SystemCalls/Linux.cpp
View File

File diff suppressed because it is too large Load Diff

857
SystemCalls/Linux/Linux.cpp Normal file
View File

@@ -0,0 +1,857 @@
/*
This file is part of Fennix Kernel.
Fennix Kernel is free software: you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
Fennix Kernel is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
*/
#include <syscalls.hpp>
#include <debug.h>
#include <cpu.hpp>
#include <errno.h>
#include "../../kernel.h"
#include "linux_syscalls.hpp"
struct SyscallData
{
const char *Name;
void *Handler;
};
using InterProcessCommunication::IPC;
using InterProcessCommunication::IPCID;
using Tasking::TaskStatus::Ready;
using Tasking::TaskStatus::Terminated;
#define ARCH_SET_GS 0x1001
#define ARCH_SET_FS 0x1002
#define ARCH_GET_FS 0x1003
#define ARCH_GET_GS 0x1004
#define PROT_NONE 0
#define PROT_READ 1
#define PROT_WRITE 2
#define PROT_EXEC 4
#define PROT_GROWSDOWN 0x01000000
#define PROT_GROWSUP 0x02000000
#define MAP_FAILED ((void *)-1)
#define MAP_FILE 0
#define MAP_SHARED 0x01
#define MAP_PRIVATE 0x02
#define MAP_SHARED_VALIDATE 0x03
#define MAP_TYPE 0x0f
#define MAP_FIXED 0x10
#define MAP_ANON 0x20
#define MAP_ANONYMOUS MAP_ANON
#define MAP_NORESERVE 0x4000
#define MAP_GROWSDOWN 0x0100
#define MAP_DENYWRITE 0x0800
#define MAP_EXECUTABLE 0x1000
#define MAP_LOCKED 0x2000
#define MAP_POPULATE 0x8000
#define MAP_NONBLOCK 0x10000
#define MAP_STACK 0x20000
#define MAP_HUGETLB 0x40000
#define MAP_SYNC 0x80000
#define MAP_FIXED_NOREPLACE 0x100000
typedef int pid_t;
struct iovec
{
void *iov_base;
size_t iov_len;
};
#if defined(a64) || defined(aa64)
static ssize_t ConvertErrno(ssize_t r)
{
if (r >= 0)
return r;
return -errno;
}
#endif
static int ConvertErrno(int r)
{
if (r >= 0)
return r;
return -errno;
}
/* https://man7.org/linux/man-pages/man2/read.2.html */
static ssize_t sys_read(int fd, void *buf, size_t count)
{
Tasking::PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_read(fd, buf, count));
}
/* https://man7.org/linux/man-pages/man2/write.2.html */
static ssize_t sys_write(int fd, const void *buf, size_t count)
{
Tasking::PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_write(fd, buf, count));
}
/* https://man7.org/linux/man-pages/man2/open.2.html */
static int sys_open(const char *pathname, int flags, mode_t mode)
{
Tasking::PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_open(pathname, flags, mode));
}
/* https://man7.org/linux/man-pages/man2/close.2.html */
static int sys_close(int fd)
{
Tasking::PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_close(fd));
}
/* https://man7.org/linux/man-pages/man3/stat.3p.html */
static int sys_stat(const char *pathname, struct stat *statbuf)
{
Tasking::PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_stat(pathname, statbuf));
}
/* https://man7.org/linux/man-pages/man3/fstat.3p.html */
static int sys_fstat(int fd, struct stat *statbuf)
{
#undef fstat
Tasking::PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_fstat(fd, statbuf));
}
/* https://man7.org/linux/man-pages/man2/lstat.2.html */
static int sys_lstat(const char *pathname, struct stat *statbuf)
{
#undef lstat
Tasking::PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_lstat(pathname, statbuf));
}
/* https://man7.org/linux/man-pages/man2/lseek.2.html */
static off_t sys_lseek(int fd, off_t offset, int whence)
{
Tasking::PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_lseek(fd, offset, whence));
}
/* https://man7.org/linux/man-pages/man3/mmap.3p.html */
static void *sys_mmap(void *addr, size_t length, int prot,
int flags, int fildes, off_t offset)
{
UNUSED(offset); /* FIXME */
Tasking::PCB *pcb = thisProcess;
Memory::MemMgr *mgr = pcb->Memory;
if (!addr)
{
void *newPages = mgr->RequestPages(TO_PAGES(length));
if (newPages == nullptr)
return MAP_FAILED;
Memory::Virtual vma = Memory::Virtual(pcb->PageTable);
if (prot & PROT_READ)
vma.Map(newPages, newPages, length, Memory::P | Memory::US, Memory::Virtual::FourKiB);
if (prot & PROT_WRITE)
vma.Map(newPages, newPages, length, Memory::RW, Memory::Virtual::FourKiB);
if (prot & PROT_EXEC)
fixme("PROT_EXEC not implemented");
if (flags & MAP_FILE)
fixme("MAP_FILE not implemented");
if (flags & MAP_SHARED)
fixme("MAP_SHARED not implemented");
if (flags & MAP_PRIVATE)
fixme("MAP_PRIVATE not implemented");
if (flags & MAP_SHARED_VALIDATE)
fixme("MAP_SHARED_VALIDATE not implemented");
if (flags & MAP_TYPE)
fixme("MAP_TYPE not implemented");
if (flags & MAP_FIXED)
fixme("MAP_FIXED not implemented");
if (flags & MAP_ANONYMOUS)
fixme("MAP_ANONYMOUS not implemented");
if (fildes != -1)
{
fixme("File mapping not implemented");
return MAP_FAILED;
}
return newPages;
}
stub;
return MAP_FAILED;
}
/* https://man7.org/linux/man-pages/man3/mprotect.3p.html */
static int sys_mprotect(void *addr, size_t len, int prot)
{
Tasking::PCB *pcb = thisProcess;
Memory::Virtual vma = Memory::Virtual(pcb->PageTable);
vma.Map(addr, addr, len, Memory::P, Memory::Virtual::FourKiB);
if (prot & PROT_READ)
vma.Map(addr, addr, len, Memory::P | Memory::US, Memory::Virtual::FourKiB);
if (prot & PROT_WRITE)
vma.Map(addr, addr, len, Memory::RW, Memory::Virtual::FourKiB);
if (prot & PROT_EXEC)
fixme("PROT_EXEC not implemented");
return 0;
}
/* https://man7.org/linux/man-pages/man2/brk.2.html */
static void *sys_brk(intptr_t increment)
{
Tasking::PCB *pcb = thisProcess;
Memory::MemMgr *mgr = pcb->Memory;
stub;
size_t PagesToAllocate = increment ? TO_PAGES(increment) : 1;
return (void *)mgr->RequestPages(PagesToAllocate, true);
}
/* https://man7.org/linux/man-pages/man2/ioctl.2.html */
static int sys_ioctl(int fd, unsigned long request, void *argp)
{
UNUSED(fd);
UNUSED(request);
UNUSED(argp);
return -ENOSYS;
}
/* https://man7.org/linux/man-pages/man3/readv.3p.html */
static ssize_t sys_readv(int fildes, const struct iovec *iov, int iovcnt)
{
ssize_t Total = 0;
for (int i = 0; i < iovcnt; i++)
{
ssize_t n = sys_read(fildes, iov[i].iov_base, iov[i].iov_len);
if (n < 0)
return n;
Total += n;
if (n < (ssize_t)iov[i].iov_len)
break;
}
return Total;
}
/* https://man7.org/linux/man-pages/man3/writev.3p.html */
static ssize_t sys_writev(int fildes, const struct iovec *iov, int iovcnt)
{
ssize_t Total = 0;
for (int i = 0; i < iovcnt; i++)
{
ssize_t n = sys_write(fildes, iov[i].iov_base, iov[i].iov_len);
if (n < 0)
return n;
Total += n;
if (n < (ssize_t)iov[i].iov_len)
break;
}
return Total;
}
/* https://man7.org/linux/man-pages/man3/exit.3.html */
static __noreturn void sys_exit(int status)
{
trace("Userspace thread %s(%d) exited with code %d (%#x)",
thisThread->Name,
thisThread->ID, status,
status < 0 ? -status : status);
thisThread->ExitCode = status;
thisThread->Status = Terminated;
TaskManager->Yield();
__builtin_unreachable();
}
/* https://man7.org/linux/man-pages/man3/creat.3p.html */
static int sys_creat(const char *pathname, mode_t mode)
{
Tasking::PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_creat(pathname, mode));
}
/* https://man7.org/linux/man-pages/man2/arch_prctl.2.html */
static int sys_arch_prctl(int code, unsigned long addr)
{
switch (code)
{
case 0x1001: // ARCH_SET_GS
{
#if defined(a64)
CPU::x64::wrmsr(CPU::x64::MSRID::MSR_GS_BASE, addr);
#elif defined(a32)
CPU::x32::wrmsr(CPU::x32::MSRID::MSR_GS_BASE, addr);
#endif
return 0;
}
case 0x1002: // ARCH_SET_FS
{
#if defined(a64)
CPU::x64::wrmsr(CPU::x64::MSRID::MSR_FS_BASE, addr);
#elif defined(a32)
CPU::x32::wrmsr(CPU::x32::MSRID::MSR_FS_BASE, addr);
#endif
return 0;
}
case 0x1003: // ARCH_GET_FS
{
#if defined(a64)
*r_cst(uint64_t *, addr) =
CPU::x64::rdmsr(CPU::x64::MSRID::MSR_FS_BASE);
#elif defined(a32)
*r_cst(uint64_t *, addr) =
CPU::x32::rdmsr(CPU::x32::MSRID::MSR_FS_BASE);
#endif
return 0;
}
case 0x1004: // ARCH_GET_GS
{
#if defined(a64)
*r_cst(uint64_t *, addr) =
CPU::x64::rdmsr(CPU::x64::MSRID::MSR_GS_BASE);
#elif defined(a32)
*r_cst(uint64_t *, addr) =
CPU::x32::rdmsr(CPU::x32::MSRID::MSR_GS_BASE);
#endif
return 0;
}
default:
fixme("code=%d", code);
return -ENOSYS;
}
}
/* https://man7.org/linux/man-pages/man2/set_tid_address.2.html */
static pid_t sys_set_tid_address(int *tidptr)
{
Tasking::TCB *tcb = thisThread;
*tidptr = tcb->ID;
return tcb->ID;
}
/* https://man7.org/linux/man-pages/man2/exit_group.2.html */
static __noreturn void sys_exit_group(int status)
{
fixme("status=%d", status);
sys_exit(status);
}
static SyscallData LinuxSyscallsTable[] = {
[__NR_read] = {"read", (void *)sys_read},
[__NR_write] = {"write", (void *)sys_write},
[__NR_open] = {"open", (void *)sys_open},
[__NR_close] = {"close", (void *)sys_close},
[__NR_stat] = {"stat", (void *)sys_stat},
[__NR_fstat] = {"fstat", (void *)sys_fstat},
[__NR_lstat] = {"lstat", (void *)sys_lstat},
[__NR_poll] = {"poll", (void *)nullptr},
[__NR_lseek] = {"lseek", (void *)sys_lseek},
[__NR_mmap] = {"mmap", (void *)sys_mmap},
[__NR_mprotect] = {"mprotect", (void *)sys_mprotect},
[__NR_munmap] = {"munmap", (void *)nullptr},
[__NR_brk] = {"brk", (void *)sys_brk},
[__NR_rt_sigaction] = {"rt_sigaction", (void *)nullptr},
[__NR_rt_sigprocmask] = {"rt_sigprocmask", (void *)nullptr},
[__NR_rt_sigreturn] = {"rt_sigreturn", (void *)nullptr},
[__NR_ioctl] = {"ioctl", (void *)sys_ioctl},
[__NR_pread64] = {"pread64", (void *)nullptr},
[__NR_pwrite64] = {"pwrite64", (void *)nullptr},
[__NR_readv] = {"readv", (void *)sys_readv},
[__NR_writev] = {"writev", (void *)sys_writev},
[__NR_access] = {"access", (void *)nullptr},
[__NR_pipe] = {"pipe", (void *)nullptr},
[__NR_select] = {"select", (void *)nullptr},
[__NR_sched_yield] = {"sched_yield", (void *)nullptr},
[__NR_mremap] = {"mremap", (void *)nullptr},
[__NR_msync] = {"msync", (void *)nullptr},
[__NR_mincore] = {"mincore", (void *)nullptr},
[__NR_madvise] = {"madvise", (void *)nullptr},
[__NR_shmget] = {"shmget", (void *)nullptr},
[__NR_shmat] = {"shmat", (void *)nullptr},
[__NR_shmctl] = {"shmctl", (void *)nullptr},
[__NR_dup] = {"dup", (void *)nullptr},
[__NR_dup2] = {"dup2", (void *)nullptr},
[__NR_pause] = {"pause", (void *)nullptr},
[__NR_nanosleep] = {"nanosleep", (void *)nullptr},
[__NR_getitimer] = {"getitimer", (void *)nullptr},
[__NR_alarm] = {"alarm", (void *)nullptr},
[__NR_setitimer] = {"setitimer", (void *)nullptr},
[__NR_getpid] = {"getpid", (void *)nullptr},
[__NR_sendfile] = {"sendfile", (void *)nullptr},
[__NR_socket] = {"socket", (void *)nullptr},
[__NR_connect] = {"connect", (void *)nullptr},
[__NR_accept] = {"accept", (void *)nullptr},
[__NR_sendto] = {"sendto", (void *)nullptr},
[__NR_recvfrom] = {"recvfrom", (void *)nullptr},
[__NR_sendmsg] = {"sendmsg", (void *)nullptr},
[__NR_recvmsg] = {"recvmsg", (void *)nullptr},
[__NR_shutdown] = {"shutdown", (void *)nullptr},
[__NR_bind] = {"bind", (void *)nullptr},
[__NR_listen] = {"listen", (void *)nullptr},
[__NR_getsockname] = {"getsockname", (void *)nullptr},
[__NR_getpeername] = {"getpeername", (void *)nullptr},
[__NR_socketpair] = {"socketpair", (void *)nullptr},
[__NR_setsockopt] = {"setsockopt", (void *)nullptr},
[__NR_getsockopt] = {"getsockopt", (void *)nullptr},
[__NR_clone] = {"clone", (void *)nullptr},
[__NR_fork] = {"fork", (void *)nullptr},
[__NR_vfork] = {"vfork", (void *)nullptr},
[__NR_execve] = {"execve", (void *)nullptr},
[__NR_exit] = {"exit", (void *)sys_exit},
[__NR_wait4] = {"wait4", (void *)nullptr},
[__NR_kill] = {"kill", (void *)nullptr},
[__NR_uname] = {"uname", (void *)nullptr},
[__NR_semget] = {"semget", (void *)nullptr},
[__NR_semop] = {"semop", (void *)nullptr},
[__NR_semctl] = {"semctl", (void *)nullptr},
[__NR_shmdt] = {"shmdt", (void *)nullptr},
[__NR_msgget] = {"msgget", (void *)nullptr},
[__NR_msgsnd] = {"msgsnd", (void *)nullptr},
[__NR_msgrcv] = {"msgrcv", (void *)nullptr},
[__NR_msgctl] = {"msgctl", (void *)nullptr},
[__NR_fcntl] = {"fcntl", (void *)nullptr},
[__NR_flock] = {"flock", (void *)nullptr},
[__NR_fsync] = {"fsync", (void *)nullptr},
[__NR_fdatasync] = {"fdatasync", (void *)nullptr},
[__NR_truncate] = {"truncate", (void *)nullptr},
[__NR_ftruncate] = {"ftruncate", (void *)nullptr},
[__NR_getdents] = {"getdents", (void *)nullptr},
[__NR_getcwd] = {"getcwd", (void *)nullptr},
[__NR_chdir] = {"chdir", (void *)nullptr},
[__NR_fchdir] = {"fchdir", (void *)nullptr},
[__NR_rename] = {"rename", (void *)nullptr},
[__NR_mkdir] = {"mkdir", (void *)nullptr},
[__NR_rmdir] = {"rmdir", (void *)nullptr},
[__NR_creat] = {"creat", (void *)sys_creat},
[__NR_link] = {"link", (void *)nullptr},
[__NR_unlink] = {"unlink", (void *)nullptr},
[__NR_symlink] = {"symlink", (void *)nullptr},
[__NR_readlink] = {"readlink", (void *)nullptr},
[__NR_chmod] = {"chmod", (void *)nullptr},
[__NR_fchmod] = {"fchmod", (void *)nullptr},
[__NR_chown] = {"chown", (void *)nullptr},
[__NR_fchown] = {"fchown", (void *)nullptr},
[__NR_lchown] = {"lchown", (void *)nullptr},
[__NR_umask] = {"umask", (void *)nullptr},
[__NR_gettimeofday] = {"gettimeofday", (void *)nullptr},
[__NR_getrlimit] = {"getrlimit", (void *)nullptr},
[__NR_getrusage] = {"getrusage", (void *)nullptr},
[__NR_sysinfo] = {"sysinfo", (void *)nullptr},
[__NR_times] = {"times", (void *)nullptr},
[__NR_ptrace] = {"ptrace", (void *)nullptr},
[__NR_getuid] = {"getuid", (void *)nullptr},
[__NR_syslog] = {"syslog", (void *)nullptr},
[__NR_getgid] = {"getgid", (void *)nullptr},
[__NR_setuid] = {"setuid", (void *)nullptr},
[__NR_setgid] = {"setgid", (void *)nullptr},
[__NR_geteuid] = {"geteuid", (void *)nullptr},
[__NR_getegid] = {"getegid", (void *)nullptr},
[__NR_setpgid] = {"setpgid", (void *)nullptr},
[__NR_getppid] = {"getppid", (void *)nullptr},
[__NR_getpgrp] = {"getpgrp", (void *)nullptr},
[__NR_setsid] = {"setsid", (void *)nullptr},
[__NR_setreuid] = {"setreuid", (void *)nullptr},
[__NR_setregid] = {"setregid", (void *)nullptr},
[__NR_getgroups] = {"getgroups", (void *)nullptr},
[__NR_setgroups] = {"setgroups", (void *)nullptr},
[__NR_setresuid] = {"setresuid", (void *)nullptr},
[__NR_getresuid] = {"getresuid", (void *)nullptr},
[__NR_setresgid] = {"setresgid", (void *)nullptr},
[__NR_getresgid] = {"getresgid", (void *)nullptr},
[__NR_getpgid] = {"getpgid", (void *)nullptr},
[__NR_setfsuid] = {"setfsuid", (void *)nullptr},
[__NR_setfsgid] = {"setfsgid", (void *)nullptr},
[__NR_getsid] = {"getsid", (void *)nullptr},
[__NR_capget] = {"capget", (void *)nullptr},
[__NR_capset] = {"capset", (void *)nullptr},
[__NR_rt_sigpending] = {"rt_sigpending", (void *)nullptr},
[__NR_rt_sigtimedwait] = {"rt_sigtimedwait", (void *)nullptr},
[__NR_rt_sigqueueinfo] = {"rt_sigqueueinfo", (void *)nullptr},
[__NR_rt_sigsuspend] = {"rt_sigsuspend", (void *)nullptr},
[__NR_sigaltstack] = {"sigaltstack", (void *)nullptr},
[__NR_utime] = {"utime", (void *)nullptr},
[__NR_mknod] = {"mknod", (void *)nullptr},
[__NR_uselib] = {"uselib", (void *)nullptr},
[__NR_personality] = {"personality", (void *)nullptr},
[__NR_ustat] = {"ustat", (void *)nullptr},
[__NR_statfs] = {"statfs", (void *)nullptr},
[__NR_fstatfs] = {"fstatfs", (void *)nullptr},
[__NR_sysfs] = {"sysfs", (void *)nullptr},
[__NR_getpriority] = {"getpriority", (void *)nullptr},
[__NR_setpriority] = {"setpriority", (void *)nullptr},
[__NR_sched_setparam] = {"sched_setparam", (void *)nullptr},
[__NR_sched_getparam] = {"sched_getparam", (void *)nullptr},
[__NR_sched_setscheduler] = {"sched_setscheduler", (void *)nullptr},
[__NR_sched_getscheduler] = {"sched_getscheduler", (void *)nullptr},
[__NR_sched_get_priority_max] = {"sched_get_priority_max", (void *)nullptr},
[__NR_sched_get_priority_min] = {"sched_get_priority_min", (void *)nullptr},
[__NR_sched_rr_get_interval] = {"sched_rr_get_interval", (void *)nullptr},
[__NR_mlock] = {"mlock", (void *)nullptr},
[__NR_munlock] = {"munlock", (void *)nullptr},
[__NR_mlockall] = {"mlockall", (void *)nullptr},
[__NR_munlockall] = {"munlockall", (void *)nullptr},
[__NR_vhangup] = {"vhangup", (void *)nullptr},
[__NR_modify_ldt] = {"modify_ldt", (void *)nullptr},
[__NR_pivot_root] = {"pivot_root", (void *)nullptr},
[__NR__sysctl] = {"_sysctl", (void *)nullptr},
[__NR_prctl] = {"prctl", (void *)nullptr},
[__NR_arch_prctl] = {"arch_prctl", (void *)sys_arch_prctl},
[__NR_adjtimex] = {"adjtimex", (void *)nullptr},
[__NR_setrlimit] = {"setrlimit", (void *)nullptr},
[__NR_chroot] = {"chroot", (void *)nullptr},
[__NR_sync] = {"sync", (void *)nullptr},
[__NR_acct] = {"acct", (void *)nullptr},
[__NR_settimeofday] = {"settimeofday", (void *)nullptr},
[__NR_mount] = {"mount", (void *)nullptr},
[__NR_umount2] = {"umount2", (void *)nullptr},
[__NR_swapon] = {"swapon", (void *)nullptr},
[__NR_swapoff] = {"swapoff", (void *)nullptr},
[__NR_reboot] = {"reboot", (void *)nullptr},
[__NR_sethostname] = {"sethostname", (void *)nullptr},
[__NR_setdomainname] = {"setdomainname", (void *)nullptr},
[__NR_iopl] = {"iopl", (void *)nullptr},
[__NR_ioperm] = {"ioperm", (void *)nullptr},
[__NR_create_module] = {"create_module", (void *)nullptr},
[__NR_init_module] = {"init_module", (void *)nullptr},
[__NR_delete_module] = {"delete_module", (void *)nullptr},
[__NR_get_kernel_syms] = {"get_kernel_syms", (void *)nullptr},
[__NR_query_module] = {"query_module", (void *)nullptr},
[__NR_quotactl] = {"quotactl", (void *)nullptr},
[__NR_nfsservctl] = {"nfsservctl", (void *)nullptr},
[__NR_getpmsg] = {"getpmsg", (void *)nullptr},
[__NR_putpmsg] = {"putpmsg", (void *)nullptr},
[__NR_afs_syscall] = {"afs_syscall", (void *)nullptr},
[__NR_tuxcall] = {"tuxcall", (void *)nullptr},
[__NR_security] = {"security", (void *)nullptr},
[__NR_gettid] = {"gettid", (void *)nullptr},
[__NR_readahead] = {"readahead", (void *)nullptr},
[__NR_setxattr] = {"setxattr", (void *)nullptr},
[__NR_lsetxattr] = {"lsetxattr", (void *)nullptr},
[__NR_fsetxattr] = {"fsetxattr", (void *)nullptr},
[__NR_getxattr] = {"getxattr", (void *)nullptr},
[__NR_lgetxattr] = {"lgetxattr", (void *)nullptr},
[__NR_fgetxattr] = {"fgetxattr", (void *)nullptr},
[__NR_listxattr] = {"listxattr", (void *)nullptr},
[__NR_llistxattr] = {"llistxattr", (void *)nullptr},
[__NR_flistxattr] = {"flistxattr", (void *)nullptr},
[__NR_removexattr] = {"removexattr", (void *)nullptr},
[__NR_lremovexattr] = {"lremovexattr", (void *)nullptr},
[__NR_fremovexattr] = {"fremovexattr", (void *)nullptr},
[__NR_tkill] = {"tkill", (void *)nullptr},
[__NR_time] = {"time", (void *)nullptr},
[__NR_futex] = {"futex", (void *)nullptr},
[__NR_sched_setaffinity] = {"sched_setaffinity", (void *)nullptr},
[__NR_sched_getaffinity] = {"sched_getaffinity", (void *)nullptr},
[__NR_set_thread_area] = {"set_thread_area", (void *)nullptr},
[__NR_io_setup] = {"io_setup", (void *)nullptr},
[__NR_io_destroy] = {"io_destroy", (void *)nullptr},
[__NR_io_getevents] = {"io_getevents", (void *)nullptr},
[__NR_io_submit] = {"io_submit", (void *)nullptr},
[__NR_io_cancel] = {"io_cancel", (void *)nullptr},
[__NR_get_thread_area] = {"get_thread_area", (void *)nullptr},
[__NR_lookup_dcookie] = {"lookup_dcookie", (void *)nullptr},
[__NR_epoll_create] = {"epoll_create", (void *)nullptr},
[__NR_epoll_ctl_old] = {"epoll_ctl_old", (void *)nullptr},
[__NR_epoll_wait_old] = {"epoll_wait_old", (void *)nullptr},
[__NR_remap_file_pages] = {"remap_file_pages", (void *)nullptr},
[__NR_getdents64] = {"getdents64", (void *)nullptr},
[__NR_set_tid_address] = {"set_tid_address", (void *)sys_set_tid_address},
[__NR_restart_syscall] = {"restart_syscall", (void *)nullptr},
[__NR_semtimedop] = {"semtimedop", (void *)nullptr},
[__NR_fadvise64] = {"fadvise64", (void *)nullptr},
[__NR_timer_create] = {"timer_create", (void *)nullptr},
[__NR_timer_settime] = {"timer_settime", (void *)nullptr},
[__NR_timer_gettime] = {"timer_gettime", (void *)nullptr},
[__NR_timer_getoverrun] = {"timer_getoverrun", (void *)nullptr},
[__NR_timer_delete] = {"timer_delete", (void *)nullptr},
[__NR_clock_settime] = {"clock_settime", (void *)nullptr},
[__NR_clock_gettime] = {"clock_gettime", (void *)nullptr},
[__NR_clock_getres] = {"clock_getres", (void *)nullptr},
[__NR_clock_nanosleep] = {"clock_nanosleep", (void *)nullptr},
[__NR_exit_group] = {"exit_group", (void *)sys_exit_group},
[__NR_epoll_wait] = {"epoll_wait", (void *)nullptr},
[__NR_epoll_ctl] = {"epoll_ctl", (void *)nullptr},
[__NR_tgkill] = {"tgkill", (void *)nullptr},
[__NR_utimes] = {"utimes", (void *)nullptr},
[__NR_vserver] = {"vserver", (void *)nullptr},
[__NR_mbind] = {"mbind", (void *)nullptr},
[__NR_set_mempolicy] = {"set_mempolicy", (void *)nullptr},
[__NR_get_mempolicy] = {"get_mempolicy", (void *)nullptr},
[__NR_mq_open] = {"mq_open", (void *)nullptr},
[__NR_mq_unlink] = {"mq_unlink", (void *)nullptr},
[__NR_mq_timedsend] = {"mq_timedsend", (void *)nullptr},
[__NR_mq_timedreceive] = {"mq_timedreceive", (void *)nullptr},
[__NR_mq_notify] = {"mq_notify", (void *)nullptr},
[__NR_mq_getsetattr] = {"mq_getsetattr", (void *)nullptr},
[__NR_kexec_load] = {"kexec_load", (void *)nullptr},
[__NR_waitid] = {"waitid", (void *)nullptr},
[__NR_add_key] = {"add_key", (void *)nullptr},
[__NR_request_key] = {"request_key", (void *)nullptr},
[__NR_keyctl] = {"keyctl", (void *)nullptr},
[__NR_ioprio_set] = {"ioprio_set", (void *)nullptr},
[__NR_ioprio_get] = {"ioprio_get", (void *)nullptr},
[__NR_inotify_init] = {"inotify_init", (void *)nullptr},
[__NR_inotify_add_watch] = {"inotify_add_watch", (void *)nullptr},
[__NR_inotify_rm_watch] = {"inotify_rm_watch", (void *)nullptr},
[__NR_migrate_pages] = {"migrate_pages", (void *)nullptr},
[__NR_openat] = {"openat", (void *)nullptr},
[__NR_mkdirat] = {"mkdirat", (void *)nullptr},
[__NR_mknodat] = {"mknodat", (void *)nullptr},
[__NR_fchownat] = {"fchownat", (void *)nullptr},
[__NR_futimesat] = {"futimesat", (void *)nullptr},
[__NR_newfstatat] = {"newfstatat", (void *)nullptr},
[__NR_unlinkat] = {"unlinkat", (void *)nullptr},
[__NR_renameat] = {"renameat", (void *)nullptr},
[__NR_linkat] = {"linkat", (void *)nullptr},
[__NR_symlinkat] = {"symlinkat", (void *)nullptr},
[__NR_readlinkat] = {"readlinkat", (void *)nullptr},
[__NR_fchmodat] = {"fchmodat", (void *)nullptr},
[__NR_faccessat] = {"faccessat", (void *)nullptr},
[__NR_pselect6] = {"pselect6", (void *)nullptr},
[__NR_ppoll] = {"ppoll", (void *)nullptr},
[__NR_unshare] = {"unshare", (void *)nullptr},
[__NR_set_robust_list] = {"set_robust_list", (void *)nullptr},
[__NR_get_robust_list] = {"get_robust_list", (void *)nullptr},
[__NR_splice] = {"splice", (void *)nullptr},
[__NR_tee] = {"tee", (void *)nullptr},
[__NR_sync_file_range] = {"sync_file_range", (void *)nullptr},
[__NR_vmsplice] = {"vmsplice", (void *)nullptr},
[__NR_move_pages] = {"move_pages", (void *)nullptr},
[__NR_utimensat] = {"utimensat", (void *)nullptr},
[__NR_epoll_pwait] = {"epoll_pwait", (void *)nullptr},
[__NR_signalfd] = {"signalfd", (void *)nullptr},
[__NR_timerfd_create] = {"timerfd_create", (void *)nullptr},
[__NR_eventfd] = {"eventfd", (void *)nullptr},
[__NR_fallocate] = {"fallocate", (void *)nullptr},
[__NR_timerfd_settime] = {"timerfd_settime", (void *)nullptr},
[__NR_timerfd_gettime] = {"timerfd_gettime", (void *)nullptr},
[__NR_accept4] = {"accept4", (void *)nullptr},
[__NR_signalfd4] = {"signalfd4", (void *)nullptr},
[__NR_eventfd2] = {"eventfd2", (void *)nullptr},
[__NR_epoll_create1] = {"epoll_create1", (void *)nullptr},
[__NR_dup3] = {"dup3", (void *)nullptr},
[__NR_pipe2] = {"pipe2", (void *)nullptr},
[__NR_inotify_init1] = {"inotify_init1", (void *)nullptr},
[__NR_preadv] = {"preadv", (void *)nullptr},
[__NR_pwritev] = {"pwritev", (void *)nullptr},
[__NR_rt_tgsigqueueinfo] = {"rt_tgsigqueueinfo", (void *)nullptr},
[__NR_perf_event_open] = {"perf_event_open", (void *)nullptr},
[__NR_recvmmsg] = {"recvmmsg", (void *)nullptr},
[__NR_fanotify_init] = {"fanotify_init", (void *)nullptr},
[__NR_fanotify_mark] = {"fanotify_mark", (void *)nullptr},
[__NR_prlimit64] = {"prlimit64", (void *)nullptr},
[__NR_name_to_handle_at] = {"name_to_handle_at", (void *)nullptr},
[__NR_open_by_handle_at] = {"open_by_handle_at", (void *)nullptr},
[__NR_clock_adjtime] = {"clock_adjtime", (void *)nullptr},
[__NR_syncfs] = {"syncfs", (void *)nullptr},
[__NR_sendmmsg] = {"sendmmsg", (void *)nullptr},
[__NR_setns] = {"setns", (void *)nullptr},
[__NR_getcpu] = {"getcpu", (void *)nullptr},
[__NR_process_vm_readv] = {"process_vm_readv", (void *)nullptr},
[__NR_process_vm_writev] = {"process_vm_writev", (void *)nullptr},
[__NR_kcmp] = {"kcmp", (void *)nullptr},
[__NR_finit_module] = {"finit_module", (void *)nullptr},
[__NR_sched_setattr] = {"sched_setattr", (void *)nullptr},
[__NR_sched_getattr] = {"sched_getattr", (void *)nullptr},
[__NR_renameat2] = {"renameat2", (void *)nullptr},
[__NR_seccomp] = {"seccomp", (void *)nullptr},
[__NR_getrandom] = {"getrandom", (void *)nullptr},
[__NR_memfd_create] = {"memfd_create", (void *)nullptr},
[__NR_kexec_file_load] = {"kexec_file_load", (void *)nullptr},
[__NR_bpf] = {"bpf", (void *)nullptr},
[__NR_execveat] = {"execveat", (void *)nullptr},
[__NR_userfaultfd] = {"userfaultfd", (void *)nullptr},
[__NR_membarrier] = {"membarrier", (void *)nullptr},
[__NR_mlock2] = {"mlock2", (void *)nullptr},
[__NR_copy_file_range] = {"copy_file_range", (void *)nullptr},
[__NR_preadv2] = {"preadv2", (void *)nullptr},
[__NR_pwritev2] = {"pwritev2", (void *)nullptr},
[__NR_pkey_mprotect] = {"pkey_mprotect", (void *)nullptr},
[__NR_pkey_alloc] = {"pkey_alloc", (void *)nullptr},
[__NR_pkey_free] = {"pkey_free", (void *)nullptr},
[__NR_statx] = {"statx", (void *)nullptr},
[__NR_io_pgetevents] = {"io_pgetevents", (void *)nullptr},
[__NR_rseq] = {"rseq", (void *)nullptr},
[335] = {"reserved", (void *)nullptr},
[336] = {"reserved", (void *)nullptr},
[337] = {"reserved", (void *)nullptr},
[338] = {"reserved", (void *)nullptr},
[339] = {"reserved", (void *)nullptr},
[340] = {"reserved", (void *)nullptr},
[341] = {"reserved", (void *)nullptr},
[342] = {"reserved", (void *)nullptr},
[343] = {"reserved", (void *)nullptr},
[344] = {"reserved", (void *)nullptr},
[345] = {"reserved", (void *)nullptr},
[346] = {"reserved", (void *)nullptr},
[347] = {"reserved", (void *)nullptr},
[348] = {"reserved", (void *)nullptr},
[349] = {"reserved", (void *)nullptr},
[350] = {"reserved", (void *)nullptr},
[351] = {"reserved", (void *)nullptr},
[352] = {"reserved", (void *)nullptr},
[353] = {"reserved", (void *)nullptr},
[354] = {"reserved", (void *)nullptr},
[355] = {"reserved", (void *)nullptr},
[356] = {"reserved", (void *)nullptr},
[357] = {"reserved", (void *)nullptr},
[358] = {"reserved", (void *)nullptr},
[359] = {"reserved", (void *)nullptr},
[360] = {"reserved", (void *)nullptr},
[361] = {"reserved", (void *)nullptr},
[362] = {"reserved", (void *)nullptr},
[363] = {"reserved", (void *)nullptr},
[364] = {"reserved", (void *)nullptr},
[365] = {"reserved", (void *)nullptr},
[366] = {"reserved", (void *)nullptr},
[367] = {"reserved", (void *)nullptr},
[368] = {"reserved", (void *)nullptr},
[369] = {"reserved", (void *)nullptr},
[370] = {"reserved", (void *)nullptr},
[371] = {"reserved", (void *)nullptr},
[372] = {"reserved", (void *)nullptr},
[373] = {"reserved", (void *)nullptr},
[374] = {"reserved", (void *)nullptr},
[375] = {"reserved", (void *)nullptr},
[376] = {"reserved", (void *)nullptr},
[377] = {"reserved", (void *)nullptr},
[378] = {"reserved", (void *)nullptr},
[379] = {"reserved", (void *)nullptr},
[380] = {"reserved", (void *)nullptr},
[381] = {"reserved", (void *)nullptr},
[382] = {"reserved", (void *)nullptr},
[383] = {"reserved", (void *)nullptr},
[384] = {"reserved", (void *)nullptr},
[385] = {"reserved", (void *)nullptr},
[386] = {"reserved", (void *)nullptr},
[387] = {"reserved", (void *)nullptr},
[388] = {"reserved", (void *)nullptr},
[389] = {"reserved", (void *)nullptr},
[390] = {"reserved", (void *)nullptr},
[391] = {"reserved", (void *)nullptr},
[392] = {"reserved", (void *)nullptr},
[393] = {"reserved", (void *)nullptr},
[394] = {"reserved", (void *)nullptr},
[395] = {"reserved", (void *)nullptr},
[396] = {"reserved", (void *)nullptr},
[397] = {"reserved", (void *)nullptr},
[398] = {"reserved", (void *)nullptr},
[399] = {"reserved", (void *)nullptr},
[400] = {"reserved", (void *)nullptr},
[401] = {"reserved", (void *)nullptr},
[402] = {"reserved", (void *)nullptr},
[403] = {"reserved", (void *)nullptr},
[404] = {"reserved", (void *)nullptr},
[405] = {"reserved", (void *)nullptr},
[406] = {"reserved", (void *)nullptr},
[407] = {"reserved", (void *)nullptr},
[408] = {"reserved", (void *)nullptr},
[409] = {"reserved", (void *)nullptr},
[410] = {"reserved", (void *)nullptr},
[411] = {"reserved", (void *)nullptr},
[412] = {"reserved", (void *)nullptr},
[413] = {"reserved", (void *)nullptr},
[414] = {"reserved", (void *)nullptr},
[415] = {"reserved", (void *)nullptr},
[416] = {"reserved", (void *)nullptr},
[417] = {"reserved", (void *)nullptr},
[418] = {"reserved", (void *)nullptr},
[419] = {"reserved", (void *)nullptr},
[420] = {"reserved", (void *)nullptr},
[421] = {"reserved", (void *)nullptr},
[422] = {"reserved", (void *)nullptr},
[423] = {"reserved", (void *)nullptr},
[__NR_pidfd_send_signal] = {"pidfd_send_signal", (void *)nullptr},
[__NR_io_uring_setup] = {"io_uring_setup", (void *)nullptr},
[__NR_io_uring_enter] = {"io_uring_enter", (void *)nullptr},
[__NR_io_uring_register] = {"io_uring_register", (void *)nullptr},
[__NR_open_tree] = {"open_tree", (void *)nullptr},
[__NR_move_mount] = {"move_mount", (void *)nullptr},
[__NR_fsopen] = {"fsopen", (void *)nullptr},
[__NR_fsconfig] = {"fsconfig", (void *)nullptr},
[__NR_fsmount] = {"fsmount", (void *)nullptr},
[__NR_fspick] = {"fspick", (void *)nullptr},
[__NR_pidfd_open] = {"pidfd_open", (void *)nullptr},
[__NR_clone3] = {"clone3", (void *)nullptr},
[__NR_close_range] = {"close_range", (void *)nullptr},
[__NR_openat2] = {"openat2", (void *)nullptr},
[__NR_pidfd_getfd] = {"pidfd_getfd", (void *)nullptr},
[__NR_faccessat2] = {"faccessat2", (void *)nullptr},
[__NR_process_madvise] = {"process_madvise", (void *)nullptr},
[__NR_epoll_pwait2] = {"epoll_pwait2", (void *)nullptr},
[__NR_mount_setattr] = {"mount_setattr", (void *)nullptr},
[443] = {"reserved", (void *)nullptr},
[__NR_landlock_create_ruleset] = {"landlock_create_ruleset", (void *)nullptr},
[__NR_landlock_add_rule] = {"landlock_add_rule", (void *)nullptr},
[__NR_landlock_restrict_self] = {"landlock_restrict_self", (void *)nullptr},
};
uintptr_t HandleLinuxSyscalls(SyscallsFrame *Frame)
{
#if defined(a64)
if (Frame->rax > sizeof(LinuxSyscallsTable) / sizeof(SyscallData))
{
fixme("Syscall %d not implemented",
Frame->rax);
return -ENOSYS;
}
SyscallData Syscall = LinuxSyscallsTable[Frame->rax];
long (*call)(long, ...) = r_cst(long (*)(long, ...),
Syscall.Handler);
if (unlikely(!call))
{
error("Syscall %s(%d) not implemented.",
Syscall.Name, Frame->rax);
return -ENOSYS;
}
debug("[%d:\"%s\"]->( %#lx %#lx %#lx %#lx %#lx %#lx )",
Frame->rax, Syscall.Name,
Frame->rdi, Frame->rsi, Frame->rdx,
Frame->r10, Frame->r8, Frame->r9);
return call(Frame->rdi, Frame->rsi, Frame->rdx,
Frame->r10, Frame->r8, Frame->r9);
#elif defined(a32)
return 0;
#elif defined(aa64)
return 0;
#endif
}

381
SystemCalls/Linux/linux_syscalls.hpp Normal file
View File

@@ -0,0 +1,381 @@
/*
This file is part of Fennix Kernel.
Fennix Kernel is free software: you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
Fennix Kernel is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef __FENNIX_KERNEL_LINUX_SYSCALLS_H__
#define __FENNIX_KERNEL_LINUX_SYSCALLS_H__
#include <types.h>
#define __NR_read 0
#define __NR_write 1
#define __NR_open 2
#define __NR_close 3
#define __NR_stat 4
#define __NR_fstat 5
#define __NR_lstat 6
#define __NR_poll 7
#define __NR_lseek 8
#define __NR_mmap 9
#define __NR_mprotect 10
#define __NR_munmap 11
#define __NR_brk 12
#define __NR_rt_sigaction 13
#define __NR_rt_sigprocmask 14
#define __NR_rt_sigreturn 15
#define __NR_ioctl 16
#define __NR_pread64 17
#define __NR_pwrite64 18
#define __NR_readv 19
#define __NR_writev 20
#define __NR_access 21
#define __NR_pipe 22
#define __NR_select 23
#define __NR_sched_yield 24
#define __NR_mremap 25
#define __NR_msync 26
#define __NR_mincore 27
#define __NR_madvise 28
#define __NR_shmget 29
#define __NR_shmat 30
#define __NR_shmctl 31
#define __NR_dup 32
#define __NR_dup2 33
#define __NR_pause 34
#define __NR_nanosleep 35
#define __NR_getitimer 36
#define __NR_alarm 37
#define __NR_setitimer 38
#define __NR_getpid 39
#define __NR_sendfile 40
#define __NR_socket 41
#define __NR_connect 42
#define __NR_accept 43
#define __NR_sendto 44
#define __NR_recvfrom 45
#define __NR_sendmsg 46
#define __NR_recvmsg 47
#define __NR_shutdown 48
#define __NR_bind 49
#define __NR_listen 50
#define __NR_getsockname 51
#define __NR_getpeername 52
#define __NR_socketpair 53
#define __NR_setsockopt 54
#define __NR_getsockopt 55
#define __NR_clone 56
#define __NR_fork 57
#define __NR_vfork 58
#define __NR_execve 59
#define __NR_exit 60
#define __NR_wait4 61
#define __NR_kill 62
#define __NR_uname 63
#define __NR_semget 64
#define __NR_semop 65
#define __NR_semctl 66
#define __NR_shmdt 67
#define __NR_msgget 68
#define __NR_msgsnd 69
#define __NR_msgrcv 70
#define __NR_msgctl 71
#define __NR_fcntl 72
#define __NR_flock 73
#define __NR_fsync 74
#define __NR_fdatasync 75
#define __NR_truncate 76
#define __NR_ftruncate 77
#define __NR_getdents 78
#define __NR_getcwd 79
#define __NR_chdir 80
#define __NR_fchdir 81
#define __NR_rename 82
#define __NR_mkdir 83
#define __NR_rmdir 84
#define __NR_creat 85
#define __NR_link 86
#define __NR_unlink 87
#define __NR_symlink 88
#define __NR_readlink 89
#define __NR_chmod 90
#define __NR_fchmod 91
#define __NR_chown 92
#define __NR_fchown 93
#define __NR_lchown 94
#define __NR_umask 95
#define __NR_gettimeofday 96
#define __NR_getrlimit 97
#define __NR_getrusage 98
#define __NR_sysinfo 99
#define __NR_times 100
#define __NR_ptrace 101
#define __NR_getuid 102
#define __NR_syslog 103
#define __NR_getgid 104
#define __NR_setuid 105
#define __NR_setgid 106
#define __NR_geteuid 107
#define __NR_getegid 108
#define __NR_setpgid 109
#define __NR_getppid 110
#define __NR_getpgrp 111
#define __NR_setsid 112
#define __NR_setreuid 113
#define __NR_setregid 114
#define __NR_getgroups 115
#define __NR_setgroups 116
#define __NR_setresuid 117
#define __NR_getresuid 118
#define __NR_setresgid 119
#define __NR_getresgid 120
#define __NR_getpgid 121
#define __NR_setfsuid 122
#define __NR_setfsgid 123
#define __NR_getsid 124
#define __NR_capget 125
#define __NR_capset 126
#define __NR_rt_sigpending 127
#define __NR_rt_sigtimedwait 128
#define __NR_rt_sigqueueinfo 129
#define __NR_rt_sigsuspend 130
#define __NR_sigaltstack 131
#define __NR_utime 132
#define __NR_mknod 133
#define __NR_uselib 134
#define __NR_personality 135
#define __NR_ustat 136
#define __NR_statfs 137
#define __NR_fstatfs 138
#define __NR_sysfs 139
#define __NR_getpriority 140
#define __NR_setpriority 141
#define __NR_sched_setparam 142
#define __NR_sched_getparam 143
#define __NR_sched_setscheduler 144
#define __NR_sched_getscheduler 145
#define __NR_sched_get_priority_max 146
#define __NR_sched_get_priority_min 147
#define __NR_sched_rr_get_interval 148
#define __NR_mlock 149
#define __NR_munlock 150
#define __NR_mlockall 151
#define __NR_munlockall 152
#define __NR_vhangup 153
#define __NR_modify_ldt 154
#define __NR_pivot_root 155
#define __NR__sysctl 156
#define __NR_prctl 157
#define __NR_arch_prctl 158
#define __NR_adjtimex 159
#define __NR_setrlimit 160
#define __NR_chroot 161
#define __NR_sync 162
#define __NR_acct 163
#define __NR_settimeofday 164
#define __NR_mount 165
#define __NR_umount2 166
#define __NR_swapon 167
#define __NR_swapoff 168
#define __NR_reboot 169
#define __NR_sethostname 170
#define __NR_setdomainname 171
#define __NR_iopl 172
#define __NR_ioperm 173
#define __NR_create_module 174
#define __NR_init_module 175
#define __NR_delete_module 176
#define __NR_get_kernel_syms 177
#define __NR_query_module 178
#define __NR_quotactl 179
#define __NR_nfsservctl 180
#define __NR_getpmsg 181
#define __NR_putpmsg 182
#define __NR_afs_syscall 183
#define __NR_tuxcall 184
#define __NR_security 185
#define __NR_gettid 186
#define __NR_readahead 187
#define __NR_setxattr 188
#define __NR_lsetxattr 189
#define __NR_fsetxattr 190
#define __NR_getxattr 191
#define __NR_lgetxattr 192
#define __NR_fgetxattr 193
#define __NR_listxattr 194
#define __NR_llistxattr 195
#define __NR_flistxattr 196
#define __NR_removexattr 197
#define __NR_lremovexattr 198
#define __NR_fremovexattr 199
#define __NR_tkill 200
#define __NR_time 201
#define __NR_futex 202
#define __NR_sched_setaffinity 203
#define __NR_sched_getaffinity 204
#define __NR_set_thread_area 205
#define __NR_io_setup 206
#define __NR_io_destroy 207
#define __NR_io_getevents 208
#define __NR_io_submit 209
#define __NR_io_cancel 210
#define __NR_get_thread_area 211
#define __NR_lookup_dcookie 212
#define __NR_epoll_create 213
#define __NR_epoll_ctl_old 214
#define __NR_epoll_wait_old 215
#define __NR_remap_file_pages 216
#define __NR_getdents64 217
#define __NR_set_tid_address 218
#define __NR_restart_syscall 219
#define __NR_semtimedop 220
#define __NR_fadvise64 221
#define __NR_timer_create 222
#define __NR_timer_settime 223
#define __NR_timer_gettime 224
#define __NR_timer_getoverrun 225
#define __NR_timer_delete 226
#define __NR_clock_settime 227
#define __NR_clock_gettime 228
#define __NR_clock_getres 229
#define __NR_clock_nanosleep 230
#define __NR_exit_group 231
#define __NR_epoll_wait 232
#define __NR_epoll_ctl 233
#define __NR_tgkill 234
#define __NR_utimes 235
#define __NR_vserver 236
#define __NR_mbind 237
#define __NR_set_mempolicy 238
#define __NR_get_mempolicy 239
#define __NR_mq_open 240
#define __NR_mq_unlink 241
#define __NR_mq_timedsend 242
#define __NR_mq_timedreceive 243
#define __NR_mq_notify 244
#define __NR_mq_getsetattr 245
#define __NR_kexec_load 246
#define __NR_waitid 247
#define __NR_add_key 248
#define __NR_request_key 249
#define __NR_keyctl 250
#define __NR_ioprio_set 251
#define __NR_ioprio_get 252
#define __NR_inotify_init 253
#define __NR_inotify_add_watch 254
#define __NR_inotify_rm_watch 255
#define __NR_migrate_pages 256
#define __NR_openat 257
#define __NR_mkdirat 258
#define __NR_mknodat 259
#define __NR_fchownat 260
#define __NR_futimesat 261
#define __NR_newfstatat 262
#define __NR_unlinkat 263
#define __NR_renameat 264
#define __NR_linkat 265
#define __NR_symlinkat 266
#define __NR_readlinkat 267
#define __NR_fchmodat 268
#define __NR_faccessat 269
#define __NR_pselect6 270
#define __NR_ppoll 271
#define __NR_unshare 272
#define __NR_set_robust_list 273
#define __NR_get_robust_list 274
#define __NR_splice 275
#define __NR_tee 276
#define __NR_sync_file_range 277
#define __NR_vmsplice 278
#define __NR_move_pages 279
#define __NR_utimensat 280
#define __NR_epoll_pwait 281
#define __NR_signalfd 282
#define __NR_timerfd_create 283
#define __NR_eventfd 284
#define __NR_fallocate 285
#define __NR_timerfd_settime 286
#define __NR_timerfd_gettime 287
#define __NR_accept4 288
#define __NR_signalfd4 289
#define __NR_eventfd2 290
#define __NR_epoll_create1 291
#define __NR_dup3 292
#define __NR_pipe2 293
#define __NR_inotify_init1 294
#define __NR_preadv 295
#define __NR_pwritev 296
#define __NR_rt_tgsigqueueinfo 297
#define __NR_perf_event_open 298
#define __NR_recvmmsg 299
#define __NR_fanotify_init 300
#define __NR_fanotify_mark 301
#define __NR_prlimit64 302
#define __NR_name_to_handle_at 303
#define __NR_open_by_handle_at 304
#define __NR_clock_adjtime 305
#define __NR_syncfs 306
#define __NR_sendmmsg 307
#define __NR_setns 308
#define __NR_getcpu 309
#define __NR_process_vm_readv 310
#define __NR_process_vm_writev 311
#define __NR_kcmp 312
#define __NR_finit_module 313
#define __NR_sched_setattr 314
#define __NR_sched_getattr 315
#define __NR_renameat2 316
#define __NR_seccomp 317
#define __NR_getrandom 318
#define __NR_memfd_create 319
#define __NR_kexec_file_load 320
#define __NR_bpf 321
#define __NR_execveat 322
#define __NR_userfaultfd 323
#define __NR_membarrier 324
#define __NR_mlock2 325
#define __NR_copy_file_range 326
#define __NR_preadv2 327
#define __NR_pwritev2 328
#define __NR_pkey_mprotect 329
#define __NR_pkey_alloc 330
#define __NR_pkey_free 331
#define __NR_statx 332
#define __NR_io_pgetevents 333
#define __NR_rseq 334
#define __NR_pidfd_send_signal 424
#define __NR_io_uring_setup 425
#define __NR_io_uring_enter 426
#define __NR_io_uring_register 427
#define __NR_open_tree 428
#define __NR_move_mount 429
#define __NR_fsopen 430
#define __NR_fsconfig 431
#define __NR_fsmount 432
#define __NR_fspick 433
#define __NR_pidfd_open 434
#define __NR_clone3 435
#define __NR_close_range 436
#define __NR_openat2 437
#define __NR_pidfd_getfd 438
#define __NR_faccessat2 439
#define __NR_process_madvise 440
#define __NR_epoll_pwait2 441
#define __NR_mount_setattr 442
#define __NR_landlock_create_ruleset 444
#define __NR_landlock_add_rule 445
#define __NR_landlock_restrict_self 446
#endif // !__FENNIX_KERNEL_LINUX_SYSCALLS_H__

617
SystemCalls/Native.cpp
View File

@@ -27,318 +27,241 @@
#include "../kernel.h"
#include "../ipc.h"
#define SysFrm SyscallsFrame
#if defined(a64) || defined(aa64)
static ssize_t ConvertErrno(ssize_t r)
{
if (r >= 0)
return r;
return -errno;
}
#endif
static int ConvertErrno(int r)
{
if (r >= 0)
return r;
return -errno;
}
struct SyscallData
{
const char *Name;
void *Handler;
int RequiredID;
};
using InterProcessCommunication::IPC;
using InterProcessCommunication::IPCID;
using Tasking::Token;
using Tasking::TTL;
using Tasking::PCB;
using Tasking::TCB;
using Tasking::TaskStatus::Ready;
using Tasking::TaskStatus::Terminated;
using Tasking::TTL::Trusted;
using Tasking::TTL::TrustedByKernel;
using Tasking::TTL::UnknownTrustLevel;
using Tasking::TTL::Untrusted;
using namespace Memory;
__noreturn static void sys_exit(SysFrm *, int code)
#define SysFrm SyscallsFrame
#if defined(a64)
typedef long arch_t;
#elif defined(a32)
typedef int arch_t;
#endif
__noreturn static void sys_exit(SysFrm *, int Code)
{
trace("Userspace thread %s(%d) exited with code %d (%#x)",
TaskManager->GetCurrentThread()->Name,
TaskManager->GetCurrentThread()->ID, code,
code < 0 ? -code : code);
thisThread->Name,
thisThread->ID, Code,
Code < 0 ? -Code : Code);
TaskManager->GetCurrentThread()->ExitCode = code;
TaskManager->GetCurrentThread()->Status = Terminated;
TaskManager->Schedule();
thisThread->ExitCode = Code;
thisThread->Status = Terminated;
TaskManager->Yield();
__builtin_unreachable();
}
static int sys_print(SysFrm *, char Char, int Index)
{
char ret = Display->Print(Char, Index, true);
if (!Config.BootAnimation && Index == 0)
Display->SetBuffer(Index);
return ret;
}
static uintptr_t sys_request_pages(SysFrm *, size_t Count)
{
Memory::MemMgr *MemMgr = TaskManager->GetCurrentThread()->Memory;
MemMgr *MemMgr = thisThread->Memory;
return (uintptr_t)MemMgr->RequestPages(Count + 1, true);
}
static int sys_free_pages(SysFrm *, uintptr_t Address, size_t Count)
static int sys_free_pages(SysFrm *, uintptr_t Address,
size_t Count)
{
Memory::MemMgr *MemMgr = TaskManager->GetCurrentThread()->Memory;
MemMgr *MemMgr = thisThread->Memory;
MemMgr->FreePages((void *)Address, Count + 1);
return SYSCALL_OK;
return 0;
}
static int sys_detach_address(SysFrm *, uintptr_t Address)
{
Memory::MemMgr *MemMgr = TaskManager->GetCurrentThread()->Memory;
MemMgr *MemMgr = thisThread->Memory;
MemMgr->DetachAddress((void *)Address);
return SYSCALL_OK;
return 0;
}
static int sys_memory_map(SysFrm *, uintptr_t VirtualAddress,
uintptr_t PhysicalAddress, size_t Size,
enum MemoryMapFlags Flags)
int Flags)
{
if (Flags > 7) /* (MAP_PRESENT | MAP_WRITABLE | MAP_USER) */
return SYSCALL_INVALID_ARGUMENT;
return -EINVAL;
Memory::PageTable *PageTable = TaskManager->GetCurrentProcess()->PageTable;
PageTable *PageTable = thisProcess->PageTable;
{
Memory::Virtual vmm = Memory::Virtual(PageTable);
Virtual vmm = Virtual(PageTable);
vmm.Map((void *)VirtualAddress,
(void *)PhysicalAddress,
Size, Flags);
}
return SYSCALL_OK;
return 0;
}
static int sys_memory_unmap(SysFrm *, uintptr_t VirtualAddress,
size_t Size)
{
Memory::PageTable *PageTable = TaskManager->GetCurrentProcess()->PageTable;
PageTable *PageTable = thisProcess->PageTable;
{
Memory::Virtual vmm = Memory::Virtual(PageTable);
Virtual vmm = Virtual(PageTable);
vmm.Unmap((void *)VirtualAddress,
Size);
}
return SYSCALL_OK;
return 0;
}
static uintptr_t sys_kernelctl(SysFrm *,
enum KCtl Command,
uint64_t Arg1, uint64_t Arg2,
uint64_t Arg3, uint64_t Arg4)
static arch_t sys_kernelctl(SysFrm *, KCtl Command,
arch_t Arg1, arch_t Arg2,
arch_t Arg3, arch_t Arg4)
{
switch (Command)
{
case KCTL_GET_PID:
return TaskManager->GetCurrentProcess()->ID;
case KCTL_GET_TID:
return TaskManager->GetCurrentThread()->ID;
case KCTL_GET_PAGE_SIZE:
return PAGE_SIZE;
case KCTL_IS_CRITICAL:
return TaskManager->GetCurrentThread()->Security.IsCritical;
case KCTL_REGISTER_ELF_LIB:
{
char *Identifier = (char *)Arg1;
const char *Path = (const char *)Arg2;
if (!Identifier || !Path)
return SYSCALL_INVALID_ARGUMENT;
std::string FullPath = Path;
int retries = 0;
RetryReadPath:
debug("KCTL_REGISTER_ELF_LIB: Trying to open %s",
FullPath.c_str());
VirtualFileSystem::File f = vfs->Open(FullPath.c_str());
if (!f.IsOK())
{
FullPath.clear();
switch (retries)
{
case 0:
FullPath = "/lib/";
break;
case 1:
FullPath = "/usr/lib/";
break;
case 2:
FullPath = "/";
break;
case 3:
{
VirtualFileSystem::Node *cwd =
TaskManager->GetCurrentProcess()->CurrentWorkingDirectory;
FullPath = vfs->GetPathFromNode(cwd).get();
break;
}
default:
{
vfs->Close(f);
return SYSCALL_INVALID_ARGUMENT;
}
}
FullPath += Path;
vfs->Close(f);
retries++;
goto RetryReadPath;
}
if (Execute::AddLibrary(Identifier, f))
{
vfs->Close(f);
return SYSCALL_OK;
}
else
{
vfs->Close(f);
return SYSCALL_INTERNAL_ERROR;
}
}
case KCTL_GET_ELF_LIB_MEMORY_IMAGE:
{
char *Identifier = (char *)Arg1;
if (!Identifier)
return 0;
Execute::SharedLibrary lib = Execute::GetLibrary(Identifier);
if (!lib.MemoryImage)
{
debug("Failed to get library memory image %#lx",
(uintptr_t)lib.MemoryImage);
}
debug("Returning memory image %#lx (%s)",
(uintptr_t)lib.MemoryImage, Identifier);
return (uintptr_t)lib.MemoryImage;
}
case KCTL_GET_ABSOLUTE_PATH:
{
char *Identifier = (char *)Arg1;
void *Buffer = (void *)Arg2;
size_t BufferSize = Arg3;
if (!Identifier || !Buffer || !BufferSize)
return SYSCALL_INVALID_ARGUMENT;
Execute::SharedLibrary lib = Execute::GetLibrary(Identifier);
if (!lib.MemoryImage)
return SYSCALL_INTERNAL_ERROR;
if (BufferSize < sizeof(lib.Path))
return SYSCALL_INVALID_ARGUMENT;
memcpy(Buffer, lib.Path, sizeof(lib.Path));
return SYSCALL_OK;
}
default:
{
warn("KernelCTL: Unknown command: %lld", Command);
return SYSCALL_INVALID_ARGUMENT;
}
}
UNUSED(Arg1);
UNUSED(Arg2);
UNUSED(Arg3);
UNUSED(Arg4);
}
static uint64_t sys_file_open(SysFrm *, const char *Path, uint64_t Flags)
{
function("%s, %#lx", Path, Flags);
VirtualFileSystem::Node *cwd = nullptr;
if (vfs->PathIsRelative(Path))
cwd = TaskManager->GetCurrentProcess()->CurrentWorkingDirectory;
else
cwd = vfs->GetRootNode();
VirtualFileSystem::File KPObj = vfs->Open(Path, cwd);
if (!KPObj.IsOK())
switch (Command)
{
debug("Failed to open file %s (%d)", Path, KPObj.Status);
vfs->Close(KPObj);
return SYSCALL_INTERNAL_ERROR;
}
Memory::MemMgr *MemMgr = TaskManager->GetCurrentThread()->Memory;
constexpr size_t FileStructPages =
TO_PAGES(sizeof(VirtualFileSystem::File));
VirtualFileSystem::File *KernelPrivate =
(VirtualFileSystem::File *)MemMgr->RequestPages(FileStructPages);
*KernelPrivate = KPObj;
debug("Opened file %s (%d)", KPObj.Name, KPObj.Status);
return (uint64_t)KernelPrivate;
UNUSED(Flags);
}
static int sys_file_close(SysFrm *, void *KernelPrivate)
{
function("%#lx", KernelPrivate);
if (KernelPrivate)
case KCTL_PRINT:
{
VirtualFileSystem::File KPObj = *(VirtualFileSystem::File *)KernelPrivate;
debug("Closed file %s (%d)", KPObj.Name, KPObj.Status);
vfs->Close(KPObj);
Memory::MemMgr *MemMgr = TaskManager->GetCurrentThread()->Memory;
MemMgr->FreePages(KernelPrivate,
TO_PAGES(sizeof(VirtualFileSystem::File)));
return SYSCALL_OK;
SmartHeap sh(strlen((const char *)Arg1) + 1);
sh = Arg1;
KPrint(sh);
return 0;
}
case KCTL_GET_PAGE_SIZE:
return PAGE_SIZE;
case KCTL_IS_CRITICAL:
return thisThread->Security.IsCritical;
default:
{
warn("KernelCTL: Unknown command: %d", Command);
return -EINVAL;
}
}
return SYSCALL_INVALID_ARGUMENT;
}
static uint64_t sys_file_read(SysFrm *, void *KernelPrivate,
uint8_t *Buffer, uint64_t Size)
static int sys_file_open(SysFrm *, const char *Path,
int Flags, mode_t Mode)
{
if (KernelPrivate == nullptr)
return 0;
debug("(KernelPrivate: %#lx, Offset: %#lx, Buffer: %#lx, Size: %#lx)",
KernelPrivate, Buffer, Size);
VirtualFileSystem::File *KPObj = (VirtualFileSystem::File *)KernelPrivate;
return vfs->Read(*KPObj, Buffer, (size_t)Size);
function("%s, %d, %d", Path, Flags, Mode);
PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_open(Path, Flags, Mode));
}
static uint64_t sys_file_write(SysFrm *, void *KernelPrivate,
uint8_t *Buffer, uint64_t Size)
static int sys_file_close(SysFrm *, int FileDescriptor)
{
if (KernelPrivate == nullptr)
return 0;
debug("(KernelPrivate: %#lx, Offset: %#lx, Buffer: %#lx, Size: %#lx)",
KernelPrivate, Buffer, Size);
VirtualFileSystem::File *KPObj = (VirtualFileSystem::File *)KernelPrivate;
return vfs->Write(*KPObj, Buffer, (size_t)Size);
function("%d", FileDescriptor);
PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_close(FileDescriptor));
}
static off_t sys_file_seek(SysFrm *, void *KernelPrivate,
static uint64_t sys_file_read(SysFrm *, int FileDescriptor,
void *Buffer, size_t Count)
{
function("%d, %p, %d", FileDescriptor, Buffer, Count);
PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_read(FileDescriptor, Buffer, Count));
}
static uint64_t sys_file_write(SysFrm *, int FileDescriptor,
const void *Buffer, size_t Count)
{
function("%d, %p, %d", FileDescriptor, Buffer, Count);
PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_write(FileDescriptor, Buffer, Count));
}
static off_t sys_file_seek(SysFrm *, int FileDescriptor,
off_t Offset, int Whence)
{
if (KernelPrivate == nullptr)
return 0;
debug("(KernelPrivate: %#lx, Offset: %#lx, Whence: %d)",
KernelPrivate, Offset, Whence);
VirtualFileSystem::File *KPObj = (VirtualFileSystem::File *)KernelPrivate;
off_t ret = vfs->Seek(*KPObj, (off_t)Offset, (uint8_t)Whence);
debug("Seek %s %ld", KPObj->Name, ret);
return ret;
function("%d, %d, %d", FileDescriptor, Offset, Whence);
PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_lseek(FileDescriptor, Offset, Whence));
}
static int sys_file_status(SysFrm *)
static int sys_file_status(SysFrm *, int FileDescriptor,
struct stat *StatBuffer)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
function("%d", FileDescriptor);
PCB *pcb = thisProcess;
VirtualFileSystem::FileDescriptorTable *fdt = pcb->FileDescriptors;
return ConvertErrno(fdt->_fstat(FileDescriptor, StatBuffer));
}
static int sys_ipc(SysFrm *, enum IPCCommand Command,
enum IPCType Type, int ID, int Flags,
void *Buffer, size_t Size)
{
InterProcessCommunication::IPC *ipc = TaskManager->GetCurrentProcess()->IPC;
InterProcessCommunication::IPC *ipc = thisProcess->IPC;
return ipc->HandleSyscall(Command, Type, ID, Flags, Buffer, Size);
}
static long sys_local_thread_state(SysFrm *, int Code,
unsigned long Address)
{
#if defined(a64) || defined(aa64)
switch (Code)
{
case LTS_SET_GS:
{
wrmsr(CPU::x64::MSR_GS_BASE, Address);
return 0;
}
case LTS_GET_GS:
{
return rdmsr(CPU::x64::MSR_GS_BASE);
}
case LTS_SET_FS:
{
wrmsr(CPU::x64::MSR_FS_BASE, Address);
return 0;
}
case LTS_GET_FS:
{
return rdmsr(CPU::x64::MSR_FS_BASE);
}
case LTS_SET_CPUID:
{
fixme("TLS_SET_CPUID");
return -ENOSYS;
}
case LTS_GET_CPUID:
{
fixme("TLS_GET_CPUID");
return -ENOSYS;
}
default:
return -EINVAL;
}
#endif
return -ENOSYS;
}
static int sys_sleep(SysFrm *, uint64_t Milliseconds)
{
TaskManager->Sleep(Milliseconds, true);
@@ -347,29 +270,31 @@ static int sys_sleep(SysFrm *, uint64_t Milliseconds)
static int sys_fork(SysFrm *Frame)
{
Tasking::PCB *Parent = TaskManager->GetCurrentThread()->Parent;
Tasking::TCB *Thread = TaskManager->GetCurrentThread();
#ifdef a32
return -ENOSYS;
#endif
PCB *Parent = thisThread->Parent;
TCB *Thread = thisThread;
void *ProcSymTable = nullptr;
if (Parent->ELFSymbolTable)
ProcSymTable = Parent->ELFSymbolTable->GetImage();
Tasking::PCB *NewProcess =
PCB *NewProcess =
TaskManager->CreateProcess(Parent,
Parent->Name,
Parent->Security.TrustLevel,
Parent->Security.ExecutionMode,
ProcSymTable);
if (!NewProcess)
{
error("Failed to create process for fork");
return SYSCALL_ERROR;
return -EAGAIN;
}
strncpy(NewProcess->Name, Parent->Name, sizeof(NewProcess->Name));
NewProcess->IPC->Fork(Parent->IPC);
Tasking::TCB *NewThread =
TCB *NewThread =
TaskManager->CreateThread(NewProcess,
0,
nullptr,
@@ -379,25 +304,26 @@ static int sys_fork(SysFrm *Frame)
Thread->Info.Compatibility,
true);
strncpy(NewThread->Name, Thread->Name, sizeof(Thread->Name));
NewThread->Rename(Thread->Name);
if (!NewThread)
{
error("Failed to create thread for fork");
return SYSCALL_ERROR;
return -EAGAIN;
}
static int RetChild = 0;
static uint64_t ReturnAddress = 0;
static uint64_t ChildStackPointer = 0;
TaskManager->Schedule();
TaskManager->UpdateFrame();
if (RetChild--)
{
/* We can't just return 0; because the
CPUData->SystemCallStack is no
longer valid */
#if defined(a64) || defined(aa64)
asmv("movq %0, %%rcx\n"
:
: "r"(ReturnAddress));
@@ -411,6 +337,10 @@ static int sys_fork(SysFrm *Frame)
asmv("swapgs\n"); /* Swap GS back to the user GS */
asmv("sti\n"); /* Enable interrupts */
asmv("sysretq\n"); /* Return to rcx address in user mode */
#elif defined(a32)
UNUSED(ReturnAddress);
UNUSED(ChildStackPointer);
#endif
}
RetChild = 1;
ReturnAddress = Frame->ReturnAddress;
@@ -424,19 +354,15 @@ static int sys_fork(SysFrm *Frame)
if (Thread->Security.IsCritical)
NewThread->SetCritical(true);
Tasking::Security *Sec = TaskManager->GetSecurityManager();
Sec->TrustToken(NewProcess->Security.UniqueToken,
(TTL)Sec->GetTokenTrustLevel(Parent->Security.UniqueToken));
Sec->TrustToken(NewThread->Security.UniqueToken,
(TTL)Sec->GetTokenTrustLevel(Thread->Security.UniqueToken));
#ifdef a86
NewThread->ShadowGSBase = Thread->ShadowGSBase;
NewThread->GSBase = Thread->GSBase;
NewThread->FSBase = Thread->FSBase;
#endif
debug("Forked thread \"%s\"(%d) to \"%s\"(%d)", Thread->Name, Thread->ID, NewThread->Name, NewThread->ID);
debug("Forked thread \"%s\"(%d) to \"%s\"(%d)",
Thread->Name, Thread->ID,
NewThread->Name, NewThread->ID);
NewThread->Status = Ready;
return (int)NewThread->ID;
}
@@ -444,118 +370,106 @@ static int sys_fork(SysFrm *Frame)
static int sys_wait(SysFrm *)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
static int sys_kill(SysFrm *)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
static int sys_spawn(SysFrm *)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
static int sys_spawn_thread(SysFrm *, uint64_t InstructionPointer)
{
Tasking::TCB *thread =
TaskManager->CreateThread(TaskManager->GetCurrentProcess(),
(Tasking::IP)InstructionPointer);
TCB *thread =
TaskManager->CreateThread(thisProcess,
Tasking::IP(InstructionPointer));
if (thread)
return (int)thread->ID;
return SYSCALL_ERROR;
return -EAGAIN;
}
static int sys_get_thread_list_of_process(SysFrm *)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
static int sys_get_current_process(SysFrm *)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
static int sys_get_current_thread(SysFrm *)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
static int sys_get_current_process_id(SysFrm *)
{
return (int)TaskManager->GetCurrentProcess()->ID;
return (int)thisProcess->ID;
}
static int sys_get_current_thread_id(SysFrm *)
{
return (int)TaskManager->GetCurrentThread()->ID;
return (int)thisThread->ID;
}
static int sys_get_process_by_pid(SysFrm *)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
static int sys_get_thread_by_tid(SysFrm *)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
static int sys_kill_process(SysFrm *)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
static int sys_kill_thread(SysFrm *)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
static int sys_sys_reserved_create_process(SysFrm *)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
static int sys_sys_reserved_create_thread(SysFrm *)
{
stub;
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
struct SyscallData
{
const char *Name;
void *Handler;
int TrustLevel;
};
static SyscallData NativeSyscallsTable[_MaxSyscall] = {
static SyscallData NativeSyscallsTable[sys_MaxSyscall] = {
/**
*
* Basic syscalls
*
*/
[_Exit] = {
[sys_Exit] = {
"Exit",
(void *)sys_exit,
TrustedByKernel | Trusted | Untrusted | UnknownTrustLevel,
},
[_Print] = {
"Print",
(void *)sys_print,
TrustedByKernel | Trusted,
UINT16_MAX,
},
/**
@@ -564,30 +478,30 @@ static SyscallData NativeSyscallsTable[_MaxSyscall] = {
*
*/
[_RequestPages] = {
[sys_RequestPages] = {
"RequestPages",
(void *)sys_request_pages,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
[_FreePages] = {
[sys_FreePages] = {
"FreePages",
(void *)sys_free_pages,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
[_DetachAddress] = {
[sys_DetachAddress] = {
"DetachAddress",
(void *)sys_detach_address,
TrustedByKernel | Trusted,
99,
},
[_MemoryMap] = {
[sys_MemoryMap] = {
"MemoryMap",
(void *)sys_memory_map,
TrustedByKernel,
99,
},
[_MemoryUnmap] = {
[sys_MemoryUnmap] = {
"MemoryUnmap",
(void *)sys_memory_unmap,
TrustedByKernel,
99,
},
/**
@@ -596,10 +510,10 @@ static SyscallData NativeSyscallsTable[_MaxSyscall] = {
*
*/
[_KernelCTL] = {
[sys_KernelCTL] = {
"KernelCTL",
(void *)sys_kernelctl,
TrustedByKernel | Trusted | Untrusted,
99,
},
/**
@@ -608,35 +522,35 @@ static SyscallData NativeSyscallsTable[_MaxSyscall] = {
*
*/
[_FileOpen] = {
[sys_FileOpen] = {
"FileOpen",
(void *)sys_file_open,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
[_FileClose] = {
[sys_FileClose] = {
"FileClose",
(void *)sys_file_close,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
[_FileRead] = {
[sys_FileRead] = {
"FileRead",
(void *)sys_file_read,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
[_FileWrite] = {
[sys_FileWrite] = {
"FileWrite",
(void *)sys_file_write,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
[_FileSeek] = {
[sys_FileSeek] = {
"FileSeek",
(void *)sys_file_seek,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
[_FileStatus] = {
[sys_FileStatus] = {
"FileStatus",
(void *)sys_file_status,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
/**
@@ -645,92 +559,97 @@ static SyscallData NativeSyscallsTable[_MaxSyscall] = {
*
*/
[_IPC] = {
[sys_IPC] = {
"IPC",
(void *)sys_ipc,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
[_Sleep] = {
[sys_LocalThreadState] = {
"LocalThreadState",
(void *)sys_local_thread_state,
UINT16_MAX,
},
[sys_Sleep] = {
"Sleep",
(void *)sys_sleep,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
[_Fork] = {
[sys_Fork] = {
"Fork",
(void *)sys_fork,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
[_Wait] = {
[sys_Wait] = {
"Wait",
(void *)sys_wait,
0,
},
[_Kill] = {
[sys_Kill] = {
"Kill",
(void *)sys_kill,
0,
},
[_Spawn] = {
[sys_Spawn] = {
"Spawn",
(void *)sys_spawn,
0,
},
[_SpawnThread] = {
[sys_SpawnThread] = {
"SpawnThread",
(void *)sys_spawn_thread,
0,
},
[_GetThreadListOfProcess] = {
[sys_GetThreadListOfProcess] = {
"GetThreadListOfProcess",
(void *)sys_get_thread_list_of_process,
0,
},
[_GetCurrentProcess] = {
[sys_GetCurrentProcess] = {
"GetCurrentProcess",
(void *)sys_get_current_process,
0,
},
[_GetCurrentThread] = {
[sys_GetCurrentThread] = {
"GetCurrentThread",
(void *)sys_get_current_thread,
0,
},
[_GetCurrentProcessID] = {
[sys_GetCurrentProcessID] = {
"GetCurrentProcessID",
(void *)sys_get_current_process_id,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
[_GetCurrentThreadID] = {
[sys_GetCurrentThreadID] = {
"GetCurrentThreadID",
(void *)sys_get_current_thread_id,
TrustedByKernel | Trusted | Untrusted,
UINT16_MAX,
},
[_GetProcessByPID] = {
[sys_GetProcessByPID] = {
"GetProcessByPID",
(void *)sys_get_process_by_pid,
0,
},
[_GetThreadByTID] = {
[sys_GetThreadByTID] = {
"GetThreadByTID",
(void *)sys_get_thread_by_tid,
0,
},
[_KillProcess] = {
[sys_KillProcess] = {
"KillProcess",
(void *)sys_kill_process,
0,
},
[_KillThread] = {
[sys_KillThread] = {
"KillThread",
(void *)sys_kill_thread,
0,
},
[_SysReservedCreateProcess] = {
[sys_SysReservedCreateProcess] = {
"SysReservedCreateProcess",
(void *)sys_sys_reserved_create_process,
0,
},
[_SysReservedCreateThread] = {
[sys_SysReservedCreateThread] = {
"SysReservedCreateThread",
(void *)sys_sys_reserved_create_thread,
0,
@@ -740,10 +659,10 @@ static SyscallData NativeSyscallsTable[_MaxSyscall] = {
uintptr_t HandleNativeSyscalls(SysFrm *Frame)
{
#if defined(a64)
if (unlikely(Frame->rax > _MaxSyscall))
if (unlikely(Frame->rax > sys_MaxSyscall))
{
fixme("Syscall %ld not implemented.", Frame->rax);
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
}
SyscallData Syscall = NativeSyscallsTable[Frame->rax];
@@ -754,28 +673,20 @@ uintptr_t HandleNativeSyscalls(SysFrm *Frame)
if (unlikely(!call))
{
error("Syscall %#lx not implemented.", Frame->rax);
return SYSCALL_NOT_IMPLEMENTED;
error("Syscall %s(%d) not implemented.",
Syscall.Name, Frame->rax);
return -ENOSYS;
}
Token token = TaskManager->GetCurrentThread()->Security.UniqueToken;
Tasking::Security *Sec = TaskManager->GetSecurityManager();
if (unlikely(!Sec->IsTokenTrusted(token, Syscall.TrustLevel)))
int euid = thisProcess->Security.Effective.UserID;
int egid = thisProcess->Security.Effective.GroupID;
int reqID = Syscall.RequiredID;
if (euid > reqID || egid > reqID)
{
warn("Thread %s(%d) tried to access a system call \"%s\" with insufficient trust level",
TaskManager->GetCurrentThread()->Name,
TaskManager->GetCurrentThread()->ID,
Syscall.Name);
#ifdef DEBUG
int TknTl = Sec->GetTokenTrustLevel(token);
debug("token=%#lx, trust=%d%d%d%d",token,
TknTl & TrustedByKernel ? 1 : 0,
TknTl & Trusted ? 1 : 0,
TknTl & Untrusted ? 1 : 0,
TknTl & UnknownTrustLevel ? 1 : 0);
#endif
return SYSCALL_ACCESS_DENIED;
warn("Process %s(%d) tried to access a system call \"%s\" with insufficient privileges.",
thisProcess->Name, thisProcess->ID, Syscall.Name);
debug("Required: %d; Effective u:%d, g:%d", reqID, euid, egid);
return -EPERM;
}
debug("[%d:\"%s\"]->( %#lx %#lx %#lx %#lx %#lx %#lx )",
@@ -787,8 +698,8 @@ uintptr_t HandleNativeSyscalls(SysFrm *Frame)
Frame->rdi, Frame->rsi, Frame->rdx,
Frame->r10, Frame->r8, Frame->r9);
#elif defined(a32)
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
#elif defined(aa64)
return SYSCALL_NOT_IMPLEMENTED;
return -ENOSYS;
#endif
}

12
SystemCalls/Syscalls.cpp
View File

@@ -23,15 +23,19 @@
extern "C" uintptr_t SystemCallsHandler(SyscallsFrame *Frame)
{
Tasking::TaskInfo *Ptinfo = &TaskManager->GetCurrentProcess()->Info;
Tasking::TaskInfo *Ttinfo = &TaskManager->GetCurrentThread()->Info;
Tasking::TaskInfo *Ptinfo = &thisProcess->Info;
Tasking::TaskInfo *Ttinfo = &thisThread->Info;
uint64_t TempTimeCalc = TimeManager->GetCounter();
switch (Ttinfo->Compatibility)
{
case Tasking::TaskCompatibility::Native:
{
uintptr_t ret = HandleNativeSyscalls(Frame);
uintptr_t ret = 0;
if (Config.UseLinuxSyscalls)
ret = HandleLinuxSyscalls(Frame);
else
ret = HandleNativeSyscalls(Frame);
Ptinfo->KernelTime += TimeManager->GetCounter() - TempTimeCalc;
Ttinfo->KernelTime += TimeManager->GetCounter() - TempTimeCalc;
return ret;
@@ -51,7 +55,7 @@ extern "C" uintptr_t SystemCallsHandler(SyscallsFrame *Frame)
default:
{
error("Unknown compatibility mode! Killing thread...");
TaskManager->KillThread(TaskManager->GetCurrentThread(), Tasking::KILL_SYSCALL);
TaskManager->KillThread(thisThread, Tasking::KILL_SYSCALL);
break;
}
}