yggdrasil/kernel/src/syscall/mod.rs

//! System function call handlers

use abi::{error::Error, io::RawFd, SyscallFunction};
use libk_util::sync::IrqSafeSpinlockGuard;
use vfs::NodeRef;

use crate::{proc::io::ProcessIoImpl, task::process::ProcessImpl};

mod arg;

fn run_with_io<T, F: FnOnce(IrqSafeSpinlockGuard<ProcessIoImpl>) -> T>(
    proc: &ProcessImpl,
    f: F,
) -> T {
    let io = proc.io.lock();
    f(io)
}

fn run_with_io_at<
    T,
    F: FnOnce(NodeRef, IrqSafeSpinlockGuard<ProcessIoImpl>) -> Result<T, Error>,
>(
    proc: &ProcessImpl,
    at: Option<RawFd>,
    f: F,
) -> Result<T, Error> {
    let mut io = proc.io.lock();
    let at = at
        .map(|fd| {
            io.files
                .file(fd)
                .and_then(|f| f.node().ok_or(Error::InvalidFile).cloned())
        })
        .transpose()?
        // at = None
        .unwrap_or_else(|| io.ioctx_mut().cwd().clone());

    f(at, io)
}

mod impls {
    pub(crate) use abi::{
        error::Error,
        io::{
            DeviceRequest, DirectoryEntry, FileAttr, FileMetadataUpdate, FileMode,
            MessageDestination, MountOptions, OpenOptions, PollControl, RawFd,
            ReceivedMessageMetadata, SeekFrom, SentMessage, TerminalOptions, TerminalSize,
            UnmountOptions,
        },
        mem::MappingSource,
        net::{SocketOption, SocketType},
        process::{ExitCode, MutexOperation, Signal, SignalEntryData, SpawnOptions},
        system::SystemInfo,
    };
    use abi::{
        io::ChannelPublisherId,
        process::{ExecveOptions, ProcessId, SpawnOption},
    };
    use alloc::{boxed::Box, sync::Arc};
    use libk::{block, runtime};
    use vfs::{File, IoContext, MessagePayload, Read, Seek, Write};
    use ygg_driver_net_core::socket::{RawSocket, TcpListener, TcpSocket, UdpSocket};

    use core::{
        mem::MaybeUninit, net::SocketAddr, num::NonZeroUsize, sync::atomic::AtomicU32,
        time::Duration,
    };

    use libk_mm::{
        phys,
        process::VirtualRangeBacking,
        table::{EntryLevelExt, MapAttributes},
    };
    use libk_thread::{
        process::{Process, ProcessManager},
        thread::Thread,
    };

    use crate::{
        arch::L3,
        debug::LogLevel,
        fs,
        proc::{self, random},
        task::process::ProcessManagerImpl,
    };

    use super::{run_with_io, run_with_io_at};

    // Misc
    pub(crate) fn debug_trace(message: &str) {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        log_print_raw!(
            LogLevel::Debug,
            "[{}:{}] TRACE: {}\n",
            process.id(),
            thread.id,
            message
        );
    }

    pub(crate) fn get_random(buffer: &mut [u8]) {
        random::read(buffer);
    }

    pub(crate) fn mount(options: &MountOptions<'_>) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let fs_root = fs::create_filesystem(options)?;
            io.ioctx_mut().mount(options.target, fs_root)?;
            Ok(())
        })
    }

    pub(crate) fn unmount(_options: &UnmountOptions) -> Result<(), Error> {
        todo!()
    }

    // Memory management
    pub(crate) fn map_memory(
        _hint: Option<NonZeroUsize>,
        len: usize,
        source: &MappingSource,
    ) -> Result<usize, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        let space = thread.address_space();

        let len = len.page_align_up::<L3>();

        run_with_io(&process, |io| {
            let backing = match source {
                MappingSource::Anonymous => VirtualRangeBacking::anonymous(),
                &MappingSource::File(fd, offset) => {
                    let file = io.files.file(fd)?;
                    VirtualRangeBacking::file(offset, file.clone())?
                }
            };

            space.allocate(
                None,
                len,
                backing,
                MapAttributes::USER_WRITE | MapAttributes::USER_READ | MapAttributes::NON_GLOBAL,
            )
        })
    }

    pub(crate) fn unmap_memory(address: usize, len: usize) -> Result<(), Error> {
        let thread = Thread::current();
        let space = thread.address_space();

        if len & 0xFFF != 0 {
            todo!();
        }

        unsafe {
            space.unmap(address, len)?;
        }

        Ok(())
    }

    pub(crate) fn get_system_info(element: &mut SystemInfo) -> Result<(), Error> {
        match element {
            SystemInfo::MemoryStats(stats) => {
                *stats = phys::stats();
                Ok(())
            }
        }
    }

    // Process/thread management
    pub(crate) fn exit_process(code: ExitCode) -> ! {
        let thread = Thread::current();
        thread.exit_process::<ProcessManagerImpl>(code)
    }

    pub(crate) fn spawn_process(options: &SpawnOptions<'_>) -> Result<ProcessId, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            // Setup a new process from the file
            let (child_process, child_main) = proc::load_binary(
                io.ioctx_mut(),
                Some(Arc::downgrade(&process)),
                options.program,
                options.arguments,
                options.environment,
            )?;
            let pid = child_process.id();

            // Inherit group and session from the creator
            child_process.inherit(&process)?;

            // Inherit root from the creator
            // let child_ioctx = IoContext::new(io.ioctx().root().clone());
            let child_ioctx = IoContext::inherit(io.ioctx_mut());
            let mut child_io = child_process.io.lock();
            child_io.set_ioctx(child_ioctx);

            for opt in options.optional {
                match opt {
                    &SpawnOption::InheritFile { source, child } => {
                        if let Ok(src_file) = io.files.file(source) {
                            child_io.files.set_file(child, src_file.clone())?;
                        }
                    }
                    &SpawnOption::SetProcessGroup(pgroup) => {
                        let pgroup = if pgroup.into_raw() == 0 {
                            child_process.id()
                        } else {
                            pgroup
                        };
                        child_process.set_group_id(pgroup);
                    }
                    _ => (),
                }
            }

            if let Some(fd) = options.optional.iter().find_map(|item| {
                if let &SpawnOption::GainTerminal(fd) = item {
                    Some(fd)
                } else {
                    None
                }
            }) {
                debugln!("{} requested terminal {:?}", pid, fd);
                let file = child_io.files.file(fd)?;
                // let node = file.node().ok_or(Error::InvalidFile)?;
                let mut req = DeviceRequest::SetTerminalGroup(child_process.group_id());
                file.device_request(&mut req)?;

                if let Some(node) = file.node() {
                    child_process.set_session_terminal(node.clone());
                }
                // node.device_request(&mut req)?;
            }

            drop(child_io);
            child_main.enqueue();

            Ok(pid as _)
        })
    }

    pub(crate) fn wait_process(pid: ProcessId, status: &mut ExitCode) -> Result<(), Error> {
        let target = ProcessManagerImpl::get(pid).ok_or(Error::DoesNotExist)?;
        *status = block!(target.wait_for_exit().await)?;
        Ok(())
    }

    pub(crate) fn get_pid() -> ProcessId {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();
        process.id()
    }

    pub(crate) fn nanosleep(duration: &Duration) {
        block! {
            runtime::sleep(*duration).await
        }
        .unwrap();
    }

    pub(crate) fn set_signal_entry(ip: usize, sp: usize) {
        let thread = Thread::current();
        thread.set_signal_entry(ip, sp);
    }

    pub(crate) fn send_signal(pid: ProcessId, signal: Signal) -> Result<(), Error> {
        let target = ProcessManagerImpl::get(pid).ok_or(Error::DoesNotExist)?;
        target.raise_signal(signal);
        Ok(())
    }

    pub(crate) fn mutex(mutex: &AtomicU32, op: &MutexOperation) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        let mutex = process.get_or_insert_mutex((mutex as *const AtomicU32).addr());

        match op {
            &MutexOperation::Wait(value, _timeout) => block! { mutex.wait(value).await }.unwrap(),
            MutexOperation::Wake => mutex.wake(),
            MutexOperation::WakeAll => mutex.wake_all(),
        }

        Ok(())
    }

    pub(crate) fn start_session() -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        let session_terminal = process.clear_session_terminal();

        if let Some(ctty) = session_terminal {
            // Drop all FDs referring to the old session terminal
            run_with_io(&process, |mut io| {
                io.files.retain(|_, f| {
                    f.node()
                        .map(|node| !Arc::ptr_eq(node, &ctty))
                        .unwrap_or(true)
                });
            });
        }

        process.set_session_id(process.id());
        process.set_group_id(process.id());

        Ok(())
    }

    // I/O
    pub(crate) fn open(
        at: Option<RawFd>,
        path: &str,
        opts: OpenOptions,
        mode: FileMode,
    ) -> Result<RawFd, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io_at(&process, at, |at, mut io| {
            let file = io.ioctx_mut().open(Some(at), path, opts, mode)?;

            // TODO NO_CTTY?
            if process.session_terminal().is_none()
                && let Some(node) = file.node()
                && node.is_terminal()
            {
                debugln!("Session terminal set for #{}: {}", process.id(), path);
                process.set_session_terminal(node.clone());
            }

            let fd = io.files.place_file(file, true)?;
            Ok(fd)
        })
    }

    pub(crate) fn close(fd: RawFd) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let res = io.files.close_file(fd);

            if res == Err(Error::InvalidFile) {
                warnln!("Double close of fd {:?} in process {}", fd, process.id());
            }

            res
        })
    }

    pub(crate) fn write(fd: RawFd, buffer: &[u8]) -> Result<usize, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |io| io.files.file(fd)?.write(buffer))
    }

    pub(crate) fn read(fd: RawFd, buffer: &mut [u8]) -> Result<usize, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |io| io.files.file(fd)?.read(buffer))
    }

    pub(crate) fn seek(fd: RawFd, pos: SeekFrom) -> Result<u64, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |io| io.files.file(fd)?.seek(pos))
    }

    pub(crate) fn open_directory(at: Option<RawFd>, path: &str) -> Result<RawFd, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io_at(&process, at, |at, mut io| {
            let node = io.ioctx_mut().find(Some(at), path, true, true)?;
            let access = io.ioctx_mut().check_access(vfs::Action::Read, &node)?;
            let file = node.open_directory(access)?;
            let fd = io.files.place_file(file, true)?;

            Ok(fd)
        })
    }

    pub(crate) fn read_directory_entries(
        fd: RawFd,
        entries: &mut [MaybeUninit<DirectoryEntry>],
    ) -> Result<usize, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |io| io.files.file(fd)?.read_dir(entries))
    }

    pub(crate) fn create_directory(
        at: Option<RawFd>,
        path: &str,
        mode: FileMode,
    ) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io_at(&process, at, |at, mut io| {
            io.ioctx_mut().create_directory(Some(at), path, mode)?;
            Ok(())
        })
    }

    pub(crate) fn remove_directory(_at: Option<RawFd>, _path: &str) -> Result<(), Error> {
        todo!()
    }

    pub(crate) fn remove(at: Option<RawFd>, path: &str) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io_at(&process, at, |at, mut io| {
            io.ioctx_mut().remove_file(Some(at), path)?;
            Ok(())
        })
    }

    pub(crate) fn clone_fd(source_fd: RawFd, target_fd: Option<RawFd>) -> Result<RawFd, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let file = io.files.file(source_fd)?.clone();

            let fd = match target_fd {
                Some(target_fd) => {
                    io.files.set_file(target_fd, file)?;
                    target_fd
                }
                None => io.files.place_file(file, true)?,
            };

            Ok(fd)
        })
    }

    pub(crate) fn update_metadata(
        at: Option<RawFd>,
        _path: &str,
        _update: &FileMetadataUpdate,
    ) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io_at(&process, at, |_at, _io| {
            todo!();
        })
    }

    pub(crate) fn get_metadata(
        at: Option<RawFd>,
        path: &str,
        buffer: &mut MaybeUninit<FileAttr>,
        follow: bool,
    ) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io_at(&process, at, |at, mut io| {
            let node = if path.is_empty() {
                at
                // at.ok_or(Error::InvalidArgument)?
            } else {
                io.ioctx_mut().find(Some(at), path, follow, true)?
            };

            let metadata = node.metadata()?;
            let size = node.size()?;

            buffer.write(FileAttr {
                size,
                ty: node.ty(),
                mode: metadata.mode,
                uid: metadata.uid,
                gid: metadata.gid,
            });

            Ok(())
        })
    }

    pub(crate) fn device_request(fd: RawFd, req: &mut DeviceRequest) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |io| io.files.file(fd)?.device_request(req))
    }

    // Misc I/O
    pub(crate) fn open_channel(name: &str, subscribe: bool) -> Result<RawFd, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let file = File::new_message_channel(name, subscribe);
            let fd = io.files.place_file(file, true)?;
            Ok(fd)
        })
    }

    pub(crate) fn create_timer(repeat: bool) -> Result<RawFd, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let file = File::new_timer(repeat);
            let fd = io.files.place_file(file, true)?;
            Ok(fd)
        })
    }

    pub(crate) fn create_pty(
        options: &TerminalOptions,
        size: &TerminalSize,
        output: &mut [MaybeUninit<RawFd>; 2],
    ) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let (master, slave) = File::new_pseudo_terminal(*options, *size)?;
            let master_fd = io.files.place_file(master, true)?;
            let slave_fd = io.files.place_file(slave, true)?;

            output[0].write(master_fd);
            output[1].write(slave_fd);

            Ok(())
        })
    }

    pub(crate) fn create_shared_memory(size: usize) -> Result<RawFd, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let file = File::new_shared_memory(size)?;
            let fd = io.files.place_file(file, true)?;
            Ok(fd)
        })
    }

    pub(crate) fn create_poll_channel() -> Result<RawFd, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let poll = File::new_poll_channel();
            let fd = io.files.place_file(poll, true)?;

            Ok(fd)
        })
    }

    pub(crate) fn create_pipe(ends: &mut [MaybeUninit<RawFd>; 2]) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let (read, write) = File::new_pipe_pair(256);

            let read_fd = io.files.place_file(read, true)?;
            let write_fd = io.files.place_file(write, true)?;

            ends[0].write(read_fd);
            ends[1].write(write_fd);

            Ok(())
        })
    }

    pub(crate) fn poll_channel_wait(
        poll_fd: RawFd,
        timeout: &Option<Duration>,
        output: &mut Option<(RawFd, Result<(), Error>)>,
    ) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |io| {
            let poll_file = io.files.file(poll_fd)?;
            let poll = poll_file.as_poll_channel()?;

            *output = block! {
                poll.wait(*timeout).await
            }?;

            Ok(())
        })
    }

    pub(crate) fn poll_channel_control(
        poll_fd: RawFd,
        control: PollControl,
        fd: RawFd,
    ) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |io| {
            let poll_file = io.files.file(poll_fd)?;
            let poll = poll_file.as_poll_channel()?;

            match control {
                PollControl::AddFd => {
                    let polled_file = io.files.file(fd)?.clone();
                    poll.add(fd, polled_file);
                }
            }

            Ok(())
        })
    }

    pub(crate) fn send_message(
        fd: RawFd,
        message: &SentMessage<'_>,
        destination: MessageDestination,
    ) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |io| {
            let file = io.files.file(fd)?;
            let channel = file.as_message_channel()?;

            match message {
                &SentMessage::File(fd) => {
                    let sent_file = io.files.file(fd)?;

                    channel.send_message(MessagePayload::File(sent_file.clone()), destination)?;
                }
                &SentMessage::Data(data) => {
                    channel.send_message(MessagePayload::Data(Box::from(data)), destination)?;
                }
            }

            Ok(())
        })
    }

    pub(crate) fn receive_message(
        fd: RawFd,
        metadata: &mut MaybeUninit<ReceivedMessageMetadata>,
        buf: &mut [u8],
        from: &mut MaybeUninit<ChannelPublisherId>,
    ) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let file = io.files.file(fd)?;
            let channel = file.as_message_channel()?;

            let message = channel.receive_message()?;

            from.write(message.source);

            match &message.payload {
                MessagePayload::Data(data) => {
                    // TODO allow truncated messages?
                    let len = data.len();
                    if buf.len() < len {
                        return Err(Error::MissingData);
                    }

                    metadata.write(ReceivedMessageMetadata::Data(len));
                    buf[..len].copy_from_slice(data);

                    Ok(())
                }
                MessagePayload::File(file) => {
                    let fd = io.files.place_file(file.clone(), true)?;

                    metadata.write(ReceivedMessageMetadata::File(fd));

                    Ok(())
                }
            }
        })
    }

    // Network
    pub(crate) fn connect_socket(
        socket_fd: Option<RawFd>,
        remote: &SocketAddr,
        ty: SocketType,
        local_result: &mut MaybeUninit<SocketAddr>,
    ) -> Result<RawFd, Error> {
        assert!(socket_fd.is_none());

        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let (local, file) = match ty {
                SocketType::TcpStream => {
                    let (local, socket) = TcpSocket::connect((*remote).into())?;
                    (local, File::from_stream_socket(socket))
                }
                _ => return Err(Error::InvalidArgument),
            };
            let fd = io.files.place_file(file, true)?;
            local_result.write(local.into());
            Ok(fd)
        })
    }

    pub(crate) fn bind_socket(listen: &SocketAddr, ty: SocketType) -> Result<RawFd, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let file = match ty {
                SocketType::UdpPacket => {
                    File::from_packet_socket(UdpSocket::bind((*listen).into())?)
                }
                SocketType::RawPacket => File::from_packet_socket(RawSocket::bind()?),
                SocketType::TcpStream => {
                    File::from_listener_socket(TcpListener::bind((*listen).into())?)
                }
            };
            let fd = io.files.place_file(file, true)?;
            Ok(fd)
        })
    }

    pub(crate) fn accept(
        socket_fd: RawFd,
        remote_result: &mut MaybeUninit<SocketAddr>,
    ) -> Result<RawFd, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |mut io| {
            let file = io.files.file(socket_fd)?;
            let mut remote = MaybeUninit::uninit();
            let accepted_file = file.accept(&mut remote)?;
            let accepted_fd = io.files.place_file(accepted_file, true)?;
            unsafe {
                remote_result.write(remote.assume_init().into());
            }
            Ok(accepted_fd)
        })
    }

    pub(crate) fn send_to(
        socket_fd: RawFd,
        buffer: &[u8],
        recepient: &Option<SocketAddr>,
    ) -> Result<usize, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |io| {
            let file = io.files.file(socket_fd)?;

            file.send_to(buffer, recepient.map(Into::into))
        })
    }

    pub(crate) fn receive_from(
        socket_fd: RawFd,
        buffer: &mut [u8],
        remote_result: &mut MaybeUninit<SocketAddr>,
    ) -> Result<usize, Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |io| {
            let file = io.files.file(socket_fd)?;
            let mut remote = MaybeUninit::uninit();
            let len = file.receive_from(buffer, &mut remote)?;
            remote_result.write(unsafe { remote.assume_init() }.into());
            Ok(len)
        })
    }

    pub(crate) fn set_socket_option(socket_fd: RawFd, option: &SocketOption) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |io| {
            let file = io.files.file(socket_fd)?;
            let socket = file.as_socket()?;
            socket.set_option(option)
        })
    }

    pub(crate) fn get_socket_option(
        socket_fd: RawFd,
        option: &mut SocketOption,
    ) -> Result<(), Error> {
        let thread = Thread::current();
        let process = thread.process::<ProcessManagerImpl>();

        run_with_io(&process, |io| {
            let file = io.files.file(socket_fd)?;
            let socket = file.as_socket()?;
            socket.get_option(option)
        })
    }

    // Handled outside
    pub(crate) fn exit_signal(_frame: &SignalEntryData) -> ! {
        unreachable!()
    }

    pub(crate) fn fork() -> Result<ProcessId, Error> {
        unreachable!()
    }

    pub(crate) fn execve(_options: &ExecveOptions<'_>) -> Result<(), Error> {
        unreachable!()
    }
}

mod generated {
    #![allow(unreachable_code)]

    use abi::{
        io::ChannelPublisherId,
        process::{ExecveOptions, ProcessId},
        SyscallFunction,
    };
    use abi_lib::SyscallRegister;

    use super::{
        arg,
        impls::{self, *},
    };

    include!(concat!(env!("OUT_DIR"), "/generated_dispatcher.rs"));
}

/// Entrypoint for system calls that takes raw argument values
pub fn raw_syscall_handler(func: u64, args: &[u64]) -> u64 {
    let Ok(func) = SyscallFunction::try_from(func as usize) else {
        todo!("Undefined syscall: {}", func);
    };
    let args = unsafe { core::mem::transmute(args) };

    let result = generated::handle_syscall(func, args);

    let value = match result {
        Ok(value) => value,
        Err(e) => (-(e as u32 as isize)) as usize,
    };

    value as _
}