105 lines
2.5 KiB
Rust
105 lines
2.5 KiB
Rust
use core::mem::MaybeUninit;
|
|
|
|
pub(crate) use abi::{
|
|
error::Error,
|
|
io::{
|
|
AccessMode, 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 libk::{
|
|
module, random,
|
|
task::thread::Thread,
|
|
time::{monotonic_time, real_time},
|
|
};
|
|
use libk_mm::phys;
|
|
|
|
use crate::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_unsecure(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 => real_time(),
|
|
ClockType::Monotonic => monotonic_time(),
|
|
};
|
|
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!()
|
|
}
|