forked from AbleOS/ableos
140 lines
3.6 KiB
Rust
140 lines
3.6 KiB
Rust
#![allow(clippy::empty_loop)]
|
|
|
|
use x86_64::instructions::interrupts::{disable, enable};
|
|
|
|
use crate::{boot_conf::KernelConfig, scratchpad};
|
|
|
|
use {
|
|
crate::{
|
|
arch::{init, sloop},
|
|
capabilities::FileAccess,
|
|
experiments::{
|
|
info::master,
|
|
systeminfo::{KERNEL_VERSION, RELEASE_TYPE},
|
|
},
|
|
file::PathRep,
|
|
relib::network::socket::{SimpleSock, Socket},
|
|
scheduler::SCHEDULER,
|
|
VgaBuffer, SCREEN_BUFFER,
|
|
},
|
|
facepalm::start_facepalm,
|
|
lazy_static::lazy_static,
|
|
shadeable::pixel_format::from_vga_16,
|
|
vga::colors::Color16,
|
|
};
|
|
|
|
lazy_static! {
|
|
// TODO: Change this structure to allow for multiple cores loaded
|
|
pub static ref KERNEL_CONF: KernelConfig = KernelConfig::new();
|
|
}
|
|
|
|
/// The main entry point of the kernel
|
|
#[no_mangle]
|
|
pub fn kernel_main() -> ! {
|
|
init::init();
|
|
|
|
if KERNEL_CONF.logging.enabled {
|
|
log::set_max_level(KERNEL_CONF.log_level());
|
|
} else {
|
|
log::set_max_level(log::LevelFilter::Off);
|
|
}
|
|
|
|
let mut scheduler = SCHEDULER.lock();
|
|
|
|
use crate::scheduler::Priority::*;
|
|
let mut process_1 = scheduler.new_process(High);
|
|
process_1.capabilities.files = FileAccess::Some(vec![PathRep {
|
|
location: FileLocations::Home,
|
|
file_name: "test".to_string(),
|
|
}]);
|
|
scheduler.add_process(process_1);
|
|
for ref_process in &scheduler.list {
|
|
trace!("{:?}", ref_process);
|
|
}
|
|
drop(scheduler);
|
|
|
|
use crate::proto_filetable::file::FileLocations;
|
|
|
|
if false {
|
|
let mut sock_print_id = SimpleSock::new();
|
|
sock_print_id.register_protocol("Screen Printer".to_string());
|
|
sock_print_id.write(format!("🐑").into());
|
|
|
|
let mut mode = SCREEN_BUFFER.lock();
|
|
|
|
mode.force_redraw();
|
|
for current in (*String::from_utf8_lossy(&sock_print_id.peek().unwrap())).chars() {
|
|
mode.draw_char(0, 0, current, from_vga_16(Color16::Red));
|
|
}
|
|
mode.copy_to_buffer();
|
|
}
|
|
|
|
start_facepalm();
|
|
scratchpad();
|
|
|
|
if false {
|
|
disable();
|
|
let mut mode = SCREEN_BUFFER.lock();
|
|
mode.force_redraw();
|
|
|
|
mode.copy_to_buffer();
|
|
mode.clear();
|
|
|
|
mode.draw_char(0, 0, 'v', 0xff00ffff);
|
|
|
|
mode.copy_to_buffer();
|
|
drop(mode);
|
|
enable()
|
|
// sloop::halt();
|
|
}
|
|
|
|
sloop()
|
|
}
|
|
|
|
pub fn cpu_socket_startup() {
|
|
let mut cpu_info_socket = SimpleSock::new();
|
|
cpu_info_socket.register_protocol("CPU_INFO".to_string());
|
|
|
|
let x = master().unwrap();
|
|
let _xyz = x.brand_string().unwrap();
|
|
}
|
|
|
|
pub fn log_version_data() {
|
|
info!("{} v{}", RELEASE_TYPE, KERNEL_VERSION);
|
|
info!(
|
|
"Brand String: {}",
|
|
master().unwrap().brand_string().unwrap()
|
|
);
|
|
}
|
|
// TODO: Split up into the randomness and the password generation
|
|
pub fn generate_process_pass() -> u128 {
|
|
// TODO: Move this into entropy_pool module
|
|
use rdrand::RdRand;
|
|
let gen = RdRand::new().unwrap();
|
|
|
|
// TODO: Split off into process module
|
|
let ret = (gen.try_next_u64().unwrap() as u128) << 64 | (gen.try_next_u64().unwrap() as u128);
|
|
ret
|
|
}
|
|
|
|
// TODO: move to a better place
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub struct AcpiStruct {}
|
|
|
|
impl acpi::AcpiHandler for AcpiStruct {
|
|
unsafe fn map_physical_region<T>(
|
|
&self,
|
|
physical_address: usize,
|
|
size: usize,
|
|
) -> acpi::PhysicalMapping<Self, T> {
|
|
info!("PHYS ADDR: {:?}", physical_address);
|
|
info!("Size: {:?}", size);
|
|
|
|
todo!("map_physical_region");
|
|
}
|
|
|
|
fn unmap_physical_region<T>(_region: &acpi::PhysicalMapping<Self, T>) {
|
|
todo!("unmap_physical_region");
|
|
}
|
|
}
|