yggdrasil/src/main.rs

//! osdev-x kernel crate
#![feature(
    naked_functions,
    asm_const,
    panic_info_message,
    optimize_attribute,
    const_trait_impl,
    maybe_uninit_slice,
    arbitrary_self_types,
    const_mut_refs,
    let_chains
)]
#![allow(clippy::new_without_default)]
#![warn(missing_docs)]
#![no_std]
#![no_main]

extern crate yggdrasil_abi as abi;
//
// use abi::{
//     error::Error,
//     io::{FileMode, OpenOptions, RawFd},
//     process::ExitCode,
// };
// use fs::{devfs, FileBlockAllocator, INITRD_DATA};
// use memfs::MemoryFilesystem;
// use task::process::Process;
// use vfs::{Filesystem, IoContext, VnodeRef};
//
// extern crate alloc;
//
#[macro_use]
pub mod debug;
#[macro_use]
pub mod arch;

#[panic_handler]
fn panic_handler(_pi: &core::panic::PanicInfo) -> ! {
    loop {}
}
//
pub mod device;
// pub mod fs;
pub mod mem;
// pub mod panic;
// pub mod proc;
pub mod sync;
// pub mod syscall;
// pub mod task;
pub mod util;
//
// fn setup_root() -> Result<VnodeRef, Error> {
//     let initrd_data = INITRD_DATA.get();
//     let fs = MemoryFilesystem::<FileBlockAllocator>::from_slice(initrd_data.data).unwrap();
//     fs.root()
// }
//
// /// Entry point for common kernel code.
// ///
// /// # Note
// ///
// /// This function is meant to be used as a kernel-space process after all the platform-specific
// /// initialization has finished.
// pub fn kernel_main() {
//     // use crate::{debug::LogLevel, mem::phys};
//     // use crate::task::tasklet::{self, TaskFlow};
//     // use core::time::Duration;
//
//     // Schedule a tasklet to print memory usage stats every 10 seconds
//     // tasklet::add_periodic("mem-stats", Duration::from_secs(3), || {
//     //     let phys_mem = phys::PHYSICAL_MEMORY.get().lock();
//     //     let stats = phys_mem.stats();
//     //     stats.dump(LogLevel::Debug);
//
//     //     TaskFlow::Continue
//     // });
//
//     let root = match setup_root() {
//         Ok(root) => root,
//         Err(err) => {
//             warnln!("Could not setup root from initrd: {:?}", err);
//             return;
//         }
//     };
//
//     let ioctx = IoContext::new(root);
//     let node = ioctx.find(None, "/init", true, true).unwrap();
//     let file = node.open(OpenOptions::READ, FileMode::empty()).unwrap();
//
//     let devfs = devfs::root();
//     let console = ioctx
//         .find(Some(devfs.clone()), "ttyS0", true, true)
//         .unwrap();
//     let stdin = console.open(OpenOptions::READ, FileMode::empty()).unwrap();
//     let stdout = console.open(OpenOptions::WRITE, FileMode::empty()).unwrap();
//     let stderr = stdout.clone();
//
//     {
//         let user_init = proc::exec::load_elf(file, &["/init", "xxx"]).unwrap();
//         let mut io = user_init.io.lock();
//         io.set_ioctx(ioctx);
//         io.set_file(RawFd::STDIN, stdin).unwrap();
//         io.set_file(RawFd::STDOUT, stdout).unwrap();
//         io.set_file(RawFd::STDERR, stderr).unwrap();
//         drop(io);
//
//         user_init.set_session_terminal(console);
//
//         user_init.enqueue_somewhere();
//     }
//
//     Process::current().exit(ExitCode::SUCCESS);
// }