JohnyTheCarrot/ableos
1
0
Fork 0
forked from AbleOS/ableos
Code Issues Pull requests Packages Projects Releases Wiki Activity

integrating logging fully

Browse source
This commit is contained in:
Able 2021-12-24 07:03:15 -06:00
parent 750f4e71b8
commit 5ba9d28f5d
10 changed files with 101 additions and 84 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
ableos/src/arch/x86_64/init.rs
View file

@ -1,11 +1,7 @@
#![allow(clippy::print_literal)]
use {
super::{gdt, interrupts},
crate::{
info,
log::{self, Log},
println,
},
crate::{info, println},
};
pub fn init() {

7
ableos/src/experiments/clip.rs
View file

@ -1,6 +1,6 @@
use crate::alloc::vec;
use crate::String;
use crate::Vec;
use alloc::{string::String, vec, vec::Vec};
// use crate::String;
// use crate::Vec;
use lazy_static::lazy_static;
#[derive(Debug)]
pub enum Mime {
@ -11,7 +11,6 @@ pub enum Mime {
lazy_static! {
pub static ref CLIPBOARD: spin::Mutex<Clipboard> = {
let clipboard = Clipboard::new();
spin::Mutex::new(clipboard)
};
}

65
ableos/src/experiments/mail.rs
View file

@ -1,5 +1,6 @@
#![allow(dead_code)]
use crate::serial_println;
use crate::trace;
pub struct MailBoxes {
flags: u8,
mailboxes: [u64; 4],
@ -51,22 +52,52 @@ impl MailBoxes {
}
}
pub fn dump_flags(&self) {
serial_println!("Flag 0: {:08b}", self.flags & 0b0000_0001);
serial_println!("Flag 1: {:08b}", self.flags & 0b0000_0010);
serial_println!("Flag 2: {:08b}", self.flags & 0b0000_0100);
serial_println!("Flag 3: {:08b}", self.flags & 0b0000_1000);
serial_println!("Flag 4: {:08b}", self.flags & 0b0001_0000);
serial_println!("Flag 5: {:08b}", self.flags & 0b0010_0000);
serial_println!("Flag 6: {:08b}", self.flags & 0b0100_0000);
serial_println!("Flag 7: {:08b}", self.flags & 0b1000_0000);
trace!(
"Flag 0: {:08b} | {}",
self.flags & 0b0000_0001,
self.flags & 0b0000_0001
);
serial_println!("Flag 0: {}", self.flags & 0b0000_0001);
serial_println!("Flag 1: {}", self.flags >> 1 & 0b0000_0001);
serial_println!("Flag 2: {}", self.flags >> 2 & 0b0000_0001);
serial_println!("Flag 3: {}", self.flags >> 3 & 0b0000_0001);
serial_println!("Flag 4: {}", self.flags >> 4 & 0b0000_0001);
serial_println!("Flag 5: {}", self.flags >> 5 & 0b0000_0001);
serial_println!("Flag 6: {}", self.flags >> 6 & 0b0000_0001);
serial_println!("Flag 7: {}", self.flags >> 7 & 0b0000_0001);
trace!(
"Flag 1: {:08b} | {}",
self.flags & 0b0000_0010,
self.flags >> 1 & 0b0000_0001
);
trace!(
"Flag 2: {:08b} | {}",
self.flags & 0b0000_0100,
self.flags >> 2 & 0b0000_0001
);
trace!(
"Flag 3: {:08b} | {}",
self.flags & 0b0000_1000,
self.flags >> 3 & 0b0000_0001
);
trace!(
"Flag 4: {:08b} | {}",
self.flags & 0b0001_0000,
self.flags >> 4 & 0b0000_0001
);
trace!(
"Flag 5: {:08b} | {}",
self.flags & 0b0010_0000,
self.flags >> 5 & 0b0000_0001
);
trace!(
"Flag 6: {:08b} | {}",
self.flags & 0b0100_0000,
self.flags >> 6 & 0b0000_0001
);
trace!(
"Flag 7: {:08b} | {}",
self.flags & 0b1000_0000,
self.flags >> 7 & 0b0000_0001
);
}
}

1
ableos/src/experiments/mod.rs
View file

@ -1,5 +1,6 @@
#![allow(dead_code)]
pub mod clip;
pub mod server;
pub mod systeminfo;
pub mod virtual_memory;

2
ableos/src/experiments/schedule.rs
View file

@ -1,3 +1,5 @@
// Deprecated
pub type Priority = [Process; 512];
pub struct VirtualMemoryTable {}

41
ableos/src/kmain.rs
View file

@ -11,7 +11,7 @@ use {
relib::math::rand::RAND_HANDLE,
scheduler::{test_fn, Thread, ThreadList},
},
alloc::{boxed::Box, rc::Rc, vec, vec::Vec},
alloc::vec,
lazy_static::lazy_static,
};
@ -30,7 +30,6 @@ lazy_static! {
pub static ref TICK: spin::Mutex<u64> = spin::Mutex::new(0);
}
use crate::log::{self, Log};
#[no_mangle]
pub fn kernel_main() -> ! {
init::init();
@ -44,20 +43,10 @@ pub fn kernel_main() -> ! {
GraphicsBuffer::draw();
GraphicsBuffer::hide_cursor();
GraphicsBuffer::show_cursor();
if false {
test_alloc();
}
// crate::wasm::evaluate();
println!("{} v{}", RELEASE_TYPE, KERNEL_VERSION);
info!("{} v{}", RELEASE_TYPE, KERNEL_VERSION);
{
use crate::experiments::mail::MailBoxes;
let mut x = MailBoxes::new();
x.set_flag(1);
x.set_flag(2);
// x.dump_flags();
}
// stack_overflow();
// crate::arch::shutdown();
@ -74,31 +63,3 @@ pub fn tick() {
pub fn key_entropy(key: u8) {
RAND_HANDLE.lock().seed_entropy_keyboard(key);
}
fn test_alloc() {
let x: Vec<u8> = vec![1];
println!("{:?}", x);
let heap_value = Box::new(41);
println!("heap_value at {:p}", heap_value);
// create a dynamically sized vector
let mut vec = Vec::new();
for i in 0..500 {
vec.push(i);
}
println!("vec at {:p}", vec.as_slice());
// create a reference counted vector -> will be freed when count reaches 0
let reference_counted = Rc::new(vec![1, 2, 3]);
let cloned_reference = reference_counted.clone();
println!(
"current reference count is {}",
Rc::strong_count(&cloned_reference)
);
core::mem::drop(reference_counted);
println!(
"reference count is {} now",
Rc::strong_count(&cloned_reference)
);
}

36
ableos/src/log.rs
View file

@ -4,6 +4,21 @@ pub trait Log {
fn info(val: &str);
fn trace(val: &str);
}
pub struct LogState {
pub debug: bool,
pub error: bool,
pub info: bool,
pub trace: bool,
}
lazy_static::lazy_static! {
pub static ref LOG_STATE: LogState = LogState {
debug: true,
error: true,
info: true,
trace: true,
};
}
use crate::serial_print;
use lliw::{Fg, Reset};
@ -26,27 +41,40 @@ impl Log for ANSISerialLogger {
#[macro_export]
macro_rules! debug {
($($arg:tt)*) => ({
if $crate::log::LOG_STATE.debug{
use crate::log::Log;
let _ = &log::ANSISerialLogger::debug(&alloc::format!($($arg)*));
}
})
}
#[macro_export]
macro_rules! error {
($($arg:tt)*) => ({
log::ANSISerialLogger::error(&alloc::format!($($arg)*));
})
if $crate::log::LOG_STATE.error{
use crate::log::Log;
crate::log::ANSISerialLogger::error(&alloc::format!($($arg)*));
}
});
}
#[macro_export]
macro_rules! info {
($($arg:tt)*) => ({
log::ANSISerialLogger::info(&alloc::format!($($arg)*));
if $crate::log::LOG_STATE.info{
use crate::log::Log;
crate::log::ANSISerialLogger::info(&alloc::format!($($arg)*));
}
})
}
#[macro_export]
macro_rules! trace {
($($arg:tt)*) => ({
log::ANSISerialLogger::trace(&alloc::format!($($arg)*));
if $crate::log::LOG_STATE.trace{
use crate::log::Log;
crate::log::ANSISerialLogger::trace(&alloc::format!($($arg)*));
}
})
}

8
ableos/src/panic.rs
View file

@ -1,9 +1,11 @@
use crate::{arch::sloop, println, serial_println};
use core::panic::PanicInfo;
use {
crate::{arch::sloop, println},
core::panic::PanicInfo,
};
#[panic_handler]
fn panic(info: &PanicInfo) -> ! {
println!("{}", info);
serial_println!("{}", info);
error!("{}", info);
sloop()
}

2
ableos/src/print.rs
View file

@ -3,7 +3,7 @@ use core::fmt::{Arguments, Error};
impl Stdout {
pub fn write_fmt(&mut self, arg: Arguments<'_>) /*-> Result<(), Error> */
{
core::fmt::Write::write_fmt(self, arg);
let _ = core::fmt::Write::write_fmt(self, arg);
// Ok(())
}
}

7
ableos/src/scheduler.rs
View file

@ -1,8 +1,5 @@
use {
crate::{
kmain::THREAD_LIST,
log::{self, Log},
},
crate::{kmain::THREAD_LIST, log},
alloc::{vec, vec::Vec},
core::cmp::Ordering,
};
@ -12,6 +9,7 @@ pub type ThreadID = u64;
pub type TaskID = u64;
pub type ThreadList = Vec<Thread>;
#[allow(dead_code)]
#[derive(Eq, Debug)]
pub struct Task {
id: TaskID,
@ -32,7 +30,6 @@ impl Task {
}
}
}
impl Ord for Task {
fn cmp(&self, other: &Self) -> Ordering {
self.id.cmp(&other.id)