1316 lines
37 KiB
C
1316 lines
37 KiB
C
/**
|
|
* @file kernel/sys/syscall.c
|
|
* @brief System call handlers.
|
|
*
|
|
* @copyright
|
|
* This file is part of ToaruOS and is released under the terms
|
|
* of the NCSA / University of Illinois License - see LICENSE.md
|
|
* Copyright (C) 2011-2021 K. Lange
|
|
*/
|
|
#include <stdint.h>
|
|
#include <errno.h>
|
|
#include <sys/sysfunc.h>
|
|
#include <sys/types.h>
|
|
#include <sys/utsname.h>
|
|
#include <sys/time.h>
|
|
#include <sys/times.h>
|
|
#include <sys/ptrace.h>
|
|
#include <sys/signal.h>
|
|
#include <syscall_nums.h>
|
|
#include <kernel/printf.h>
|
|
#include <kernel/process.h>
|
|
#include <kernel/string.h>
|
|
#include <kernel/version.h>
|
|
#include <kernel/pipe.h>
|
|
#include <kernel/shm.h>
|
|
#include <kernel/mmu.h>
|
|
#include <kernel/pty.h>
|
|
#include <kernel/spinlock.h>
|
|
#include <kernel/signal.h>
|
|
#include <kernel/time.h>
|
|
#include <kernel/syscall.h>
|
|
#include <kernel/misc.h>
|
|
#include <kernel/ptrace.h>
|
|
#include <kernel/net/netif.h>
|
|
|
|
static char hostname[256];
|
|
static size_t hostname_len = 0;
|
|
|
|
int ptr_validate(void * ptr, const char * syscall) {
|
|
if (ptr) {
|
|
if (!PTR_INRANGE(ptr)) {
|
|
send_signal(this_core->current_process->id, SIGSEGV, 1);
|
|
return 1;
|
|
}
|
|
if (!mmu_validate_user_pointer(ptr,1,0)) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#define PTRCHECK(addr,size,flags) do { if (!mmu_validate_user_pointer(addr,size,flags)) return -EFAULT; } while (0)
|
|
|
|
long sys_sbrk(ssize_t size) {
|
|
if (size & 0xFFF) return -EINVAL;
|
|
volatile process_t * volatile proc = this_core->current_process;
|
|
if (proc->group != 0) {
|
|
proc = process_from_pid(proc->group);
|
|
}
|
|
if (!proc) return -EINVAL;
|
|
spin_lock(proc->image.lock);
|
|
uintptr_t out = proc->image.heap;
|
|
for (uintptr_t i = out; i < out + size; i += 0x1000) {
|
|
union PML * page = mmu_get_page(i, MMU_GET_MAKE);
|
|
if (page->bits.page != 0) {
|
|
printf("odd, %#zx is already allocated?\n", i);
|
|
}
|
|
mmu_frame_allocate(page, MMU_FLAG_WRITABLE);
|
|
}
|
|
proc->image.heap += size;
|
|
spin_unlock(proc->image.lock);
|
|
return (long)out;
|
|
}
|
|
|
|
extern int elf_module(char ** args);
|
|
|
|
long sys_sysfunc(long fn, char ** args) {
|
|
/* FIXME: Most of these should be top-level, many are hacks/broken in Misaka */
|
|
switch (fn) {
|
|
case TOARU_SYS_FUNC_SYNC:
|
|
/* FIXME: There is no sync ability in the VFS at the moment.
|
|
* XXX: Should this just be an ioctl on individual devices?
|
|
* Or possibly even an ioctl we can send to arbitrary files? */
|
|
printf("sync: not implemented\n");
|
|
return -EINVAL;
|
|
|
|
case TOARU_SYS_FUNC_LOGHERE:
|
|
/* FIXME: The entire kernel logging system needs to be revamped as
|
|
* Misaka switched everything to raw printfs, and then also
|
|
* removed most of them for cleanliness... first task would
|
|
* be to reintroduce kernel fprintf() to printf to fs_nodes. */
|
|
//if (this_core->current_process->user != 0) return -EACCES;
|
|
printf("\033[32m%s\033[0m", (char*)args);
|
|
return -EINVAL;
|
|
|
|
case TOARU_SYS_FUNC_KDEBUG:
|
|
/* FIXME: The kernel debugger is completely deprecated and fully removed
|
|
* in Misaka, and I'm not sure I want to add it back... */
|
|
if (this_core->current_process->user != 0) return -EACCES;
|
|
printf("kdebug: not implemented\n");
|
|
return -EINVAL;
|
|
|
|
case 42:
|
|
#ifdef __aarch64__
|
|
PTR_VALIDATE(&args[0]);
|
|
PTR_VALIDATE(&args[1]);
|
|
extern void arch_clear_icache(uintptr_t,uintptr_t);
|
|
arch_clear_icache((uintptr_t)args[0], (uintptr_t)args[1]);
|
|
#endif
|
|
return 0;
|
|
|
|
case 43: {
|
|
extern void mmu_unmap_user(uintptr_t addr, size_t size);
|
|
PTR_VALIDATE(&args[0]);
|
|
PTR_VALIDATE(&args[1]);
|
|
volatile process_t * volatile proc = this_core->current_process;
|
|
if (proc->group != 0) proc = process_from_pid(proc->group);
|
|
if (!proc) return -EFAULT;
|
|
spin_lock(proc->image.lock);
|
|
mmu_unmap_user((uintptr_t)args[0], (size_t)args[1]);
|
|
spin_unlock(proc->image.lock);
|
|
return 0;
|
|
}
|
|
|
|
case TOARU_SYS_FUNC_INSMOD:
|
|
/* Linux has init_module as a system call? */
|
|
if (this_core->current_process->user != 0) return -EACCES;
|
|
PTR_VALIDATE(args);
|
|
if (!args) return -EFAULT;
|
|
PTR_VALIDATE(args[0]);
|
|
if (!args[0]) return -EFAULT;
|
|
for (char ** aa = args; *aa; ++aa) { PTR_VALIDATE(*aa); }
|
|
return elf_module(args);
|
|
|
|
case TOARU_SYS_FUNC_SETHEAP: {
|
|
/* I'm not really sure how this should be done...
|
|
* traditional brk() would be expected to map everything in-between,
|
|
* but we use this to move the heap in ld.so, and we don't want
|
|
* the stuff in the middle to be mapped necessarily... */
|
|
PTR_VALIDATE(args);
|
|
if (!args) return -EFAULT;
|
|
if (!PTR_INRANGE(args[0])) return -EFAULT;
|
|
if (!args[0]) return -EFAULT;
|
|
volatile process_t * volatile proc = this_core->current_process;
|
|
if (proc->group != 0) proc = process_from_pid(proc->group);
|
|
if (!proc) return -EFAULT;
|
|
spin_lock(proc->image.lock);
|
|
proc->image.heap = (uintptr_t)args[0];
|
|
spin_unlock(proc->image.lock);
|
|
return 0;
|
|
}
|
|
|
|
case TOARU_SYS_FUNC_MMAP: {
|
|
/* FIXME: This whole thing should be removed; we need a proper mmap interface,
|
|
* preferrably with all of the file mapping options, too. And it should
|
|
* probably also interact with the SHM subsystem... */
|
|
PTR_VALIDATE(args);
|
|
if (!args) return -EFAULT;
|
|
volatile process_t * volatile proc = this_core->current_process;
|
|
if (proc->group != 0) proc = process_from_pid(proc->group);
|
|
if (!proc) return -EFAULT;
|
|
spin_lock(proc->image.lock);
|
|
/* Align inputs */
|
|
uintptr_t start = ((uintptr_t)args[0]) & 0xFFFFffffFFFFf000UL;
|
|
uintptr_t end = ((uintptr_t)args[0] + (size_t)args[1] + 0xFFF) & 0xFFFFffffFFFFf000UL;
|
|
if (!PTR_INRANGE(start)) return -EFAULT;
|
|
if (!PTR_INRANGE(end)) return -EFAULT;
|
|
for (uintptr_t i = start; i < end; i += 0x1000) {
|
|
union PML * page = mmu_get_page(i, MMU_GET_MAKE);
|
|
mmu_frame_allocate(page, MMU_FLAG_WRITABLE);
|
|
}
|
|
spin_unlock(proc->image.lock);
|
|
return 0;
|
|
}
|
|
|
|
case TOARU_SYS_FUNC_THREADNAME: {
|
|
/* This should probably be moved to a new system call. */
|
|
int count = 0;
|
|
char **arg = args;
|
|
PTR_VALIDATE(args);
|
|
if (!args) return -EFAULT;
|
|
while (*arg) {
|
|
PTR_VALIDATE(*arg);
|
|
count++;
|
|
arg++;
|
|
}
|
|
this_core->current_process->cmdline = malloc(sizeof(char*)*(count+1));
|
|
int i = 0;
|
|
while (i < count) {
|
|
this_core->current_process->cmdline[i] = strdup(args[i]);
|
|
i++;
|
|
}
|
|
this_core->current_process->cmdline[i] = NULL;
|
|
return 0;
|
|
}
|
|
|
|
case TOARU_SYS_FUNC_SETGSBASE:
|
|
/* This should be a new system call; see what Linux, et al., call it. */
|
|
PTR_VALIDATE(args);
|
|
if (!args) return -EFAULT;
|
|
PTR_VALIDATE(args[0]);
|
|
this_core->current_process->thread.context.tls_base = (uintptr_t)args[0];
|
|
arch_set_tls_base(this_core->current_process->thread.context.tls_base);
|
|
return 0;
|
|
|
|
case TOARU_SYS_FUNC_NPROC:
|
|
return processor_count;
|
|
|
|
default:
|
|
printf("Bad system function: %ld\n", fn);
|
|
return -EINVAL;
|
|
}
|
|
return -EINVAL;
|
|
}
|
|
|
|
__attribute__((noreturn))
|
|
long sys_exit(long exitcode) {
|
|
task_exit((exitcode & 0xFF) << 8);
|
|
__builtin_unreachable();
|
|
}
|
|
|
|
long sys_write(int fd, char * ptr, unsigned long len) {
|
|
#if 0
|
|
/* Enable this to force stderr output to always be printed by the kernel. */
|
|
if (fd == 2) {
|
|
printf_output(len,ptr);
|
|
}
|
|
#endif
|
|
if (FD_CHECK(fd)) {
|
|
PTRCHECK(ptr,len,MMU_PTR_NULL);
|
|
fs_node_t * node = FD_ENTRY(fd);
|
|
if (!(FD_MODE(fd) & 2)) return -EACCES;
|
|
if (len && !ptr) {
|
|
return -EFAULT;
|
|
}
|
|
int64_t out = write_fs(node, FD_OFFSET(fd), len, (uint8_t*)ptr);
|
|
if (out > 0) {
|
|
FD_OFFSET(fd) += out;
|
|
}
|
|
return out;
|
|
}
|
|
return -EBADF;
|
|
}
|
|
|
|
long sys_pwrite(int fd, void * ptr, size_t count, off_t offset) {
|
|
if (FD_CHECK(fd)) {
|
|
if ((FD_ENTRY(fd)->flags & FS_PIPE) || (FD_ENTRY(fd)->flags & FS_CHARDEVICE) || (FD_ENTRY(fd)->flags & FS_SOCKET)) return -ESPIPE;
|
|
PTRCHECK(ptr,count,MMU_PTR_NULL);
|
|
fs_node_t * node = FD_ENTRY(fd);
|
|
if (!(FD_MODE(fd) & 2)) return -EACCES;
|
|
if (count && !ptr) return -EFAULT;
|
|
return write_fs(node, offset, count, (uint8_t*)ptr);
|
|
}
|
|
return -EBADF;
|
|
}
|
|
|
|
long sys_pread(int fd, void * ptr, size_t count, off_t offset) {
|
|
if (FD_CHECK(fd)) {
|
|
if ((FD_ENTRY(fd)->flags & FS_PIPE) || (FD_ENTRY(fd)->flags & FS_CHARDEVICE) || (FD_ENTRY(fd)->flags & FS_SOCKET)) return -ESPIPE;
|
|
PTRCHECK(ptr,count,MMU_PTR_NULL|MMU_PTR_WRITE);
|
|
fs_node_t * node = FD_ENTRY(fd);
|
|
if (!(FD_MODE(fd) & 01)) return -EACCES;
|
|
if (count && !ptr) return -EFAULT;
|
|
return read_fs(node, offset, count, (uint8_t *)ptr);
|
|
}
|
|
return -EBADF;
|
|
}
|
|
|
|
static long stat_node(fs_node_t * fn, uintptr_t st) {
|
|
struct stat * f = (struct stat *)st;
|
|
|
|
if (!fn) {
|
|
/* XXX: Does this need to zero the stat struct when returning -ENOENT? */
|
|
memset(f, 0x00, sizeof(struct stat));
|
|
return -ENOENT;
|
|
}
|
|
|
|
f->st_dev = (uint16_t)(((uint64_t)fn->device & 0xFFFF0) >> 8);
|
|
f->st_ino = fn->inode;
|
|
|
|
uint32_t flags = 0;
|
|
if (fn->flags & FS_FILE) { flags |= _IFREG; }
|
|
if (fn->flags & FS_DIRECTORY) { flags |= _IFDIR; }
|
|
if (fn->flags & FS_CHARDEVICE) { flags |= _IFCHR; }
|
|
if (fn->flags & FS_BLOCKDEVICE) { flags |= _IFBLK; }
|
|
if (fn->flags & FS_PIPE) { flags |= _IFIFO; }
|
|
if (fn->flags & FS_SYMLINK) { flags |= _IFLNK; }
|
|
if (fn->flags & FS_SOCKET) { flags |= _IFSOCK; }
|
|
|
|
f->st_mode = fn->mask | flags;
|
|
f->st_nlink = fn->nlink;
|
|
f->st_uid = fn->uid;
|
|
f->st_gid = fn->gid;
|
|
f->st_rdev = 0;
|
|
f->st_size = fn->length;
|
|
|
|
f->st_atime = fn->atime;
|
|
f->st_mtime = fn->mtime;
|
|
f->st_ctime = fn->ctime;
|
|
f->st_blksize = 512; /* whatever */
|
|
|
|
if (fn->get_size) {
|
|
f->st_size = fn->get_size(fn);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
long sys_stat(int fd, uintptr_t st) {
|
|
PTR_VALIDATE(st);
|
|
if (!st) return -EFAULT;
|
|
if (FD_CHECK(fd)) {
|
|
return stat_node(FD_ENTRY(fd), st);
|
|
}
|
|
return -EBADF;
|
|
}
|
|
|
|
long sys_statf(char * file, uintptr_t st) {
|
|
int result;
|
|
PTR_VALIDATE(file);
|
|
PTR_VALIDATE(st);
|
|
|
|
if (!file || !st) return -EFAULT;
|
|
|
|
fs_node_t * fn = kopen(file, 0);
|
|
result = stat_node(fn, st);
|
|
if (fn) {
|
|
close_fs(fn);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
long sys_symlink(char * target, char * name) {
|
|
PTR_VALIDATE(target);
|
|
PTR_VALIDATE(name);
|
|
if (!target || !name) return -EFAULT;
|
|
return symlink_fs(target, name);
|
|
}
|
|
|
|
long sys_readlink(const char * file, char * ptr, long len) {
|
|
PTR_VALIDATE(file);
|
|
PTRCHECK(ptr,len,0);
|
|
if (!file) return -EFAULT;
|
|
fs_node_t * node = kopen((char *) file, O_PATH | O_NOFOLLOW);
|
|
if (!node) {
|
|
return -ENOENT;
|
|
}
|
|
long rv = readlink_fs(node, ptr, len);
|
|
close_fs(node);
|
|
return rv;
|
|
}
|
|
|
|
long sys_lstat(char * file, uintptr_t st) {
|
|
PTR_VALIDATE(file);
|
|
PTR_VALIDATE(st);
|
|
if (!file || !st) return -EFAULT;
|
|
fs_node_t * fn = kopen(file, O_PATH | O_NOFOLLOW);
|
|
long result = stat_node(fn, st);
|
|
if (fn) {
|
|
close_fs(fn);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
long sys_open(const char * file, long flags, long mode) {
|
|
PTR_VALIDATE(file);
|
|
if (!file) return -EFAULT;
|
|
fs_node_t * node = kopen((char *)file, flags);
|
|
|
|
int access_bits = 0;
|
|
|
|
if (node && (flags & O_CREAT) && (flags & O_EXCL)) {
|
|
close_fs(node);
|
|
return -EEXIST;
|
|
}
|
|
|
|
if (!(flags & O_WRONLY) || (flags & O_RDWR)) {
|
|
if (node && !has_permission(node, 04)) {
|
|
close_fs(node);
|
|
return -EACCES;
|
|
} else {
|
|
access_bits |= 01;
|
|
}
|
|
}
|
|
|
|
if ((flags & O_RDWR) || (flags & O_WRONLY)) {
|
|
if (node && !has_permission(node, 02)) {
|
|
close_fs(node);
|
|
return -EACCES;
|
|
}
|
|
if (node && (node->flags & FS_DIRECTORY)) {
|
|
return -EISDIR;
|
|
}
|
|
if ((flags & O_RDWR) || (flags & O_WRONLY)) {
|
|
/* truncate doesn't grant write permissions */
|
|
access_bits |= 02;
|
|
}
|
|
}
|
|
|
|
if (!node && (flags & O_CREAT)) {
|
|
/* TODO check directory permissions */
|
|
int result = create_file_fs((char *)file, mode);
|
|
if (!result) {
|
|
node = kopen((char *)file, flags);
|
|
} else {
|
|
return result;
|
|
}
|
|
}
|
|
|
|
if (node && (flags & O_DIRECTORY)) {
|
|
if (!(node->flags & FS_DIRECTORY)) {
|
|
return -ENOTDIR;
|
|
}
|
|
}
|
|
|
|
if (node && (flags & O_TRUNC)) {
|
|
if (!(access_bits & 02)) {
|
|
close_fs(node);
|
|
return -EINVAL;
|
|
}
|
|
truncate_fs(node);
|
|
}
|
|
|
|
if (!node) {
|
|
return -ENOENT;
|
|
}
|
|
if (node && (flags & O_CREAT) && (node->flags & FS_DIRECTORY)) {
|
|
close_fs(node);
|
|
return -EISDIR;
|
|
}
|
|
int fd = process_append_fd((process_t *)this_core->current_process, node);
|
|
FD_MODE(fd) = access_bits;
|
|
if (flags & O_APPEND) {
|
|
FD_OFFSET(fd) = node->length;
|
|
} else {
|
|
FD_OFFSET(fd) = 0;
|
|
}
|
|
return fd;
|
|
}
|
|
|
|
long sys_close(int fd) {
|
|
if (FD_CHECK(fd)) {
|
|
close_fs(FD_ENTRY(fd));
|
|
FD_ENTRY(fd) = NULL;
|
|
return 0;
|
|
}
|
|
return -EBADF;
|
|
}
|
|
|
|
long sys_seek(int fd, long offset, long whence) {
|
|
if (FD_CHECK(fd)) {
|
|
if ((FD_ENTRY(fd)->flags & FS_PIPE) || (FD_ENTRY(fd)->flags & FS_CHARDEVICE) || (FD_ENTRY(fd)->flags & FS_SOCKET)) return -ESPIPE;
|
|
switch (whence) {
|
|
case 0:
|
|
FD_OFFSET(fd) = offset;
|
|
break;
|
|
case 1:
|
|
FD_OFFSET(fd) += offset;
|
|
break;
|
|
case 2:
|
|
FD_OFFSET(fd) = FD_ENTRY(fd)->length + offset;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
return FD_OFFSET(fd);
|
|
}
|
|
return -EBADF;
|
|
}
|
|
|
|
long sys_read(int fd, char * ptr, unsigned long len) {
|
|
if (FD_CHECK(fd)) {
|
|
PTRCHECK(ptr,len,MMU_PTR_NULL|MMU_PTR_WRITE);
|
|
if (len && !ptr) {
|
|
return -EFAULT;
|
|
}
|
|
|
|
fs_node_t * node = FD_ENTRY(fd);
|
|
if (!(FD_MODE(fd) & 01)) {
|
|
return -EACCES;
|
|
}
|
|
uint64_t out = read_fs(node, FD_OFFSET(fd), len, (uint8_t *)ptr);
|
|
FD_OFFSET(fd) += out;
|
|
return out;
|
|
}
|
|
return -EBADF;
|
|
}
|
|
|
|
long sys_ioctl(int fd, unsigned long request, void * argp) {
|
|
if (FD_CHECK(fd)) {
|
|
PTR_VALIDATE(argp);
|
|
return ioctl_fs(FD_ENTRY(fd), request, argp);
|
|
}
|
|
return -EBADF;
|
|
}
|
|
|
|
long sys_readdir(int fd, long index, struct dirent * entry) {
|
|
if (FD_CHECK(fd)) {
|
|
PTR_VALIDATE(entry);
|
|
if (!entry) return -EFAULT;
|
|
struct dirent * kentry = readdir_fs(FD_ENTRY(fd), (uint64_t)index);
|
|
if (kentry) {
|
|
memcpy(entry, kentry, sizeof *entry);
|
|
free(kentry);
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
return -EBADF;
|
|
}
|
|
|
|
long sys_mkdir(char * path, uint64_t mode) {
|
|
PTR_VALIDATE(path);
|
|
if (!path) return -EFAULT;
|
|
return mkdir_fs(path, mode);
|
|
}
|
|
|
|
long sys_access(const char * file, long flags) {
|
|
PTR_VALIDATE(file);
|
|
if (!file) return -EFAULT;
|
|
fs_node_t * node = kopen((char *)file, 0);
|
|
if (!node) return -ENOENT;
|
|
close_fs(node);
|
|
return 0;
|
|
}
|
|
|
|
long sys_chmod(char * file, long mode) {
|
|
PTR_VALIDATE(file);
|
|
if (!file) return -EFAULT;
|
|
fs_node_t * fn = kopen(file, 0);
|
|
if (fn) {
|
|
/* Can group members change bits? I think it's only owners. */
|
|
if (this_core->current_process->user != 0 && this_core->current_process->user != fn->uid) {
|
|
close_fs(fn);
|
|
return -EACCES;
|
|
}
|
|
long result = chmod_fs(fn, mode);
|
|
close_fs(fn);
|
|
return result;
|
|
} else {
|
|
return -ENOENT;
|
|
}
|
|
}
|
|
|
|
static int current_group_matches(gid_t gid) {
|
|
if (gid == this_core->current_process->user_group) return 1;
|
|
for (int i = 0; i < this_core->current_process->supplementary_group_count; ++i) {
|
|
if (gid == this_core->current_process->supplementary_group_list[i]) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
long sys_chown(char * file, uid_t uid, uid_t gid) {
|
|
PTR_VALIDATE(file);
|
|
if (!file) return -EFAULT;
|
|
fs_node_t * fn = kopen(file, 0);
|
|
if (fn) {
|
|
|
|
/* Only a privileged user can change the owner of a file. */
|
|
if (this_core->current_process->user != USER_ROOT_UID && uid != -1) {
|
|
goto _access;
|
|
}
|
|
|
|
if (this_core->current_process->user != USER_ROOT_UID && gid != -1) {
|
|
/* The owner of a file... */
|
|
if (this_core->current_process->user != fn->uid) {
|
|
goto _access;
|
|
}
|
|
|
|
/* May change the group of the file to one that the owner is a member of... */
|
|
if (!current_group_matches(gid)) {
|
|
goto _access;
|
|
}
|
|
}
|
|
|
|
if ((uid != -1 || gid != -1) && (fn->mask & 0x800)) {
|
|
/* Whenever the owner or group of a setuid executable is changed, it
|
|
* loses the setuid bit. */
|
|
chmod_fs(fn, fn->mask & (~0x800));
|
|
}
|
|
|
|
long result = chown_fs(fn, uid, gid);
|
|
close_fs(fn);
|
|
return result;
|
|
} else {
|
|
return -ENOENT;
|
|
}
|
|
|
|
_access:
|
|
close_fs(fn);
|
|
return -EACCES;
|
|
}
|
|
|
|
long sys_gettimeofday(struct timeval * tv, void * tz) {
|
|
PTR_VALIDATE(tv);
|
|
PTR_VALIDATE(tz);
|
|
if (!tv) return -EFAULT;
|
|
return gettimeofday(tv, tz);
|
|
}
|
|
|
|
long sys_settimeofday(struct timeval * tv, void * tz) {
|
|
extern int settimeofday(struct timeval * t, void *z);
|
|
if (this_core->current_process->user != USER_ROOT_UID) return -EPERM;
|
|
PTR_VALIDATE(tv);
|
|
PTR_VALIDATE(tz);
|
|
return settimeofday(tv,tz);
|
|
}
|
|
|
|
long sys_getuid(void) {
|
|
return (long)this_core->current_process->real_user;
|
|
}
|
|
|
|
long sys_geteuid(void) {
|
|
return (long)this_core->current_process->user;
|
|
}
|
|
|
|
long sys_setuid(uid_t new_uid) {
|
|
if (this_core->current_process->user == USER_ROOT_UID) {
|
|
this_core->current_process->user = new_uid;
|
|
this_core->current_process->real_user = new_uid;
|
|
return 0;
|
|
}
|
|
return -EPERM;
|
|
}
|
|
|
|
long sys_getgid(void) {
|
|
return (long)this_core->current_process->real_user_group;
|
|
}
|
|
|
|
long sys_getegid(void) {
|
|
return (long)this_core->current_process->user_group;
|
|
}
|
|
|
|
long sys_setgid(gid_t new_gid) {
|
|
if (this_core->current_process->user == USER_ROOT_UID) {
|
|
this_core->current_process->user_group = new_gid;
|
|
this_core->current_process->real_user_group = new_gid;
|
|
return 0;
|
|
}
|
|
return -EPERM;
|
|
}
|
|
|
|
long sys_getgroups(int size, gid_t list[]) {
|
|
if (size == 0) {
|
|
return this_core->current_process->supplementary_group_count;
|
|
} else if (size < this_core->current_process->supplementary_group_count) {
|
|
return -EINVAL;
|
|
} else {
|
|
PTR_VALIDATE(list);
|
|
if (!list) return -EFAULT;
|
|
for (int i = 0; i < this_core->current_process->supplementary_group_count; ++i) {
|
|
PTR_VALIDATE(list + i);
|
|
list[i] = this_core->current_process->supplementary_group_list[i];
|
|
}
|
|
return this_core->current_process->supplementary_group_count;
|
|
}
|
|
}
|
|
|
|
long sys_setgroups(int size, const gid_t list[]) {
|
|
if (this_core->current_process->user != USER_ROOT_UID) return -EPERM;
|
|
if (size < 0) return -EINVAL;
|
|
if (size > 32) return -EINVAL; /* Arbitrary decision */
|
|
|
|
/* Free the current set. */
|
|
if (this_core->current_process->supplementary_group_count) {
|
|
free(this_core->current_process->supplementary_group_list);
|
|
this_core->current_process->supplementary_group_list = NULL;
|
|
}
|
|
|
|
this_core->current_process->supplementary_group_count = size;
|
|
if (size == 0) return 0;
|
|
|
|
this_core->current_process->supplementary_group_list = malloc(sizeof(gid_t) * size);
|
|
|
|
PTR_VALIDATE(list);
|
|
if (!list) return -EFAULT;
|
|
|
|
for (int i = 0; i < size; ++i) {
|
|
PTR_VALIDATE(list + i);
|
|
this_core->current_process->supplementary_group_list[i] = list[i];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
long sys_getpid(void) {
|
|
/* The user actually wants the pid of the originating thread (which can be us). */
|
|
return this_core->current_process->group ? (long)this_core->current_process->group : (long)this_core->current_process->id;
|
|
}
|
|
|
|
long sys_gettid(void) {
|
|
return (long)this_core->current_process->id;
|
|
}
|
|
|
|
long sys_setsid(void) {
|
|
if (this_core->current_process->job == this_core->current_process->group) {
|
|
return -EPERM;
|
|
}
|
|
this_core->current_process->session = this_core->current_process->group;
|
|
this_core->current_process->job = this_core->current_process->group;
|
|
return this_core->current_process->session;
|
|
}
|
|
|
|
long sys_setpgid(pid_t pid, pid_t pgid) {
|
|
if (pgid < 0) {
|
|
return -EINVAL;
|
|
}
|
|
process_t * proc = NULL;
|
|
if (pid == 0) {
|
|
proc = (process_t*)this_core->current_process;
|
|
} else {
|
|
proc = process_from_pid(pid);
|
|
}
|
|
|
|
if (!proc) {
|
|
return -ESRCH;
|
|
}
|
|
if (proc->session != this_core->current_process->session || proc->session == proc->group) {
|
|
return -EPERM;
|
|
}
|
|
|
|
if (pgid == 0) {
|
|
proc->job = proc->group;
|
|
} else {
|
|
process_t * pgroup = process_from_pid(pgid);
|
|
|
|
if (!pgroup || pgroup->session != proc->session) {
|
|
return -EPERM;
|
|
}
|
|
|
|
proc->job = pgid;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
long sys_getpgid(pid_t pid) {
|
|
process_t * proc;
|
|
if (pid == 0) {
|
|
proc = (process_t*)this_core->current_process;
|
|
} else {
|
|
proc = process_from_pid(pid);
|
|
}
|
|
|
|
if (!proc) {
|
|
return -ESRCH;
|
|
}
|
|
|
|
return proc->job;
|
|
}
|
|
|
|
long sys_uname(struct utsname * name) {
|
|
PTR_VALIDATE(name);
|
|
if (!name) return -EFAULT;
|
|
char version_number[256];
|
|
snprintf(version_number, 255, __kernel_version_format,
|
|
__kernel_version_major,
|
|
__kernel_version_minor,
|
|
__kernel_version_lower,
|
|
__kernel_version_suffix);
|
|
char version_string[256];
|
|
snprintf(version_string, 255, "%s %s %s",
|
|
__kernel_version_codename,
|
|
__kernel_build_date,
|
|
__kernel_build_time);
|
|
strcpy(name->sysname, __kernel_name);
|
|
strcpy(name->nodename, hostname);
|
|
strcpy(name->release, version_number);
|
|
strcpy(name->version, version_string);
|
|
strcpy(name->machine, __kernel_arch);
|
|
strcpy(name->domainname, ""); /* TODO */
|
|
return 0;
|
|
}
|
|
|
|
long sys_chdir(char * newdir) {
|
|
PTR_VALIDATE(newdir);
|
|
if (!newdir) return -EFAULT;
|
|
char * path = canonicalize_path(this_core->current_process->wd_name, newdir);
|
|
fs_node_t * chd = kopen(path, 0);
|
|
if (chd) {
|
|
if ((chd->flags & FS_DIRECTORY) == 0) {
|
|
close_fs(chd);
|
|
return -ENOTDIR;
|
|
}
|
|
if (!has_permission(chd, 01)) {
|
|
close_fs(chd);
|
|
return -EACCES;
|
|
}
|
|
close_fs(chd);
|
|
free(this_core->current_process->wd_name);
|
|
this_core->current_process->wd_name = malloc(strlen(path) + 1);
|
|
memcpy(this_core->current_process->wd_name, path, strlen(path) + 1);
|
|
return 0;
|
|
} else {
|
|
return -ENOENT;
|
|
}
|
|
}
|
|
|
|
long sys_getcwd(char * buf, size_t size) {
|
|
if (buf) {
|
|
PTR_VALIDATE(buf);
|
|
size_t len = strlen(this_core->current_process->wd_name) + 1;
|
|
return (long)memcpy(buf, this_core->current_process->wd_name, size < len ? size : len);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
long sys_dup2(int old, int new) {
|
|
return process_move_fd((process_t *)this_core->current_process, old, new);
|
|
}
|
|
|
|
long sys_sethostname(char * new_hostname) {
|
|
if (this_core->current_process->user == USER_ROOT_UID) {
|
|
PTR_VALIDATE(new_hostname);
|
|
if (!new_hostname) return -EFAULT;
|
|
size_t len = strlen(new_hostname) + 1;
|
|
if (len > 256) {
|
|
return -ENAMETOOLONG;
|
|
}
|
|
hostname_len = len;
|
|
memcpy(hostname, new_hostname, hostname_len);
|
|
return 0;
|
|
} else {
|
|
return -EPERM;
|
|
}
|
|
}
|
|
|
|
long sys_gethostname(char * buffer) {
|
|
PTR_VALIDATE(buffer);
|
|
if (!buffer) return -EFAULT;
|
|
memcpy(buffer, hostname, hostname_len);
|
|
return hostname_len;
|
|
}
|
|
|
|
long sys_mount(char * arg, char * mountpoint, char * type, unsigned long flags, void * data) {
|
|
/* TODO: Make use of flags and data from mount command. */
|
|
(void)flags;
|
|
(void)data;
|
|
|
|
if (this_core->current_process->user != USER_ROOT_UID) {
|
|
return -EPERM;
|
|
}
|
|
|
|
if (PTR_INRANGE(arg) && PTR_INRANGE(mountpoint) && PTR_INRANGE(type)) {
|
|
return vfs_mount_type(type, arg, mountpoint);
|
|
}
|
|
|
|
return -EFAULT;
|
|
}
|
|
|
|
long sys_umask(long mode) {
|
|
this_core->current_process->mask = mode & 0777;
|
|
return 0;
|
|
}
|
|
|
|
long sys_unlink(char * file) {
|
|
PTR_VALIDATE(file);
|
|
if (!file) return -EFAULT;
|
|
return unlink_fs(file);
|
|
}
|
|
|
|
long sys_execve(const char * filename, char *const argv[], char *const envp[]) {
|
|
PTR_VALIDATE(filename);
|
|
PTR_VALIDATE(argv);
|
|
PTR_VALIDATE(envp);
|
|
|
|
if (!filename || !argv) return -EFAULT;
|
|
|
|
int argc = 0;
|
|
int envc = 0;
|
|
while (argv[argc]) {
|
|
PTR_VALIDATE(argv[argc]);
|
|
++argc;
|
|
}
|
|
|
|
if (envp) {
|
|
while (envp[envc]) {
|
|
PTR_VALIDATE(envp[envc]);
|
|
++envc;
|
|
}
|
|
}
|
|
|
|
char **argv_ = malloc(sizeof(char*) * (argc + 1));
|
|
for (int j = 0; j < argc; ++j) {
|
|
argv_[j] = malloc(strlen(argv[j]) + 1);
|
|
memcpy(argv_[j], argv[j], strlen(argv[j]) + 1);
|
|
}
|
|
argv_[argc] = 0;
|
|
char ** envp_;
|
|
if (envp && envc) {
|
|
envp_ = malloc(sizeof(char*) * (envc + 1));
|
|
for (int j = 0; j < envc; ++j) {
|
|
envp_[j] = malloc(strlen(envp[j]) + 1);
|
|
memcpy(envp_[j], envp[j], strlen(envp[j]) + 1);
|
|
}
|
|
envp_[envc] = 0;
|
|
} else {
|
|
envp_ = malloc(sizeof(char*));
|
|
envp_[0] = NULL;
|
|
}
|
|
|
|
/**
|
|
* FIXME: For legacy reasons, we're just going to close everything >2 for now,
|
|
* but we should really implement proper CLOEXEC semantics...
|
|
*/
|
|
for (unsigned int i = 3; i < this_core->current_process->fds->length; ++i) {
|
|
if (this_core->current_process->fds->entries[i]) {
|
|
close_fs(this_core->current_process->fds->entries[i]);
|
|
this_core->current_process->fds->entries[i] = NULL;
|
|
}
|
|
}
|
|
|
|
shm_release_all((process_t *)this_core->current_process);
|
|
|
|
this_core->current_process->cmdline = argv_;
|
|
return exec(filename, argc, argv_, envp_, 0);
|
|
}
|
|
|
|
long sys_fork(void) {
|
|
return fork();
|
|
}
|
|
|
|
long sys_clone(uintptr_t new_stack, uintptr_t thread_func, uintptr_t arg) {
|
|
if (!new_stack || !PTR_INRANGE(new_stack)) return -EINVAL;
|
|
if (!thread_func || !PTR_INRANGE(thread_func)) return -EINVAL;
|
|
return (int)clone(new_stack, thread_func, arg);
|
|
}
|
|
|
|
long sys_waitpid(int pid, int * status, int options) {
|
|
if (status && !PTR_INRANGE(status)) return -EINVAL;
|
|
return waitpid(pid, status, options);
|
|
}
|
|
|
|
long sys_yield(void) {
|
|
switch_task(1);
|
|
return 1;
|
|
}
|
|
|
|
long sys_sleepabs(unsigned long seconds, unsigned long subseconds) {
|
|
/* Mark us as asleep until <some time period> */
|
|
sleep_until((process_t *)this_core->current_process, seconds, subseconds);
|
|
|
|
/* Switch without adding us to the queue */
|
|
//printf("process %p (pid=%d) entering sleep until %ld.%06ld\n", current_process, current_process->id, seconds, subseconds);
|
|
switch_task(0);
|
|
|
|
unsigned long timer_ticks = 0, timer_subticks = 0;
|
|
relative_time(0,0,&timer_ticks,&timer_subticks);
|
|
//printf("process %p (pid=%d) resumed from sleep at %ld.%06ld\n", current_process, current_process->id, timer_ticks, timer_subticks);
|
|
|
|
if (seconds > timer_ticks || (seconds == timer_ticks && subseconds >= timer_subticks)) {
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
long sys_sleep(unsigned long seconds, unsigned long subseconds) {
|
|
unsigned long s, ss;
|
|
relative_time(seconds, subseconds * 10000, &s, &ss);
|
|
return sys_sleepabs(s, ss);
|
|
}
|
|
|
|
long sys_pipe(int pipes[2]) {
|
|
if (!pipes || !PTR_INRANGE(pipes)) {
|
|
return -EFAULT;
|
|
}
|
|
|
|
fs_node_t * outpipes[2];
|
|
|
|
make_unix_pipe(outpipes);
|
|
|
|
open_fs(outpipes[0], 0);
|
|
open_fs(outpipes[1], 0);
|
|
|
|
pipes[0] = process_append_fd((process_t *)this_core->current_process, outpipes[0]);
|
|
pipes[1] = process_append_fd((process_t *)this_core->current_process, outpipes[1]);
|
|
FD_MODE(pipes[0]) = 03;
|
|
FD_MODE(pipes[1]) = 03;
|
|
return 0;
|
|
}
|
|
|
|
long sys_signal(long signum, uintptr_t handler) {
|
|
if (signum >= NUMSIGNALS || signum < 0) return -EINVAL;
|
|
if (signum == SIGKILL || signum == SIGSTOP) return -EINVAL;
|
|
uintptr_t old = this_core->current_process->signals[signum].handler;
|
|
this_core->current_process->signals[signum].handler = handler;
|
|
this_core->current_process->signals[signum].flags = SA_RESTART;
|
|
return old;
|
|
}
|
|
|
|
long sys_sigaction(int signum, struct sigaction *act, struct sigaction *oldact) {
|
|
if (act) PTRCHECK(act,sizeof(struct sigaction),0);
|
|
if (oldact) PTRCHECK(oldact,sizeof(struct sigaction),MMU_PTR_WRITE);
|
|
|
|
if (signum >= NUMSIGNALS || signum < 0) return -EINVAL;
|
|
if (signum == SIGKILL || signum == SIGSTOP) return -EINVAL;
|
|
|
|
if (oldact) {
|
|
oldact->sa_handler = (_sig_func_ptr)this_core->current_process->signals[signum].handler;
|
|
oldact->sa_mask = this_core->current_process->signals[signum].mask;
|
|
oldact->sa_flags = this_core->current_process->signals[signum].flags;
|
|
}
|
|
|
|
if (act) {
|
|
this_core->current_process->signals[signum].handler = (uintptr_t)act->sa_handler;
|
|
this_core->current_process->signals[signum].mask = act->sa_mask;
|
|
this_core->current_process->signals[signum].flags = act->sa_flags;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
long sys_sigpending(sigset_t * set) {
|
|
PTRCHECK(set,sizeof(sigset_t),MMU_PTR_WRITE);
|
|
*set = this_core->current_process->pending_signals;
|
|
return 0;
|
|
}
|
|
|
|
long sys_sigprocmask(int how, sigset_t *restrict set, sigset_t * restrict oset) {
|
|
if (oset) {
|
|
PTRCHECK(oset,sizeof(sigset_t),MMU_PTR_WRITE);
|
|
*oset = this_core->current_process->blocked_signals;
|
|
}
|
|
|
|
if (set) {
|
|
PTRCHECK(set,sizeof(sigset_t),0);
|
|
switch (how) {
|
|
case SIG_SETMASK:
|
|
this_core->current_process->blocked_signals = *set;
|
|
break;
|
|
case SIG_BLOCK:
|
|
this_core->current_process->blocked_signals |= *set;
|
|
break;
|
|
case SIG_UNBLOCK:
|
|
this_core->current_process->blocked_signals &= ~*set;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
long sys_sigsuspend_cur(void) {
|
|
switch_task(0);
|
|
return -EINTR;
|
|
}
|
|
|
|
long sys_sigwait(sigset_t * set, int * sig) {
|
|
PTRCHECK(set,sizeof(sigset_t),0);
|
|
PTRCHECK(sig,sizeof(int),MMU_PTR_WRITE);
|
|
|
|
/* Silently ignore attempts to wait on KILL or STOP */
|
|
sigset_t awaited = *set & ~((1 << SIGKILL) | (1 << SIGSTOP));
|
|
|
|
/* Don't let processes wait on unblocked signals */
|
|
if (awaited & ~this_core->current_process->blocked_signals) return -EINVAL;
|
|
|
|
return signal_await(awaited, sig);
|
|
}
|
|
|
|
long sys_fswait(int c, int fds[]) {
|
|
PTR_VALIDATE(fds);
|
|
if (!fds || c < 0) return -EFAULT;
|
|
for (int i = 0; i < c; ++i) {
|
|
if (!FD_CHECK(fds[i])) return -EBADF;
|
|
}
|
|
fs_node_t ** nodes = malloc(sizeof(fs_node_t *)*(c+1));
|
|
for (int i = 0; i < c; ++i) {
|
|
nodes[i] = FD_ENTRY(fds[i]);
|
|
}
|
|
nodes[c] = NULL;
|
|
|
|
int result = process_wait_nodes((process_t *)this_core->current_process, nodes, -1);
|
|
free(nodes);
|
|
return result;
|
|
}
|
|
|
|
long sys_fswait_timeout(int c, int fds[], int timeout) {
|
|
PTR_VALIDATE(fds);
|
|
if (!fds || c < 0) return -EFAULT;
|
|
for (int i = 0; i < c; ++i) {
|
|
if (!FD_CHECK(fds[i])) return -EBADF;
|
|
}
|
|
fs_node_t ** nodes = malloc(sizeof(fs_node_t *)*(c+1));
|
|
for (int i = 0; i < c; ++i) {
|
|
nodes[i] = FD_ENTRY(fds[i]);
|
|
}
|
|
nodes[c] = NULL;
|
|
|
|
int result = process_wait_nodes((process_t *)this_core->current_process, nodes, timeout);
|
|
free(nodes);
|
|
return result;
|
|
}
|
|
|
|
long sys_fswait_multi(int c, int fds[], int timeout, int out[]) {
|
|
PTR_VALIDATE(fds);
|
|
PTR_VALIDATE(out);
|
|
if (!fds || !out || c < 0) return -EFAULT;
|
|
int has_match = -1;
|
|
for (int i = 0; i < c; ++i) {
|
|
if (!FD_CHECK(fds[i])) {
|
|
return -EBADF;
|
|
}
|
|
if (selectcheck_fs(FD_ENTRY(fds[i])) == 0) {
|
|
out[i] = 1;
|
|
has_match = (has_match == -1) ? i : has_match;
|
|
} else {
|
|
out[i] = 0;
|
|
}
|
|
}
|
|
|
|
/* Already found a match, return immediately with the first match */
|
|
if (has_match != -1) return has_match;
|
|
|
|
int result = sys_fswait_timeout(c, fds, timeout);
|
|
if (result >= 0 && result < c) out[result] = 1;
|
|
return result;
|
|
}
|
|
|
|
long sys_shm_obtain(char * path, size_t * size) {
|
|
PTR_VALIDATE(path);
|
|
PTR_VALIDATE(size);
|
|
if (!path || !size) return -EFAULT;
|
|
return (long)shm_obtain(path, size);
|
|
}
|
|
|
|
long sys_shm_release(char * path) {
|
|
PTR_VALIDATE(path);
|
|
if (!path) return -EFAULT;
|
|
return shm_release(path);
|
|
}
|
|
|
|
long sys_openpty(int * master, int * slave, char * name, void * _ign0, void * size) {
|
|
/* We require a place to put these when we are done. */
|
|
if (!master || !slave) return -EINVAL;
|
|
if (master && !PTR_INRANGE(master)) return -EINVAL;
|
|
if (slave && !PTR_INRANGE(slave)) return -EINVAL;
|
|
if (size && !PTR_INRANGE(size)) return -EINVAL;
|
|
|
|
/* Create a new pseudo terminal */
|
|
fs_node_t * fs_master;
|
|
fs_node_t * fs_slave;
|
|
|
|
pty_create(size, &fs_master, &fs_slave);
|
|
|
|
/* Append the master and slave to the calling process */
|
|
*master = process_append_fd((process_t *)this_core->current_process, fs_master);
|
|
*slave = process_append_fd((process_t *)this_core->current_process, fs_slave);
|
|
|
|
FD_MODE(*master) = 03;
|
|
FD_MODE(*slave) = 03;
|
|
|
|
open_fs(fs_master, 0);
|
|
open_fs(fs_slave, 0);
|
|
|
|
/* Return success */
|
|
return 0;
|
|
}
|
|
|
|
long sys_kill(pid_t process, int signal) {
|
|
if (process < -1) {
|
|
return group_send_signal(-process, signal, 0);
|
|
} else if (process == 0) {
|
|
return group_send_signal(this_core->current_process->job, signal, 0);
|
|
} else {
|
|
return send_signal(process, signal, 0);
|
|
}
|
|
}
|
|
|
|
long sys_reboot(void) {
|
|
if (this_core->current_process->user != USER_ROOT_UID) {
|
|
return -EPERM;
|
|
}
|
|
|
|
return arch_reboot();
|
|
}
|
|
|
|
long sys_times(struct tms *buf) {
|
|
if (buf) {
|
|
PTR_VALIDATE(buf);
|
|
|
|
buf->tms_utime = (this_core->current_process->time_total - this_core->current_process->time_sys) / arch_cpu_mhz();
|
|
buf->tms_stime = this_core->current_process->time_sys / arch_cpu_mhz();
|
|
buf->tms_cutime = (this_core->current_process->time_children - this_core->current_process->time_sys_children) / arch_cpu_mhz();
|
|
buf->tms_cstime = this_core->current_process->time_sys_children / arch_cpu_mhz();
|
|
}
|
|
|
|
return arch_perf_timer() / arch_cpu_mhz();
|
|
}
|
|
|
|
extern long ptrace_handle(long,pid_t,void*,void*);
|
|
|
|
typedef long (*scall_func)(long,long,long,long,long);
|
|
|
|
static scall_func syscalls[] = {
|
|
/* System Call Table */
|
|
[SYS_EXT] = (scall_func)(uintptr_t)sys_exit,
|
|
[SYS_GETEUID] = (scall_func)(uintptr_t)sys_geteuid,
|
|
[SYS_OPEN] = (scall_func)(uintptr_t)sys_open,
|
|
[SYS_READ] = (scall_func)(uintptr_t)sys_read,
|
|
[SYS_WRITE] = (scall_func)(uintptr_t)sys_write,
|
|
[SYS_CLOSE] = (scall_func)(uintptr_t)sys_close,
|
|
[SYS_GETTIMEOFDAY] = (scall_func)(uintptr_t)sys_gettimeofday,
|
|
[SYS_GETPID] = (scall_func)(uintptr_t)sys_getpid,
|
|
[SYS_SBRK] = (scall_func)(uintptr_t)sys_sbrk,
|
|
[SYS_UNAME] = (scall_func)(uintptr_t)sys_uname,
|
|
[SYS_SEEK] = (scall_func)(uintptr_t)sys_seek,
|
|
[SYS_STAT] = (scall_func)(uintptr_t)sys_stat,
|
|
[SYS_GETUID] = (scall_func)(uintptr_t)sys_getuid,
|
|
[SYS_SETUID] = (scall_func)(uintptr_t)sys_setuid,
|
|
[SYS_READDIR] = (scall_func)(uintptr_t)sys_readdir,
|
|
[SYS_CHDIR] = (scall_func)(uintptr_t)sys_chdir,
|
|
[SYS_GETCWD] = (scall_func)(uintptr_t)sys_getcwd,
|
|
[SYS_SETHOSTNAME] = (scall_func)(uintptr_t)sys_sethostname,
|
|
[SYS_GETHOSTNAME] = (scall_func)(uintptr_t)sys_gethostname,
|
|
[SYS_MKDIR] = (scall_func)(uintptr_t)sys_mkdir,
|
|
[SYS_GETTID] = (scall_func)(uintptr_t)sys_gettid,
|
|
[SYS_SYSFUNC] = (scall_func)(uintptr_t)sys_sysfunc,
|
|
[SYS_IOCTL] = (scall_func)(uintptr_t)sys_ioctl,
|
|
[SYS_ACCESS] = (scall_func)(uintptr_t)sys_access,
|
|
[SYS_STATF] = (scall_func)(uintptr_t)sys_statf,
|
|
[SYS_CHMOD] = (scall_func)(uintptr_t)sys_chmod,
|
|
[SYS_UMASK] = (scall_func)(uintptr_t)sys_umask,
|
|
[SYS_UNLINK] = (scall_func)(uintptr_t)sys_unlink,
|
|
[SYS_MOUNT] = (scall_func)(uintptr_t)sys_mount,
|
|
[SYS_SYMLINK] = (scall_func)(uintptr_t)sys_symlink,
|
|
[SYS_READLINK] = (scall_func)(uintptr_t)sys_readlink,
|
|
[SYS_LSTAT] = (scall_func)(uintptr_t)sys_lstat,
|
|
[SYS_CHOWN] = (scall_func)(uintptr_t)sys_chown,
|
|
[SYS_SETSID] = (scall_func)(uintptr_t)sys_setsid,
|
|
[SYS_SETPGID] = (scall_func)(uintptr_t)sys_setpgid,
|
|
[SYS_GETPGID] = (scall_func)(uintptr_t)sys_getpgid,
|
|
[SYS_DUP2] = (scall_func)(uintptr_t)sys_dup2,
|
|
[SYS_EXECVE] = (scall_func)(uintptr_t)sys_execve,
|
|
[SYS_FORK] = (scall_func)(uintptr_t)sys_fork,
|
|
[SYS_WAITPID] = (scall_func)(uintptr_t)sys_waitpid,
|
|
[SYS_YIELD] = (scall_func)(uintptr_t)sys_yield,
|
|
[SYS_SLEEPABS] = (scall_func)(uintptr_t)sys_sleepabs,
|
|
[SYS_SLEEP] = (scall_func)(uintptr_t)sys_sleep,
|
|
[SYS_PIPE] = (scall_func)(uintptr_t)sys_pipe,
|
|
[SYS_FSWAIT] = (scall_func)(uintptr_t)sys_fswait,
|
|
[SYS_FSWAIT2] = (scall_func)(uintptr_t)sys_fswait_timeout,
|
|
[SYS_FSWAIT3] = (scall_func)(uintptr_t)sys_fswait_multi,
|
|
[SYS_CLONE] = (scall_func)(uintptr_t)sys_clone,
|
|
[SYS_OPENPTY] = (scall_func)(uintptr_t)sys_openpty,
|
|
[SYS_SHM_OBTAIN] = (scall_func)(uintptr_t)sys_shm_obtain,
|
|
[SYS_SHM_RELEASE] = (scall_func)(uintptr_t)sys_shm_release,
|
|
[SYS_SIGNAL] = (scall_func)(uintptr_t)sys_signal,
|
|
[SYS_KILL] = (scall_func)(uintptr_t)sys_kill,
|
|
[SYS_REBOOT] = (scall_func)(uintptr_t)sys_reboot,
|
|
[SYS_GETGID] = (scall_func)(uintptr_t)sys_getgid,
|
|
[SYS_GETEGID] = (scall_func)(uintptr_t)sys_getegid,
|
|
[SYS_SETGID] = (scall_func)(uintptr_t)sys_setgid,
|
|
[SYS_GETGROUPS] = (scall_func)(uintptr_t)sys_getgroups,
|
|
[SYS_SETGROUPS] = (scall_func)(uintptr_t)sys_setgroups,
|
|
[SYS_TIMES] = (scall_func)(uintptr_t)sys_times,
|
|
[SYS_PTRACE] = (scall_func)(uintptr_t)ptrace_handle,
|
|
[SYS_SETTIMEOFDAY] = (scall_func)(uintptr_t)sys_settimeofday,
|
|
[SYS_SIGACTION] = (scall_func)(uintptr_t)sys_sigaction,
|
|
[SYS_SIGPENDING] = (scall_func)(uintptr_t)sys_sigpending,
|
|
[SYS_SIGPROCMASK] = (scall_func)(uintptr_t)sys_sigprocmask,
|
|
[SYS_SIGSUSPEND] = (scall_func)(uintptr_t)sys_sigsuspend_cur,
|
|
[SYS_SIGWAIT] = (scall_func)(uintptr_t)sys_sigwait,
|
|
[SYS_PREAD] = (scall_func)(uintptr_t)sys_pread,
|
|
[SYS_PWRITE] = (scall_func)(uintptr_t)sys_pwrite,
|
|
|
|
[SYS_SOCKET] = (scall_func)(uintptr_t)net_socket,
|
|
[SYS_SETSOCKOPT] = (scall_func)(uintptr_t)net_setsockopt,
|
|
[SYS_BIND] = (scall_func)(uintptr_t)net_bind,
|
|
[SYS_ACCEPT] = (scall_func)(uintptr_t)net_accept,
|
|
[SYS_LISTEN] = (scall_func)(uintptr_t)net_listen,
|
|
[SYS_CONNECT] = (scall_func)(uintptr_t)net_connect,
|
|
[SYS_GETSOCKOPT] = (scall_func)(uintptr_t)net_getsockopt,
|
|
[SYS_RECV] = (scall_func)(uintptr_t)net_recv,
|
|
[SYS_SEND] = (scall_func)(uintptr_t)net_send,
|
|
[SYS_SHUTDOWN] = (scall_func)(uintptr_t)net_shutdown,
|
|
[SYS_GETSOCKNAME] = (scall_func)(uintptr_t)net_getsockname,
|
|
[SYS_GETPEERNAME] = (scall_func)(uintptr_t)net_getpeername,
|
|
};
|
|
|
|
static long num_syscalls = sizeof(syscalls) / sizeof(*syscalls);
|
|
|
|
void syscall_handler(struct regs * r) {
|
|
|
|
this_core->current_process->syscall_registers = r;
|
|
|
|
if (this_core->current_process->flags & PROC_FLAG_TRACE_SYSCALLS) {
|
|
ptrace_signal(SIGTRAP, PTRACE_EVENT_SYSCALL_ENTER);
|
|
}
|
|
|
|
long result;
|
|
|
|
if (arch_syscall_number(r) >= num_syscalls) {
|
|
result = -EINVAL;
|
|
goto _finish_syscall;
|
|
}
|
|
|
|
scall_func func = syscalls[arch_syscall_number(r)];
|
|
result = func(
|
|
arch_syscall_arg0(r), arch_syscall_arg1(r), arch_syscall_arg2(r),
|
|
arch_syscall_arg3(r), arch_syscall_arg4(r));
|
|
|
|
if (result == -ERESTARTSYS) {
|
|
this_core->current_process->interrupted_system_call = arch_syscall_number(r);
|
|
}
|
|
|
|
_finish_syscall:
|
|
arch_syscall_return(r, result);
|
|
|
|
if (this_core->current_process->flags & PROC_FLAG_TRACE_SYSCALLS) {
|
|
ptrace_signal(SIGTRAP, PTRACE_EVENT_SYSCALL_EXIT);
|
|
}
|
|
}
|