Fennix/Kernel
1
0
Fork 0
mirror of https://github.com/Fennix-Project/Kernel.git synced 2025-07-11 07:19:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Updated kernel (tl;dr: improved filesystem, tasking, loading files, etc..)

Browse Source
This commit is contained in:
Alex
2023-02-06 19:35:44 +02:00
parent 640f6a412a
commit a592b85ce5
46 changed files with 3503 additions and 2412 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
SystemCalls/Native.cpp
View File

@ -1,5 +1,6 @@
#include <syscalls.hpp>
#include <memory.hpp>
#include <lock.hpp>
#include <debug.h>
@ -7,19 +8,54 @@
#include "../kernel.h"
#include "../../Userspace/libs/include/sysbase.h"
#include "../ipc.h"
NewLock(SyscallsLock);
using InterProcessCommunication::IPC;
using InterProcessCommunication::IPCID;
using Tasking::Token;
using Tasking::TTL;
using Tasking::TTL::Trusted;
using Tasking::TTL::TrustedByKernel;
using Tasking::TTL::UnknownTrustLevel;
using Tasking::TTL::Untrusted;
static inline bool CheckTrust(int TrustLevel)
{
// SmartTimeoutLock(SyscallsLock, 10000); - This is already done in the caller
Token token = TaskManager->GetCurrentThread()->Security.UniqueToken;
if (TaskManager->GetSecurityManager()->IsTokenTrusted(token, TrustLevel))
return true;
warn("Thread %s(%lld) tried to access a system call \"%s\" with insufficient trust level",
KernelSymbolTable->GetSymbolFromAddress((uintptr_t)__builtin_extract_return_addr(__builtin_return_address(0))), TaskManager->GetCurrentThread()->Name, TaskManager->GetCurrentThread()->ID);
debug("Token: token=%#lx, trust=%d", token, TaskManager->GetSecurityManager()->GetTokenTrustLevel(token));
return false;
}
static int sys_exit(SyscallsFrame *Frame, int code)
{
SmartTimeoutLock(SyscallsLock, 10000);
/* Allow everyone to exit */
if (!CheckTrust(TrustedByKernel | Trusted | Untrusted | UnknownTrustLevel))
return SYSCALL_ACCESS_DENIED;
trace("Userspace thread %s(%lld) exited with code %#llx", TaskManager->GetCurrentThread()->Name, TaskManager->GetCurrentThread()->ID, code);
TaskManager->GetCurrentThread()->ExitCode = code;
TaskManager->GetCurrentThread()->Status = Tasking::TaskStatus::Terminated;
UNUSED(Frame);
return 0;
return SYSCALL_OK;
}
static int sys_print(SyscallsFrame *Frame, char Char, int Index)
{
int ret = Display->Print(Char, Index, true);
SmartTimeoutLock(SyscallsLock, 10000);
/* Only trusted threads can write to the kernel console */
if (!CheckTrust(TrustedByKernel | Trusted))
return SYSCALL_ACCESS_DENIED;
char ret = Display->Print(Char, Index, true);
#ifdef DEBUG
Display->SetBuffer(Index);
#endif
@ -29,19 +65,43 @@ static int sys_print(SyscallsFrame *Frame, char Char, int Index)
static uintptr_t sys_request_pages(SyscallsFrame *Frame, size_t Count)
{
SmartTimeoutLock(SyscallsLock, 10000);
/* Allow everyone to request pages */
if (!CheckTrust(TrustedByKernel | Trusted | Untrusted))
return SYSCALL_ACCESS_DENIED;
UNUSED(Frame);
return (uintptr_t)TaskManager->GetCurrentThread()->Memory->RequestPages(Count);
return (uintptr_t)TaskManager->GetCurrentThread()->Memory->RequestPages(Count, true);
}
static int sys_free_pages(SyscallsFrame *Frame, uintptr_t Address, size_t Count)
{
SmartTimeoutLock(SyscallsLock, 10000);
/* Allow everyone to free pages */
if (!CheckTrust(TrustedByKernel | Trusted | Untrusted))
return SYSCALL_ACCESS_DENIED;
TaskManager->GetCurrentThread()->Memory->FreePages((void *)Address, Count);
UNUSED(Frame);
return 0;
return SYSCALL_OK;
}
static int sys_kernelctl(SyscallsFrame *Frame, int Command, uint64_t Arg1, uint64_t Arg2, uint64_t Arg3, uint64_t Arg4)
static int sys_detach_address(SyscallsFrame *Frame, uintptr_t Address)
{
SmartTimeoutLock(SyscallsLock, 10000);
/* Only trusted threads can detach allocated addresses */
if (!CheckTrust(TrustedByKernel | Trusted))
return SYSCALL_ACCESS_DENIED;
TaskManager->GetCurrentThread()->Memory->DetachAddress((void *)Address);
UNUSED(Frame);
return SYSCALL_OK;
}
static uintptr_t sys_kernelctl(SyscallsFrame *Frame, enum KCtl Command, uint64_t Arg1, uint64_t Arg2, uint64_t Arg3, uint64_t Arg4)
{
SmartTimeoutLock(SyscallsLock, 10000);
/* Only trusted threads can use kernelctl */
if (!CheckTrust(TrustedByKernel | Trusted))
return SYSCALL_ACCESS_DENIED;
switch (Command)
{
case KCTL_GET_PID:
@ -53,7 +113,7 @@ static int sys_kernelctl(SyscallsFrame *Frame, int Command, uint64_t Arg1, uint6
default:
{
warn("KernelCTL: Unknown command: %lld", Command);
return -1;
return SYSCALL_INVALID_ARGUMENT;
}
}
@ -62,121 +122,152 @@ static int sys_kernelctl(SyscallsFrame *Frame, int Command, uint64_t Arg1, uint6
UNUSED(Arg3);
UNUSED(Arg4);
UNUSED(Frame);
return -1;
}
static int sys_ipc(SyscallsFrame *Frame, int Command, int Type, int ID, int Flags, void *Buffer, size_t Size)
{
SmartTimeoutLock(SyscallsLock, 10000);
/* Allow everyone to use IPC */
if (!CheckTrust(TrustedByKernel | Trusted | Untrusted))
return SYSCALL_ACCESS_DENIED;
IPC *ipc = TaskManager->GetCurrentProcess()->IPC;
UNUSED(Frame);
return 0;
}
static int sys_file_open(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_file_open: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_file_close(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_file_close: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_file_read(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_file_read: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_file_write(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_file_write: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_file_seek(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_file_seek: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_file_status(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_file_status: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_wait(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_wait: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_kill(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_kill: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_spawn(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_spawn: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_spawn_thread(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_spawn_thread: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_get_thread_list_of_process(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_get_thread_list_of_process: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_get_current_process(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_get_current_process: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_get_current_thread(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_get_current_thread: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_get_process_by_pid(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_get_process_by_pid: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_get_thread_by_tid(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_get_thread_by_tid: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_kill_process(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_kill_process: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_kill_thread(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_kill_thread: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_sys_reserved_create_process(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_sys_reserved_create_process: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static int sys_sys_reserved_create_thread(SyscallsFrame *Frame)
{
SmartTimeoutLock(SyscallsLock, 10000);
fixme("sys_sys_reserved_create_thread: %#lx", Frame);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
static void *NativeSyscallsTable[] = {
@ -185,8 +276,10 @@ static void *NativeSyscallsTable[] = {
[_RequestPages] = (void *)sys_request_pages,
[_FreePages] = (void *)sys_free_pages,
[_DetachAddress] = (void *)sys_detach_address,
[_KernelCTL] = (void *)sys_kernelctl,
[_IPC] = (void *)sys_ipc,
[_FileOpen] = (void *)sys_file_open,
[_FileClose] = (void *)sys_file_close,
@ -217,14 +310,14 @@ uintptr_t HandleNativeSyscalls(SyscallsFrame *Frame)
if (Frame->rax > sizeof(NativeSyscallsTable))
{
fixme("Syscall %lld not implemented", Frame->rax);
return -1;
return SYSCALL_NOT_IMPLEMENTED;
}
uintptr_t (*call)(uintptr_t, ...) = reinterpret_cast<uintptr_t (*)(uintptr_t, ...)>(NativeSyscallsTable[Frame->rax]);
if (!call)
{
error("Syscall %#llx failed.", Frame->rax);
return -1;
return SYSCALL_INTERNAL_ERROR;
}
debug("[%#lx]->( %#lx %#lx %#lx %#lx %#lx %#lx )", Frame->rax, Frame->rdi, Frame->rsi, Frame->rdx, Frame->rcx, Frame->r8, Frame->r9);
uintptr_t ret = call((uintptr_t)Frame, Frame->rdi, Frame->rsi, Frame->rdx, Frame->r10, Frame->r8, Frame->r9);