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,
    linked_list_cursors
)]
#![allow(clippy::new_without_default, clippy::fn_to_numeric_cast)]
#![warn(missing_docs)]
#![no_std]
#![no_main]

use abi::{
    error::Error,
    io::{FileMode, OpenOptions, RawFd},
};
use fs::{devfs, FileBlockAllocator, INITRD_DATA};
use memfs::MemoryFilesystem;
use vfs::{Filesystem, IoContext, VnodeRef};

extern crate yggdrasil_abi as abi;

extern crate alloc;

#[macro_use]
pub mod debug;
#[macro_use]
pub mod arch;

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() {
    infoln!("In main");

    #[cfg(feature = "fb_console")]
    {
        use core::time::Duration;

        use device::display::console::task_update_consoles;
        use task::tasklet;

        tasklet::add_periodic(
            "update-console",
            Duration::from_millis(15),
            task_update_consoles,
        );
    }

    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();
    #[cfg(target_arch = "x86_64")]
    let console = ioctx.find(Some(devfs.clone()), "tty0", true, true).unwrap();
    #[cfg(target_arch = "aarch64")]
    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("init", 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();
    }
}