yggdrasil/kernel/src/syscall/imp/mod.rs

use core::mem::MaybeUninit;

pub(crate) use abi::{
    error::Error,
    io::{
        DirectoryEntry, FileAttr, FileMode, MountOptions, OpenOptions, PipeOptions, PollControl,
        RawFd, TerminalOptions, TerminalSize, TimerOptions, UnmountOptions,
    },
    mem::{MappingFlags, MappingSource},
    net::SocketType,
    process::{Signal, SignalEntryData, SpawnOptions, WaitFlags},
    system::SystemInfo,
};
use abi::{
    path::Path,
    process::{ExecveOptions, ProcessId},
    time::{ClockType, SystemTime},
};
use device_api::timer::RealTimeProviderDevice;
use libk::{module, random, task::thread::Thread};
use libk_device::monotonic_timestamp_provider;
use libk_mm::phys;

use crate::{device::timer::GLOBAL_TIME, fs};

use super::run_with_io;

pub(super) mod sys_debug;
pub(super) mod sys_io;
pub(super) mod sys_net;
pub(super) mod sys_process;

pub(super) use sys_debug::*;
pub(super) use sys_io::*;
pub(super) use sys_net::*;
pub(super) use sys_process::*;

// Misc
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();

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

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

pub(crate) fn get_clock(ty: ClockType, value: &mut MaybeUninit<SystemTime>) -> Result<(), Error> {
    let time = match ty {
        ClockType::RealTime => GLOBAL_TIME.real_timestamp()?,
        ClockType::Monotonic => {
            let time = monotonic_timestamp_provider().monotonic_timestamp()?;
            SystemTime {
                seconds: time.as_secs(),
                nanoseconds: time.subsec_nanos() as _,
            }
        }
    };
    value.write(time);
    Ok(())
}

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

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

    let file = run_with_io(&process, |mut io| {
        let path: &Path = path.as_ref();
        if !path.is_absolute() {
            return Err(Error::InvalidArgument);
        }
        io.ioctx_mut().open_executable(path)
    })?;

    module::load_and_execute(file)
}

// 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!()
}