forked from AbleOS/ableos
Merge branches 'master' and 'master' of ssh://git.ablecorp.us:20/able/ableos
This commit is contained in:
commit
1dca7c4705
4
.vscode/settings.json
vendored
4
.vscode/settings.json
vendored
|
|
@ -2,7 +2,5 @@
|
|||
"files.associations": {
|
||||
"stddef.h": "c"
|
||||
},
|
||||
"settings": {
|
||||
|
||||
}
|
||||
"rust-analyzer.checkOnSave.allTargets": false,
|
||||
}
|
||||
15
Cargo.lock
generated
15
Cargo.lock
generated
|
|
@ -37,7 +37,6 @@ dependencies = [
|
|||
"genfs",
|
||||
"hashbrown 0.7.2",
|
||||
"kernel",
|
||||
"lazy_static",
|
||||
"libwasm",
|
||||
"linked_list_allocator",
|
||||
"lliw",
|
||||
|
|
@ -53,7 +52,7 @@ dependencies = [
|
|||
"rkyv",
|
||||
"serde",
|
||||
"shadeable",
|
||||
"spin 0.5.2",
|
||||
"spin",
|
||||
"toml",
|
||||
"uart_16550",
|
||||
"unicode-width",
|
||||
|
|
@ -274,7 +273,7 @@ dependencies = [
|
|||
"bitflags",
|
||||
"genfs",
|
||||
"rlibc",
|
||||
"spin 0.9.2",
|
||||
"spin",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
|
@ -384,7 +383,6 @@ dependencies = [
|
|||
name = "kernel"
|
||||
version = "0.1.2"
|
||||
dependencies = [
|
||||
"lazy_static",
|
||||
"log",
|
||||
"versioning",
|
||||
]
|
||||
|
|
@ -394,9 +392,6 @@ name = "lazy_static"
|
|||
version = "1.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
|
||||
dependencies = [
|
||||
"spin 0.5.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
|
|
@ -842,12 +837,6 @@ dependencies = [
|
|||
"version_check",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "spin"
|
||||
version = "0.5.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
|
||||
|
||||
[[package]]
|
||||
name = "spin"
|
||||
version = "0.9.2"
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ build-std = ["core", "compiler_builtins", "alloc"]
|
|||
build-std-features = ["compiler-builtins-mem"]
|
||||
|
||||
[target.'cfg(target_arch = "x86_64")']
|
||||
rustflags = ["-C", "target-feature=+rdrnd"]
|
||||
rustflags = ["-C", "target-feature=+rdrand"]
|
||||
runner = "bootimage runner"
|
||||
|
||||
[target.riscv64gc-unknown-none-elf]
|
||||
|
|
|
|||
|
|
@ -34,6 +34,7 @@ run-args = [
|
|||
"unix:../qmp-sock,server,nowait"
|
||||
|
||||
]
|
||||
|
||||
test-args = [
|
||||
"-device",
|
||||
"isa-debug-exit,iobase=0xf4,iosize=0x04",
|
||||
|
|
@ -41,12 +42,10 @@ test-args = [
|
|||
"stdio",
|
||||
]
|
||||
|
||||
|
||||
|
||||
[dependencies]
|
||||
linked_list_allocator = "0.9.0"
|
||||
lliw = "0.2.0"
|
||||
spin = "0.5.2"
|
||||
spin = "0.9"
|
||||
log = "*"
|
||||
pretty-hex = "0.2.1"
|
||||
unicode-width = "0.1.7"
|
||||
|
|
@ -56,39 +55,32 @@ genfs = "0.1.0"
|
|||
rhai = "1.6.0"
|
||||
libwasm = {git="https://git.ablecorp.us:443/able/libwasm.git"}
|
||||
acpi = "4.1.0"
|
||||
|
||||
axel = { git = "https://git.ablecorp.us/able/aos_userland" }
|
||||
|
||||
|
||||
|
||||
|
||||
[dependencies.logos]
|
||||
version = "0.12.0"
|
||||
version = "0.12"
|
||||
default-features = false
|
||||
features = ["export_derive"]
|
||||
|
||||
[dependencies.rdrand]
|
||||
version = "0.8.1"
|
||||
version = "0.8"
|
||||
default-features = false
|
||||
|
||||
[dependencies.kernel]
|
||||
path = "../kernel"
|
||||
|
||||
[dependencies.serde]
|
||||
version = "1.0.136"
|
||||
version = "1.0"
|
||||
default-features = false
|
||||
features = ["derive", "alloc"]
|
||||
|
||||
[dependencies.hashbrown]
|
||||
version = "0.7.2"
|
||||
version = "0.7"
|
||||
default-features = false
|
||||
features = ["inline-more"]
|
||||
|
||||
|
||||
|
||||
|
||||
[dependencies.rkyv]
|
||||
version = "0.7.29"
|
||||
version = "0.7"
|
||||
default-features = false
|
||||
features = ["size_64", "alloc"]
|
||||
|
||||
|
|
@ -103,15 +95,11 @@ git = "https://git.ablecorp.us:443/able/y-compositor-protocol.git"
|
|||
[dependencies.ext2]
|
||||
git = "https://git.ablecorp.us:443/able/ext2-rs.git"
|
||||
|
||||
|
||||
|
||||
|
||||
[dependencies.toml]
|
||||
git = "https://github.com/diondokter/toml-rs"
|
||||
# version = "0.5.8"
|
||||
default-features = false
|
||||
|
||||
|
||||
[dependencies.shadeable]
|
||||
path = "../shadeable"
|
||||
|
||||
|
|
@ -128,10 +116,6 @@ default-features = false
|
|||
features = ["core"]
|
||||
version = "*"
|
||||
|
||||
[dependencies.lazy_static]
|
||||
features = ["spin_no_std"]
|
||||
version = "1.0"
|
||||
|
||||
[dependencies.externc-libm]
|
||||
git = "https://git.ablecorp.us:443/able/externc-libm.git"
|
||||
|
||||
|
|
|
|||
|
|
@ -1,8 +1,7 @@
|
|||
use hashbrown::HashMap;
|
||||
|
||||
lazy_static::lazy_static! {
|
||||
pub static ref ALIAS_TABLE: spin::Mutex<AliasTable> = spin::Mutex::new(AliasTable::new());
|
||||
}
|
||||
pub static ALIAS_TABLE: spin::Mutex<AliasTable> = spin::Mutex::new(AliasTable::new());
|
||||
|
||||
/// A table of aliases
|
||||
///
|
||||
/// This is used to allow users to specify aliases for files and commands
|
||||
|
|
@ -16,6 +15,7 @@ impl AliasTable {
|
|||
table: HashMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn add_alias(&mut self, alias: String, path: String) {
|
||||
self.table.insert(alias, path);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,12 +1,9 @@
|
|||
/*!
|
||||
The allocator to be implemented by ableOS
|
||||
*/
|
||||
//! The allocator to be implemented by ableOS
|
||||
|
||||
use alloc::alloc::{GlobalAlloc, Layout};
|
||||
use core::ptr::null_mut;
|
||||
|
||||
pub struct AAloc;
|
||||
|
||||
unsafe impl GlobalAlloc for AAloc {
|
||||
unsafe fn alloc(&self, _layout: Layout) -> *mut u8 {
|
||||
println!("Allocating memory");
|
||||
|
|
|
|||
|
|
@ -1,22 +1,16 @@
|
|||
mod aalloc;
|
||||
|
||||
pub const HEAP_START: usize = 0x_4444_4444_0000;
|
||||
/// 131072 bytes
|
||||
// pub const HEAP_MULTIPLIER: usize = 1024;
|
||||
pub const HEAP_MULTIPLIER: usize = 100000;
|
||||
|
||||
pub const HEAP_BASE: usize = 100;
|
||||
|
||||
pub const HEAP_SIZE: usize = HEAP_BASE * HEAP_MULTIPLIER;
|
||||
|
||||
use linked_list_allocator::LockedHeap;
|
||||
|
||||
pub const HEAP_START: usize = 0x_4444_4444_0000;
|
||||
pub const HEAP_MULTIPLIER: usize = 100000;
|
||||
pub const HEAP_BASE: usize = 100;
|
||||
pub const HEAP_SIZE: usize = HEAP_BASE * HEAP_MULTIPLIER;
|
||||
|
||||
#[global_allocator]
|
||||
pub static ALLOCATOR: LockedHeap = LockedHeap::empty();
|
||||
|
||||
#[alloc_error_handler]
|
||||
fn alloc_error_handler(layout: alloc::alloc::Layout) -> ! {
|
||||
// error!("allocation error: {:?}", layout);
|
||||
|
||||
panic!("allocation error: {:?}", layout)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@ use alloc::alloc::{GlobalAlloc, Layout};
|
|||
use core::ptr::null_mut;
|
||||
|
||||
pub struct Dummy;
|
||||
|
||||
unsafe impl GlobalAlloc for Dummy {
|
||||
unsafe fn alloc(&self, _layout: Layout) -> *mut u8 {
|
||||
null_mut()
|
||||
|
|
|
|||
|
|
@ -7,21 +7,27 @@ impl Graphics for GraphicsBuffer {
|
|||
fn put_line(coords_start: Point, coords_end: Point, thickness: u32, color: Rgb) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn put_rect(coords_start: Point, coords_end: Point, color: Rgb) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn put_circle(coords: Point, radius: u32) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn put_triangle(coords_1: Point, coords_2: Point, coords_3: Point, thickness: u32, color: Rgb) {
|
||||
todo!();
|
||||
}
|
||||
|
||||
fn put_pixel(coords: Point, color: Rgb) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn paint_cursor(coords: Point) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn hide_cursor() {}
|
||||
fn show_cursor() {}
|
||||
fn draw() {}
|
||||
|
|
|
|||
|
|
@ -1,36 +1,8 @@
|
|||
//! A not-very-useful abstraction of GPIOs in Rust
|
||||
#![allow(dead_code)]
|
||||
|
||||
// A not-very-useful abstraction of GPIOs in Rust
|
||||
|
||||
use core::sync::atomic::{AtomicBool, Ordering::SeqCst};
|
||||
|
||||
/// A struct that represents an nRF52 Pin
|
||||
pub struct Pin(u8);
|
||||
|
||||
/// A struct that represents P0 of the nRF52
|
||||
pub struct Pins {
|
||||
pub p0_31: Pin,
|
||||
}
|
||||
|
||||
impl Pins {
|
||||
/// A function to obtain a Port 0 singleton structure
|
||||
pub fn take() -> Self {
|
||||
static TAKEN: AtomicBool = AtomicBool::new(false);
|
||||
|
||||
// Enforce this as a singleton
|
||||
assert!(!TAKEN.swap(true, SeqCst));
|
||||
|
||||
Self { p0_31: Pin(31) }
|
||||
}
|
||||
}
|
||||
|
||||
/// The level of a GPIO
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum Level {
|
||||
Low,
|
||||
High,
|
||||
}
|
||||
|
||||
const REG_P0_PIN_CNF_BASE: *mut u32 = 0x5000_0700 as *mut u32;
|
||||
const REG_P0_OUT_SET: *mut u32 = 0x5000_0508 as *mut u32;
|
||||
const REG_P0_OUT_CLR: *mut u32 = 0x5000_050C as *mut u32;
|
||||
|
|
@ -40,7 +12,8 @@ const PIN_CNF_INPUT_CONNECT: u32 = 0x0000_0000;
|
|||
const PIN_CNF_PULL_DISABLED: u32 = 0x0000_0000;
|
||||
const PIN_CNF_DRIVE_S0S1: u32 = 0x0000_0000;
|
||||
const PIN_CNF_SENSE_DISABLED: u32 = 0x0000_0000;
|
||||
|
||||
/// A struct that represents an nRF52 Pin
|
||||
pub struct Pin(u8);
|
||||
impl Pin {
|
||||
/// Set a pin to be a push pull output
|
||||
pub fn set_push_pull_output(&mut self, level: Level) {
|
||||
|
|
@ -71,3 +44,27 @@ impl Pin {
|
|||
unsafe { core::ptr::write_volatile(REG_P0_OUT_CLR, 1 << (self.0 as u32)) }
|
||||
}
|
||||
}
|
||||
|
||||
/// The level of a GPIO
|
||||
#[derive(Copy, Clone)]
|
||||
pub enum Level {
|
||||
Low,
|
||||
High,
|
||||
}
|
||||
|
||||
/// A struct that represents P0 of the nRF52
|
||||
pub struct Pins {
|
||||
pub p0_31: Pin,
|
||||
}
|
||||
|
||||
impl Pins {
|
||||
/// A function to obtain a Port 0 singleton structure
|
||||
pub fn take() -> Self {
|
||||
static TAKEN: AtomicBool = AtomicBool::new(false);
|
||||
|
||||
// Enforce this as a singleton
|
||||
assert!(!TAKEN.swap(true, SeqCst));
|
||||
|
||||
Self { p0_31: Pin(31) }
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,11 +1,10 @@
|
|||
use core::ptr;
|
||||
|
||||
// mod panic;
|
||||
pub mod drivers;
|
||||
pub mod init;
|
||||
|
||||
use crate::arch::drivers::nrf52::{Level, Pins};
|
||||
use core::ptr;
|
||||
use core::ptr::write_volatile;
|
||||
|
||||
global_asm!(include_str!("boot.s"));
|
||||
|
||||
fn delay(ticks: usize) {
|
||||
|
|
@ -33,7 +32,6 @@ pub extern "C" fn not_main() {
|
|||
}
|
||||
}
|
||||
|
||||
//
|
||||
// let gpios = Pins::take();
|
||||
// let mut led = gpios.p0_31;
|
||||
//
|
||||
|
|
@ -46,14 +44,15 @@ pub extern "C" fn not_main() {
|
|||
// }
|
||||
//
|
||||
// led.set_push_pull_output(Level::Low);
|
||||
crate::kmain::kernel_main();
|
||||
|
||||
crate::kmain::kernel_main();
|
||||
sloop();
|
||||
}
|
||||
|
||||
pub fn sloop() -> ! {
|
||||
loop {}
|
||||
}
|
||||
|
||||
pub fn print() {
|
||||
for byte in b"ableOS Arm 64" {
|
||||
const UART0: *mut u8 = 0x0900_0000 as *mut u8;
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@ use alloc::alloc::{GlobalAlloc, Layout};
|
|||
use core::ptr::null_mut;
|
||||
|
||||
pub struct Dummy;
|
||||
|
||||
unsafe impl GlobalAlloc for Dummy {
|
||||
unsafe fn alloc(&self, _layout: Layout) -> *mut u8 {
|
||||
null_mut()
|
||||
|
|
|
|||
|
|
@ -7,21 +7,27 @@ impl Graphics for GraphicsBuffer {
|
|||
fn put_line(coords_start: Point, coords_end: Point, thickness: u32, color: Rgb) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn put_rect(coords_start: Point, coords_end: Point, color: Rgb) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn put_circle(coords: Point, radius: u32) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn put_triangle(coords_1: Point, coords_2: Point, coords_3: Point, thickness: u32, color: Rgb) {
|
||||
todo!();
|
||||
}
|
||||
|
||||
fn put_pixel(coords: Point, color: Rgb) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn paint_cursor(coords: Point) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn hide_cursor() {}
|
||||
fn show_cursor() {}
|
||||
fn draw() {}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@
|
|||
/// We label the mmio function unsafe since
|
||||
/// we will be working with raw memory. Rust cannot
|
||||
/// make any guarantees when we do this.
|
||||
///
|
||||
#[inline(always)]
|
||||
fn mmio_write(address: usize, offset: usize, value: u8) {
|
||||
// Set the pointer based off of the address
|
||||
|
|
|
|||
|
|
@ -1,6 +1,4 @@
|
|||
use core::fmt::Write;
|
||||
|
||||
use core::fmt::Error;
|
||||
use core::fmt::{Error, Write};
|
||||
|
||||
/// Initialize the UART driver by setting
|
||||
/// the word length, FIFOs, and interrupts
|
||||
|
|
@ -113,6 +111,7 @@ impl Uart {
|
|||
uart_init(self.base_address);
|
||||
}
|
||||
}
|
||||
|
||||
// This is a slightly different syntax. Write is this "trait", meaning it is much like
|
||||
// an interface where we're just guaranteeing a certain function signature. In the Write
|
||||
// trait, one is absolutely required to be implemented, which is write_str. There are other
|
||||
|
|
|
|||
|
|
@ -1,5 +1,10 @@
|
|||
pub mod drivers;
|
||||
pub mod init;
|
||||
|
||||
use crate::print;
|
||||
use crate::println;
|
||||
use core::arch::asm;
|
||||
|
||||
#[naked]
|
||||
#[no_mangle]
|
||||
unsafe extern "C" fn _boot() -> ! {
|
||||
|
|
@ -31,9 +36,10 @@ unsafe extern "C" fn _boot() -> ! {
|
|||
}
|
||||
|
||||
extern "C" fn _start() -> ! {
|
||||
use crate::serial_println;
|
||||
|
||||
let uart = crate::arch::drivers::uart::Uart::new(0x1000_0000);
|
||||
uart.init();
|
||||
use crate::serial_println;
|
||||
serial_println!("Hello, world!\r");
|
||||
|
||||
loop {
|
||||
|
|
@ -53,7 +59,6 @@ extern "C" fn _start() -> ! {
|
|||
}
|
||||
|
||||
serial_println!("Serial connection closed.\r");
|
||||
|
||||
sloop()
|
||||
}
|
||||
|
||||
|
|
@ -64,13 +69,8 @@ pub fn sloop() -> ! {
|
|||
};
|
||||
}
|
||||
}
|
||||
use core::arch::asm;
|
||||
|
||||
pub fn shutdown() {}
|
||||
|
||||
use crate::print;
|
||||
use crate::println;
|
||||
|
||||
pub fn generate_process_pass() -> u128 {
|
||||
123
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
use alloc::alloc::{GlobalAlloc, Layout};
|
||||
|
||||
use crate::allocator::{HEAP_SIZE, HEAP_START};
|
||||
use alloc::alloc::{GlobalAlloc, Layout};
|
||||
use core::ptr::null_mut;
|
||||
use x86_64::{
|
||||
structures::paging::{
|
||||
|
|
@ -9,7 +8,6 @@ use x86_64::{
|
|||
VirtAddr,
|
||||
};
|
||||
pub struct Dummy;
|
||||
|
||||
unsafe impl GlobalAlloc for Dummy {
|
||||
unsafe fn alloc(&self, _layout: Layout) -> *mut u8 {
|
||||
null_mut()
|
||||
|
|
|
|||
|
|
@ -8,25 +8,32 @@ impl Graphics for GraphicsBuffer {
|
|||
fn put_line(coords_start: Point, coords_end: Point, thickness: u32, color: Rgb) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn put_rect(coords_start: Point, coords_end: Point, color: Rgb) {}
|
||||
|
||||
fn put_circle(coords: Point, radius: u32) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn put_triangle(coords_1: Point, coords_2: Point, coords_3: Point, thickness: u32, color: Rgb) {
|
||||
todo!();
|
||||
}
|
||||
|
||||
fn put_pixel(coords: Point, color: Rgb) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn paint_cursor(coords: Point) {
|
||||
todo!()
|
||||
}
|
||||
|
||||
fn hide_cursor() {
|
||||
unsafe {
|
||||
outw(0x0A, 0x3D4);
|
||||
outw(0x20, 0x3D5);
|
||||
}
|
||||
}
|
||||
|
||||
fn show_cursor() {}
|
||||
fn draw() {}
|
||||
fn clear() {
|
||||
|
|
|
|||
|
|
@ -1,8 +1,7 @@
|
|||
pub mod allocator;
|
||||
pub mod graphics;
|
||||
pub mod serial;
|
||||
|
||||
pub mod timer;
|
||||
|
||||
// #[deprecated(note = "The use of hardware specific drivers for VGA is discouraged")]
|
||||
#[deprecated(note = "The use of hardware specific drivers for VGA is discouraged")]
|
||||
pub mod vga;
|
||||
|
|
|
|||
|
|
@ -1,13 +1,12 @@
|
|||
use lazy_static::lazy_static;
|
||||
use spin::Mutex;
|
||||
use spin::{Lazy, Mutex};
|
||||
use uart_16550::SerialPort;
|
||||
lazy_static! {
|
||||
pub static ref SERIAL1: Mutex<SerialPort> = {
|
||||
let mut serial_port = unsafe { SerialPort::new(0x3F8) };
|
||||
serial_port.init();
|
||||
Mutex::new(serial_port)
|
||||
};
|
||||
}
|
||||
|
||||
pub static SERIAL1: Lazy<Mutex<SerialPort>> = Lazy::new(|| {
|
||||
let mut serial_port = unsafe { SerialPort::new(0x3F8) };
|
||||
serial_port.init();
|
||||
Mutex::new(serial_port)
|
||||
});
|
||||
|
||||
#[doc(hidden)]
|
||||
pub fn _print(args: ::core::fmt::Arguments) {
|
||||
use core::fmt::Write;
|
||||
|
|
@ -16,6 +15,7 @@ pub fn _print(args: ::core::fmt::Arguments) {
|
|||
.write_fmt(args)
|
||||
.expect("Printing to serial failed");
|
||||
}
|
||||
|
||||
/// Prints to the host through the serial interface.
|
||||
#[macro_export]
|
||||
macro_rules! sprint {
|
||||
|
|
@ -23,6 +23,7 @@ macro_rules! sprint {
|
|||
$crate::arch::drivers::serial::_print(format_args!($($arg)*));
|
||||
};
|
||||
}
|
||||
|
||||
/// Prints to the host through the serial interface, appending a newline.
|
||||
#[macro_export]
|
||||
macro_rules! sprintln {
|
||||
|
|
|
|||
|
|
@ -1,3 +1,10 @@
|
|||
use core::fmt;
|
||||
use spin::{Lazy, Mutex};
|
||||
use volatile::Volatile;
|
||||
|
||||
const BUFFER_HEIGHT: usize = 25;
|
||||
const BUFFER_WIDTH: usize = 80;
|
||||
|
||||
#[allow(dead_code)]
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
#[repr(u8)]
|
||||
|
|
@ -19,31 +26,34 @@ pub enum Color {
|
|||
Yellow = 14,
|
||||
White = 15,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
#[repr(transparent)]
|
||||
struct ColorCode(u8);
|
||||
impl ColorCode {
|
||||
fn new(foreground: Color, background: Color) -> ColorCode {
|
||||
const fn new(foreground: Color, background: Color) -> ColorCode {
|
||||
ColorCode((background as u8) << 4 | (foreground as u8))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
#[repr(C)]
|
||||
struct ScreenChar {
|
||||
ascii_character: u8,
|
||||
color_code: ColorCode,
|
||||
}
|
||||
const BUFFER_HEIGHT: usize = 25;
|
||||
const BUFFER_WIDTH: usize = 80;
|
||||
|
||||
#[repr(transparent)]
|
||||
struct Buffer {
|
||||
chars: [[Volatile<ScreenChar>; BUFFER_WIDTH]; BUFFER_HEIGHT],
|
||||
}
|
||||
|
||||
pub struct Writer {
|
||||
column_position: usize,
|
||||
color_code: ColorCode,
|
||||
buffer: &'static mut Buffer,
|
||||
}
|
||||
|
||||
impl Writer {
|
||||
pub fn write_byte(&mut self, byte: u8) {
|
||||
match byte {
|
||||
|
|
@ -63,6 +73,7 @@ impl Writer {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn write_string(&mut self, s: &str) {
|
||||
for byte in s.bytes() {
|
||||
match byte {
|
||||
|
|
@ -73,6 +84,7 @@ impl Writer {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn new_line(&mut self) {
|
||||
for row in 1..BUFFER_HEIGHT {
|
||||
for col in 0..BUFFER_WIDTH {
|
||||
|
|
@ -83,6 +95,7 @@ impl Writer {
|
|||
self.clear_row(BUFFER_HEIGHT - 1);
|
||||
self.column_position = 0;
|
||||
}
|
||||
|
||||
fn clear_row(&mut self, row: usize) {
|
||||
let blank = ScreenChar {
|
||||
ascii_character: b' ',
|
||||
|
|
@ -108,35 +121,33 @@ impl Writer {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Write for Writer {
|
||||
fn write_str(&mut self, s: &str) -> fmt::Result {
|
||||
self.write_string(s);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
lazy_static! {
|
||||
pub static ref WRITER: Mutex<Writer> = Mutex::new(Writer {
|
||||
|
||||
pub static WRITER: Lazy<Mutex<Writer>> = Lazy::new(|| {
|
||||
Mutex::new(Writer {
|
||||
column_position: 0,
|
||||
color_code: ColorCode::new(Color::White, Color::Black),
|
||||
buffer: unsafe { &mut *(0xb8000 as *mut Buffer) },
|
||||
});
|
||||
}
|
||||
|
||||
use core::fmt;
|
||||
use lazy_static::lazy_static;
|
||||
use spin::Mutex;
|
||||
|
||||
use volatile::Volatile;
|
||||
})
|
||||
});
|
||||
|
||||
#[macro_export]
|
||||
macro_rules! kprint {
|
||||
($($arg:tt)*) => ($crate::arch::drivers::vga::_kprint(format_args!($($arg)*)));
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
macro_rules! kprintln {
|
||||
() => ($crate::kprint!("\n"));
|
||||
($($arg:tt)*) => ($crate::kprint!("{}\n", format_args!($($arg)*)));
|
||||
}
|
||||
|
||||
#[doc(hidden)]
|
||||
pub fn _kprint(args: fmt::Arguments) {
|
||||
use core::fmt::Write;
|
||||
|
|
|
|||
|
|
@ -1,39 +1,40 @@
|
|||
use lazy_static::lazy_static;
|
||||
use spin::Lazy;
|
||||
use x86_64::structures::gdt::{Descriptor, GlobalDescriptorTable, SegmentSelector};
|
||||
use x86_64::structures::tss::TaskStateSegment;
|
||||
use x86_64::VirtAddr;
|
||||
pub const DOUBLE_FAULT_IST_INDEX: u16 = 0;
|
||||
lazy_static! {
|
||||
static ref TSS: TaskStateSegment = {
|
||||
let mut tss = TaskStateSegment::new();
|
||||
tss.interrupt_stack_table[DOUBLE_FAULT_IST_INDEX as usize] = {
|
||||
const STACK_SIZE: usize = 4096 * 5;
|
||||
static mut STACK: [u8; STACK_SIZE] = [0; STACK_SIZE];
|
||||
|
||||
let stack_start = VirtAddr::from_ptr(unsafe { &STACK });
|
||||
stack_start + STACK_SIZE
|
||||
};
|
||||
tss
|
||||
};
|
||||
}
|
||||
pub const DOUBLE_FAULT_IST_INDEX: u16 = 0;
|
||||
|
||||
struct Selectors {
|
||||
code_selector: SegmentSelector,
|
||||
tss_selector: SegmentSelector,
|
||||
}
|
||||
lazy_static! {
|
||||
static ref GDT: (GlobalDescriptorTable, Selectors) = {
|
||||
let mut gdt = GlobalDescriptorTable::new();
|
||||
let code_selector = gdt.add_entry(Descriptor::kernel_code_segment());
|
||||
let tss_selector = gdt.add_entry(Descriptor::tss_segment(&TSS));
|
||||
(
|
||||
gdt,
|
||||
Selectors {
|
||||
code_selector,
|
||||
tss_selector,
|
||||
},
|
||||
)
|
||||
|
||||
static TSS: Lazy<TaskStateSegment> = Lazy::new(|| {
|
||||
let mut tss = TaskStateSegment::new();
|
||||
tss.interrupt_stack_table[DOUBLE_FAULT_IST_INDEX as usize] = {
|
||||
const STACK_SIZE: usize = 4096 * 5;
|
||||
static mut STACK: [u8; STACK_SIZE] = [0; STACK_SIZE];
|
||||
|
||||
let stack_start = VirtAddr::from_ptr(unsafe { &STACK });
|
||||
stack_start + STACK_SIZE
|
||||
};
|
||||
}
|
||||
tss
|
||||
});
|
||||
|
||||
static GDT: Lazy<(GlobalDescriptorTable, Selectors)> = Lazy::new(|| {
|
||||
let mut gdt = GlobalDescriptorTable::new();
|
||||
let code_selector = gdt.add_entry(Descriptor::kernel_code_segment());
|
||||
let tss_selector = gdt.add_entry(Descriptor::tss_segment(&TSS));
|
||||
(
|
||||
gdt,
|
||||
Selectors {
|
||||
code_selector,
|
||||
tss_selector,
|
||||
},
|
||||
)
|
||||
});
|
||||
|
||||
pub fn init() {
|
||||
use x86_64::instructions::segmentation::{Segment, CS};
|
||||
use x86_64::instructions::tables::load_tss;
|
||||
|
|
|
|||
|
|
@ -1,16 +1,17 @@
|
|||
// #![allow(clippy::print_literal)]
|
||||
use super::{gdt, interrupts};
|
||||
use crate::{
|
||||
logger,
|
||||
scheduler::{capabilities::Capabilities, SCHEDULER},
|
||||
serial_println,
|
||||
};
|
||||
|
||||
use super::{gdt, interrupts};
|
||||
|
||||
/// x86_64 initialization
|
||||
pub fn init() {
|
||||
use crate::network::socket::SimpleSock;
|
||||
use crate::relib::network::socket::Socket;
|
||||
use crate::{
|
||||
network::socket::SimpleSock, relib::network::socket::Socket,
|
||||
scheduler::priority::Priority::High, stdio::StdIO,
|
||||
};
|
||||
|
||||
let mut log_socket_id = SimpleSock::new();
|
||||
log_socket_id.register_protocol("Logger".to_string());
|
||||
|
|
@ -22,10 +23,9 @@ pub fn init() {
|
|||
}
|
||||
Err(err) => error!("{}", err),
|
||||
}
|
||||
|
||||
gdt::init();
|
||||
|
||||
use crate::scheduler::priority::Priority::High;
|
||||
use crate::stdio::StdIO;
|
||||
let mut scheduler = SCHEDULER.lock();
|
||||
let process_0 = scheduler.new_process(
|
||||
Capabilities::empty(),
|
||||
|
|
@ -34,11 +34,9 @@ pub fn init() {
|
|||
StdIO::new("null".to_string()),
|
||||
);
|
||||
scheduler.add_process(process_0);
|
||||
|
||||
drop(scheduler);
|
||||
|
||||
interrupts::init_idt();
|
||||
|
||||
unsafe { interrupts::PICS.lock().initialize() };
|
||||
x86_64::instructions::interrupts::enable();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,14 +4,14 @@ use crate::{
|
|||
print, println,
|
||||
rhai_shell::KEYBUFF,
|
||||
};
|
||||
|
||||
use cpuio::outb;
|
||||
use lazy_static::lazy_static;
|
||||
use pic8259::ChainedPics;
|
||||
use spin;
|
||||
use spin::Lazy;
|
||||
use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame};
|
||||
|
||||
pub const PIC_1_OFFSET: u8 = 32;
|
||||
pub const PIC_2_OFFSET: u8 = PIC_1_OFFSET + 8;
|
||||
|
||||
pub static PICS: spin::Mutex<ChainedPics> =
|
||||
spin::Mutex::new(unsafe { ChainedPics::new(PIC_1_OFFSET, PIC_2_OFFSET) });
|
||||
|
||||
|
|
@ -24,6 +24,7 @@ pub enum InterruptIndex {
|
|||
// SecondInterrupt = PIC_2_OFFSET,
|
||||
Cmos = 0x70,
|
||||
}
|
||||
|
||||
impl InterruptIndex {
|
||||
fn as_u8(self) -> u8 {
|
||||
self as u8
|
||||
|
|
@ -32,35 +33,31 @@ impl InterruptIndex {
|
|||
usize::from(self.as_u8())
|
||||
}
|
||||
}
|
||||
pub fn init_idt() {
|
||||
IDT.load();
|
||||
}
|
||||
lazy_static! {
|
||||
static ref IDT: InterruptDescriptorTable = {
|
||||
let mut idt = InterruptDescriptorTable::new();
|
||||
idt.breakpoint.set_handler_fn(breakpoint_handler);
|
||||
unsafe {
|
||||
idt.double_fault.set_handler_fn(double_fault_handler)
|
||||
.set_stack_index(gdt::DOUBLE_FAULT_IST_INDEX);
|
||||
}
|
||||
|
||||
// This gives fast interrupts
|
||||
set_pit_frequency(1000);
|
||||
static IDT: Lazy<InterruptDescriptorTable> = Lazy::new(|| {
|
||||
let mut idt = InterruptDescriptorTable::new();
|
||||
idt.breakpoint.set_handler_fn(breakpoint_handler);
|
||||
unsafe {
|
||||
idt.double_fault
|
||||
.set_handler_fn(double_fault_handler)
|
||||
.set_stack_index(gdt::DOUBLE_FAULT_IST_INDEX);
|
||||
}
|
||||
|
||||
idt[InterruptIndex::Timer.as_usize()].set_handler_fn(timer_interrupt_handler);
|
||||
idt[InterruptIndex::Keyboard.as_usize()] .set_handler_fn(keyboard_interrupt_handler);
|
||||
// This gives fast interrupts
|
||||
set_pit_frequency(1000);
|
||||
|
||||
idt[6].set_handler_fn(floppy_disk_interrupt_handler);
|
||||
idt[InterruptIndex::Timer.as_usize()].set_handler_fn(timer_interrupt_handler);
|
||||
idt[InterruptIndex::Keyboard.as_usize()].set_handler_fn(keyboard_interrupt_handler);
|
||||
|
||||
idt[6].set_handler_fn(floppy_disk_interrupt_handler);
|
||||
|
||||
idt
|
||||
};
|
||||
}
|
||||
idt
|
||||
});
|
||||
|
||||
extern "x86-interrupt" fn breakpoint_handler(stack_frame: InterruptStackFrame) {
|
||||
println!("EXCEPTION: BREAKPOINT\n{:#?}", stack_frame);
|
||||
}
|
||||
// new
|
||||
|
||||
extern "x86-interrupt" fn double_fault_handler(
|
||||
stack_frame: InterruptStackFrame,
|
||||
error_code: u64,
|
||||
|
|
@ -70,6 +67,7 @@ extern "x86-interrupt" fn double_fault_handler(
|
|||
error_code, stack_frame
|
||||
);
|
||||
}
|
||||
|
||||
extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFrame) {
|
||||
kernel::tick();
|
||||
unsafe {
|
||||
|
|
@ -77,6 +75,7 @@ extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFr
|
|||
.notify_end_of_interrupt(InterruptIndex::Timer.as_u8());
|
||||
}
|
||||
}
|
||||
|
||||
extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStackFrame) {
|
||||
use crate::keyboard::{
|
||||
CustomLayout, CustomScancodeSet, DecodedKey, DecodedKeyKind, HandleControl, KeyCode,
|
||||
|
|
@ -84,14 +83,15 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStac
|
|||
};
|
||||
use spin::Mutex;
|
||||
use x86_64::instructions::port::Port;
|
||||
lazy_static! {
|
||||
static ref KEYBOARD: Mutex<Keyboard<CustomLayout, CustomScancodeSet>> =
|
||||
Mutex::new(Keyboard::new(
|
||||
CustomLayout::new_us104key(),
|
||||
CustomScancodeSet::default(),
|
||||
HandleControl::Ignore
|
||||
));
|
||||
}
|
||||
|
||||
static KEYBOARD: Lazy<Mutex<Keyboard<CustomLayout, CustomScancodeSet>>> = Lazy::new(|| {
|
||||
Mutex::new(Keyboard::new(
|
||||
CustomLayout::new_us104key(),
|
||||
CustomScancodeSet::default(),
|
||||
HandleControl::Ignore,
|
||||
))
|
||||
});
|
||||
|
||||
let mut keyboard = KEYBOARD.lock();
|
||||
let mut port = Port::new(0x60);
|
||||
let scancode: u8 = unsafe { port.read() };
|
||||
|
|
@ -147,6 +147,10 @@ extern "x86-interrupt" fn floppy_disk_interrupt_handler(_stack_frame: InterruptS
|
|||
println!("EXCEPTION: FLOPPY DISK");
|
||||
}
|
||||
|
||||
pub fn init_idt() {
|
||||
IDT.load();
|
||||
}
|
||||
|
||||
fn set_pit_frequency(freq: u32) {
|
||||
let divisor: u16 = (1193180 / freq).try_into().unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -74,7 +74,6 @@ pub fn create_example_mapping(
|
|||
}
|
||||
|
||||
pub struct EmptyFrameAllocator;
|
||||
|
||||
unsafe impl FrameAllocator<Size4KiB> for EmptyFrameAllocator {
|
||||
fn allocate_frame(&mut self) -> Option<PhysFrame<Size4KiB>> {
|
||||
None
|
||||
|
|
|
|||
|
|
@ -1,16 +1,13 @@
|
|||
use crate::arch::drivers::allocator;
|
||||
use bootloader::{entry_point, BootInfo};
|
||||
use x86_64::{
|
||||
instructions::hlt,
|
||||
{structures::paging::Page, VirtAddr},
|
||||
};
|
||||
|
||||
pub mod drivers;
|
||||
pub mod gdt;
|
||||
pub mod init;
|
||||
pub mod interrupts;
|
||||
pub mod memory;
|
||||
|
||||
use crate::arch::drivers::allocator;
|
||||
use bootloader::{entry_point, BootInfo};
|
||||
use x86_64::{instructions::hlt, VirtAddr};
|
||||
|
||||
entry_point![start];
|
||||
#[no_mangle]
|
||||
pub fn start(boot_info: &'static BootInfo) -> ! {
|
||||
|
|
@ -19,13 +16,12 @@ pub fn start(boot_info: &'static BootInfo) -> ! {
|
|||
let mut mapper = unsafe { memory::init(phys_mem_offset) };
|
||||
let mut frame_allocator =
|
||||
unsafe { memory::BootInfoFrameAllocator::init(&boot_info.memory_map) };
|
||||
if false {
|
||||
let page = Page::containing_address(VirtAddr::new(0xdeadbeaf000));
|
||||
memory::create_example_mapping(page, &mut mapper, &mut frame_allocator);
|
||||
|
||||
let page_ptr: *mut u64 = page.start_address().as_mut_ptr();
|
||||
unsafe { page_ptr.offset(400).write_volatile(0xf021_f077_f065_804e) };
|
||||
}
|
||||
// let page = Page::containing_address(VirtAddr::new(0xdeadbeaf000));
|
||||
// memory::create_example_mapping(page, &mut mapper, &mut frame_allocator);
|
||||
//
|
||||
// let page_ptr: *mut u64 = page.start_address().as_mut_ptr();
|
||||
// unsafe { page_ptr.offset(400).write_volatile(0xf021_f077_f065_804e) };
|
||||
|
||||
allocator::init_heap(&mut mapper, &mut frame_allocator).expect("heap initialization failed");
|
||||
|
||||
|
|
@ -54,6 +50,5 @@ pub fn generate_process_pass() -> u128 {
|
|||
use rdrand::RdRand;
|
||||
let gen = RdRand::new().unwrap();
|
||||
|
||||
let ret = (gen.try_next_u64().unwrap() as u128) << 64 | (gen.try_next_u64().unwrap() as u128);
|
||||
ret
|
||||
(gen.try_next_u64().unwrap() as u128) << 64 | (gen.try_next_u64().unwrap() as u128)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,8 +26,7 @@ pub struct KernelConfig {
|
|||
|
||||
impl KernelConfig {
|
||||
pub fn new() -> Self {
|
||||
let p: KernelConfig = toml::from_str(include_str!("../assets/kernel.toml")).unwrap();
|
||||
p
|
||||
toml::from_str(include_str!("../assets/kernel.toml")).unwrap()
|
||||
}
|
||||
|
||||
pub fn log_level(&self) -> LevelFilter {
|
||||
|
|
@ -43,6 +42,12 @@ impl KernelConfig {
|
|||
}
|
||||
}
|
||||
|
||||
impl Default for KernelConfig {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Serialize, Debug, Deserialize)]
|
||||
pub struct LoggingConfig {
|
||||
pub enabled: bool,
|
||||
|
|
|
|||
|
|
@ -1,9 +1,7 @@
|
|||
use kernel::device_interface::character::CharacterDevice;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
|
||||
pub struct DevNull;
|
||||
|
||||
impl CharacterDevice for DevNull {
|
||||
fn can_read(&self) -> bool {
|
||||
true
|
||||
|
|
|
|||
|
|
@ -44,5 +44,6 @@ fn add1_char(c: char) -> char {
|
|||
if c == char::MAX {
|
||||
return 0x00 as char;
|
||||
}
|
||||
|
||||
char::from_u32(c as u32 + 1).unwrap()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@ use kernel::device_interface::character::CharacterDevice;
|
|||
|
||||
#[derive(Debug)]
|
||||
pub struct DevZero;
|
||||
|
||||
impl CharacterDevice for DevZero {
|
||||
fn can_read(&self) -> bool {
|
||||
true
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
pub mod dev_null;
|
||||
pub mod dev_unicode;
|
||||
|
||||
pub mod dev_zero;
|
||||
|
||||
pub use kernel::device_interface::character::CharacterDevice;
|
||||
|
|
|
|||
|
|
@ -1,13 +1,19 @@
|
|||
// ! A virtual terminal device.
|
||||
|
||||
use kernel::device_interface::character::CharacterDevice;
|
||||
|
||||
use core::ops::Not;
|
||||
use core::sync::atomic::AtomicU32;
|
||||
use core::sync::atomic::Ordering;
|
||||
use kernel::device_interface::character::CharacterDevice;
|
||||
use shadeable::pixel_format::Rgba64;
|
||||
|
||||
pub const VTERM_HEIGHT: u32 = 40;
|
||||
pub const VTERM_WIDTH: u32 = 100;
|
||||
|
||||
pub static VIRTUAL_TERMINAL_COUNT: AtomicU32 = AtomicU32::new(0);
|
||||
|
||||
/// Fg and bg colors for vterm
|
||||
pub type ColorCharacter = (Rgba64, Rgba64);
|
||||
|
||||
/// A vterm representation of a character
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct VtermCharacter {
|
||||
|
|
@ -25,21 +31,27 @@ impl Style {
|
|||
pub fn bold(&self) -> bool {
|
||||
(self.0 & 0x01) > 0
|
||||
}
|
||||
|
||||
pub fn underlined(&self) -> bool {
|
||||
(self.0 & 0x02) > 0
|
||||
}
|
||||
|
||||
pub fn italic(&self) -> bool {
|
||||
(self.0 & 0x04) > 0
|
||||
}
|
||||
|
||||
pub fn blinking(&self) -> bool {
|
||||
(self.0 & 0x08) > 0
|
||||
}
|
||||
|
||||
pub fn reversed(&self) -> bool {
|
||||
(self.0 & 0x10) > 0
|
||||
}
|
||||
|
||||
pub fn struck(&self) -> bool {
|
||||
(self.0 & 0x20) > 0
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn set_bold(mut self, v: bool) -> Self {
|
||||
if v {
|
||||
|
|
@ -49,6 +61,7 @@ impl Style {
|
|||
}
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn set_underlined(mut self, v: bool) -> Self {
|
||||
if v {
|
||||
|
|
@ -58,6 +71,7 @@ impl Style {
|
|||
}
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn set_italic(mut self, v: bool) -> Self {
|
||||
if v {
|
||||
|
|
@ -67,6 +81,7 @@ impl Style {
|
|||
}
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn set_blinking(mut self, v: bool) -> Self {
|
||||
if v {
|
||||
|
|
@ -76,6 +91,7 @@ impl Style {
|
|||
}
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn set_reversed(mut self, v: bool) -> Self {
|
||||
if v {
|
||||
|
|
@ -85,6 +101,7 @@ impl Style {
|
|||
}
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn set_struck(mut self, v: bool) -> Self {
|
||||
if v {
|
||||
|
|
@ -95,18 +112,23 @@ impl Style {
|
|||
self
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct VTerm {
|
||||
pub characters: [[VtermCharacter; VTERM_WIDTH as usize]; VTERM_HEIGHT as usize],
|
||||
pub cursor_visible: bool,
|
||||
|
||||
/// Internal ID of the vterm
|
||||
iid: u32,
|
||||
pub characters: [[VtermCharacter; VTERM_WIDTH as usize]; VTERM_HEIGHT as usize],
|
||||
|
||||
/// The internal representation of the vterm
|
||||
style: Style,
|
||||
|
||||
/// The cursor position in layout x,y
|
||||
cursor_position: (u32, u32),
|
||||
pub cursor_visible: bool,
|
||||
key_buff: Vec<char>,
|
||||
}
|
||||
|
||||
impl Default for VTerm {
|
||||
fn default() -> Self {
|
||||
VTerm {
|
||||
|
|
@ -150,6 +172,7 @@ impl VTerm {
|
|||
self.cursor_position.1 = y;
|
||||
}
|
||||
}
|
||||
|
||||
/// Set the vterm style
|
||||
pub fn set_vterm_style(&mut self, style: Style) {
|
||||
self.style = style;
|
||||
|
|
@ -177,30 +200,30 @@ impl CharacterDevice for VTerm {
|
|||
'\n' => {
|
||||
self.cursor_position.1 += 1;
|
||||
self.cursor_position.0 = 0;
|
||||
return true;
|
||||
true
|
||||
}
|
||||
'\r' => {
|
||||
self.cursor_position.0 = 0;
|
||||
return true;
|
||||
true
|
||||
}
|
||||
'\t' => {
|
||||
self.cursor_position.0 += 4;
|
||||
return true;
|
||||
true
|
||||
}
|
||||
'\x08' => {
|
||||
self.cursor_position.0 -= 1;
|
||||
self.characters[self.cursor_position.1 as usize][self.cursor_position.0 as usize]
|
||||
.character = ' ';
|
||||
return true;
|
||||
true
|
||||
}
|
||||
/// This is a form feed, which is used to clear the screen
|
||||
// This is a form feed, which is used to clear the screen
|
||||
'\x0c' => {
|
||||
self.characters = [[VtermCharacter {
|
||||
character: ' ',
|
||||
char_color: (0xff_ff_ff_ff, 0x00_00_00_00),
|
||||
style: Style::default(),
|
||||
}; VTERM_WIDTH as usize]; VTERM_HEIGHT as usize];
|
||||
return true;
|
||||
true
|
||||
}
|
||||
|
||||
_ => {
|
||||
|
|
@ -213,11 +236,11 @@ impl CharacterDevice for VTerm {
|
|||
|
||||
if self.cursor_position.0 < VTERM_WIDTH {
|
||||
self.cursor_position.0 += 1;
|
||||
return true;
|
||||
true
|
||||
} else {
|
||||
self.cursor_position.0 = 0;
|
||||
self.cursor_position.1 += 1;
|
||||
return true;
|
||||
true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -229,6 +252,7 @@ impl CharacterDevice for VTerm {
|
|||
char_color: (0xff_ff_ff_ff, 0x00_00_00_00),
|
||||
style: Style::default(),
|
||||
}; VTERM_WIDTH as usize]; VTERM_HEIGHT as usize];
|
||||
|
||||
self.cursor_position = (0, 0);
|
||||
self.cursor_visible = true;
|
||||
self.style = Style::default();
|
||||
|
|
@ -238,9 +262,3 @@ impl CharacterDevice for VTerm {
|
|||
true
|
||||
}
|
||||
}
|
||||
|
||||
lazy_static::lazy_static! {
|
||||
pub static ref VIRTUAL_TERMINAL_COUNT: AtomicU32 = AtomicU32::new(0);
|
||||
}
|
||||
use core::sync::atomic::AtomicU32;
|
||||
use core::sync::atomic::Ordering;
|
||||
|
|
|
|||
|
|
@ -1,15 +1,14 @@
|
|||
#[derive(Debug)]
|
||||
pub enum Vendor {
|
||||
Unknown = 0,
|
||||
|
||||
Ati = 1002,
|
||||
}
|
||||
|
||||
pub fn match_vendor(id: u16) -> Vendor {
|
||||
use Vendor::*;
|
||||
|
||||
match id {
|
||||
1002 => Ati,
|
||||
|
||||
_ => Unknown,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,42 +2,57 @@ pub mod character_devs;
|
|||
pub mod id;
|
||||
pub mod pci_inner;
|
||||
|
||||
use hashbrown::HashMap;
|
||||
mod dev_vterm;
|
||||
|
||||
pub use self::Device::*;
|
||||
|
||||
use crate::devices::dev_vterm::VTerm;
|
||||
use character_devs::{dev_null::DevNull, dev_unicode::DevUnicode, dev_zero::DevZero};
|
||||
use hashbrown::HashMap;
|
||||
use kernel::device_interface::character::CharacterDevice;
|
||||
use spin::Lazy;
|
||||
|
||||
pub static DEVICE_TABLE: Lazy<spin::Mutex<DeviceTable>> =
|
||||
Lazy::new(|| spin::Mutex::new(DeviceTable::new()));
|
||||
|
||||
// FIXME: This is a hack to hold a device.
|
||||
// #[derive(Debug)]
|
||||
pub enum Device {
|
||||
Character(Box<dyn CharacterDevice>),
|
||||
Vterm(VTerm),
|
||||
Vterm(Box<VTerm>),
|
||||
}
|
||||
|
||||
unsafe impl Sync for Device {}
|
||||
unsafe impl Send for Device {}
|
||||
|
||||
pub struct DeviceTable {
|
||||
pub devices: HashMap<String, Device>,
|
||||
}
|
||||
use self::character_devs::{dev_null::DevNull, dev_unicode::DevUnicode, dev_zero::DevZero};
|
||||
pub use self::Device::*;
|
||||
|
||||
impl DeviceTable {
|
||||
pub fn new() -> Self {
|
||||
let mut table: HashMap<String, Device> = HashMap::new();
|
||||
table.insert("null".to_string(), Character(Box::new(DevNull)));
|
||||
table.insert("zero".to_string(), Character(Box::new(DevZero)));
|
||||
table.insert(
|
||||
"unicode".to_string(),
|
||||
Character(Box::new(DevUnicode {
|
||||
next_write_char: 0x00 as char,
|
||||
next_read_char: 0x00 as char,
|
||||
})),
|
||||
);
|
||||
table.insert("kvterm".to_string(), Vterm(VTerm::new()));
|
||||
DeviceTable { devices: table }
|
||||
DeviceTable {
|
||||
devices: [
|
||||
("null", Character(Box::new(DevNull))),
|
||||
("zero", Character(Box::new(DevZero))),
|
||||
(
|
||||
"unicode",
|
||||
Character(Box::new(DevUnicode {
|
||||
next_write_char: 0x00 as char,
|
||||
next_read_char: 0x00 as char,
|
||||
})),
|
||||
),
|
||||
("kvterm", Vterm(Box::new(VTerm::new()))),
|
||||
]
|
||||
.into_iter()
|
||||
.map(|(k, v)| (k.to_string(), v))
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
lazy_static::lazy_static!(
|
||||
pub static ref DEVICE_TABLE: spin::Mutex<DeviceTable> =
|
||||
spin::Mutex::new(DeviceTable::new());
|
||||
);
|
||||
impl Default for DeviceTable {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,9 +2,6 @@
|
|||
//!
|
||||
//!
|
||||
|
||||
#[allow(dead_code)]
|
||||
fn scan_pci_bus() {}
|
||||
|
||||
pub enum Vendors {
|
||||
ThreeDfxInteractiveInc = 0x121a,
|
||||
ThreeDLabs = 0x3d3d,
|
||||
|
|
@ -53,3 +50,6 @@ pub enum Vendors {
|
|||
pub struct PciDevice {
|
||||
pub vendor: Vendors,
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
fn scan_pci_bus() {}
|
||||
|
|
|
|||
|
|
@ -1,16 +1,21 @@
|
|||
#![allow(unused)]
|
||||
|
||||
pub const REFRESH_RATE: u8 = 60;
|
||||
|
||||
pub type RefreshRate = u8;
|
||||
pub type Resolution = (usize, usize);
|
||||
pub type Point = (GCoord, GCoord);
|
||||
pub type GCoord = usize;
|
||||
|
||||
pub enum GModes {
|
||||
Vga800x600,
|
||||
Custom(u16, u16),
|
||||
}
|
||||
pub type GCoord = usize;
|
||||
|
||||
// TODO remap to a bitmasked u32
|
||||
/* REASON: More effecient memory wise so less overhead on the wasm memory
|
||||
Current: u32+u32+u32
|
||||
Proposed: u32 with bitmaps
|
||||
*/
|
||||
|
||||
// REASON: More effecient memory wise so less overhead on the wasm memory
|
||||
// Current: u32+u32+u32
|
||||
// Proposed: u32 with bitmaps
|
||||
pub struct Rgb {
|
||||
pub r: u32,
|
||||
pub g: u32,
|
||||
|
|
@ -22,13 +27,8 @@ impl Rgb {
|
|||
todo!();
|
||||
}
|
||||
}
|
||||
pub type RefreshRate = u8;
|
||||
|
||||
pub const REFRESH_RATE: u8 = 60;
|
||||
pub type Resolution = (usize, usize);
|
||||
pub type Point = (GCoord, GCoord);
|
||||
pub struct FrameBuffer;
|
||||
// [[Rgb; 5]; 5]
|
||||
pub trait Graphics {
|
||||
fn put_line(coords_start: Point, coords_end: Point, thickness: u32, color: Rgb);
|
||||
fn put_rect(coords_start: Point, coords_end: Point, color: Rgb);
|
||||
|
|
|
|||
|
|
@ -1,5 +1,3 @@
|
|||
|
||||
|
||||
// TODO: Bitmasking
|
||||
pub enum Mouse {
|
||||
Button1,
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ use kernel::device_interface::character::CharacterDevice;
|
|||
pub struct Serial {
|
||||
pub base: usize,
|
||||
}
|
||||
|
||||
impl CharacterDevice for Serial {
|
||||
fn can_read(&self) -> bool {
|
||||
true
|
||||
|
|
@ -16,7 +17,7 @@ impl CharacterDevice for Serial {
|
|||
todo!()
|
||||
}
|
||||
|
||||
fn write_char(&mut self, c: char) -> bool {
|
||||
fn write_char(&mut self, _c: char) -> bool {
|
||||
todo!()
|
||||
}
|
||||
|
||||
|
|
@ -28,6 +29,7 @@ impl CharacterDevice for Serial {
|
|||
false
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new_serial_test() {
|
||||
let mut serial = Serial { base: 0x3F8 };
|
||||
serial.initialize();
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
// TODO improve tokenizer/parser
|
||||
use logos::{Lexer, Logos};
|
||||
|
||||
// TODO improve tokenizer/parser
|
||||
pub fn colorify(eval: &str) {
|
||||
let y = eval.split("$");
|
||||
let y = eval.split('$');
|
||||
for z in y {
|
||||
match z {
|
||||
"BLACK" => {
|
||||
|
|
@ -55,15 +56,13 @@ pub fn colorify(eval: &str) {
|
|||
"RESET" => {
|
||||
// set_vga_color(Color::White, Color::Black);
|
||||
}
|
||||
elk => {
|
||||
_elk => {
|
||||
// kprint!("{}", elk);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
use logos::Logos;
|
||||
|
||||
#[derive(Logos, Debug, PartialEq)]
|
||||
pub enum Token {
|
||||
// Hex(u32),
|
||||
|
|
@ -80,6 +79,7 @@ pub enum Token {
|
|||
#[regex(r"[ \t\n\f]+", logos::skip)]
|
||||
Error,
|
||||
}
|
||||
|
||||
pub fn colorify_2(eval: &str) {
|
||||
let lexer = Token::lexer(eval);
|
||||
for token in lexer {
|
||||
|
|
@ -91,7 +91,7 @@ pub fn colorify_2(eval: &str) {
|
|||
Reset => {
|
||||
// set_vga_color(Color::White, Color::Black);
|
||||
}
|
||||
Text(text) => {
|
||||
Text(_text) => {
|
||||
// kprint!("{}", text);
|
||||
}
|
||||
err => {
|
||||
|
|
@ -100,9 +100,7 @@ pub fn colorify_2(eval: &str) {
|
|||
}
|
||||
}
|
||||
}
|
||||
use logos::Lexer;
|
||||
|
||||
// use crate::kprint;
|
||||
fn parse_text(lex: &mut Lexer<Token>) -> Option<String> {
|
||||
let slice = lex.slice();
|
||||
Some(String::from(slice))
|
||||
|
|
|
|||
|
|
@ -1,20 +1,13 @@
|
|||
use alloc::{string::String, vec, vec::Vec};
|
||||
// use crate::String;
|
||||
// use crate::Vec;
|
||||
use lazy_static::lazy_static;
|
||||
|
||||
pub static CLIPBOARD: spin::Mutex<Clipboard> = spin::Mutex::new(Clipboard::new());
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum Mime {
|
||||
None,
|
||||
Text(String),
|
||||
}
|
||||
|
||||
lazy_static! {
|
||||
pub static ref CLIPBOARD: spin::Mutex<Clipboard> = {
|
||||
let clipboard = Clipboard::new();
|
||||
spin::Mutex::new(clipboard)
|
||||
};
|
||||
}
|
||||
|
||||
// ctrl+v paste but not pop and pastes
|
||||
// ctrl+shift+v pops from the stack and pastes
|
||||
// ctrl+c pushes to the stack
|
||||
|
|
@ -25,30 +18,36 @@ pub struct Clipboard {
|
|||
pub index: usize,
|
||||
pub pages: Vec<Mime>,
|
||||
}
|
||||
|
||||
impl Clipboard {
|
||||
pub fn new() -> Clipboard {
|
||||
pub const fn new() -> Clipboard {
|
||||
Clipboard {
|
||||
index: 0,
|
||||
pages: vec![],
|
||||
}
|
||||
}
|
||||
|
||||
pub fn clear(&mut self) {
|
||||
self.pages = vec![];
|
||||
}
|
||||
|
||||
pub fn set_index(&mut self, index_new: usize) {
|
||||
self.index = index_new;
|
||||
}
|
||||
|
||||
pub fn clip_end(&mut self) {
|
||||
self.index = 0;
|
||||
}
|
||||
|
||||
pub fn clip_home(&mut self) {
|
||||
self.index = self.pages.len();
|
||||
}
|
||||
|
||||
pub fn copy(&mut self, copy_mime: Mime) {
|
||||
self.pages.push(copy_mime);
|
||||
}
|
||||
|
||||
pub fn paste(&mut self) -> &Mime {
|
||||
let paste_pos = &self.pages[self.index];
|
||||
paste_pos
|
||||
&self.pages[self.index] as _
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,6 @@
|
|||
use core::time::Duration;
|
||||
|
||||
// pub struct Duration {}
|
||||
|
||||
pub struct AtomicU32(u32);
|
||||
|
||||
impl AtomicU32 {
|
||||
//if v != current value
|
||||
pub fn wait(&self, _v: u32) {
|
||||
|
|
@ -21,9 +18,8 @@ impl AtomicU32 {
|
|||
}
|
||||
}
|
||||
/*
|
||||
|
||||
SUPER HANDWAVEY
|
||||
YOU WILL NEED LOCKING THAT I DIDNT WRITE OUT (you == zuurr#9735)
|
||||
// SUPER HANDWAVEY
|
||||
// YOU WILL NEED LOCKING THAT I DIDNT WRITE OUT (you == zuurr#9735)
|
||||
|
||||
// all the red is by design
|
||||
pub fn futex_wait(atom: &AtomicU32, value: usize, current_thread: ThreadID) {
|
||||
|
|
@ -44,7 +40,6 @@ pub fn futex_wake(atom: &AtomicU32, threads_to_wake: usize) {
|
|||
waiting_thread.wake()
|
||||
}
|
||||
}
|
||||
|
||||
*/
|
||||
|
||||
struct FutexWaitlist {
|
||||
|
|
|
|||
|
|
@ -1,8 +1,3 @@
|
|||
#![cfg_attr(
|
||||
not(any(target_arch = "x86_64", target_arch = "x86")),
|
||||
allow(dead_code)
|
||||
)]
|
||||
|
||||
//! ```
|
||||
//! extern crate cupid;
|
||||
//!
|
||||
|
|
@ -17,10 +12,50 @@
|
|||
//! }
|
||||
//! ```
|
||||
|
||||
#![cfg_attr(
|
||||
not(any(target_arch = "x86_64", target_arch = "x86")),
|
||||
allow(dead_code)
|
||||
)]
|
||||
|
||||
use core::arch::asm;
|
||||
use core::ops::Deref;
|
||||
use core::{fmt, slice, str};
|
||||
|
||||
// 3 calls of 4 registers of 4 bytes
|
||||
const BRAND_STRING_LENGTH: usize = 3 * 4 * 4;
|
||||
|
||||
macro_rules! bit {
|
||||
($reg:ident, {$($idx:expr => $name:ident),+ $(,)?}) => {
|
||||
$(pub fn $name(self) -> bool {
|
||||
((self.$reg >> $idx) & 1) != 0
|
||||
})+
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! dump {
|
||||
($me:expr, $f: expr, $sname:expr, {$($name:ident),+ $(,)?}) => {
|
||||
$f.debug_struct($sname)
|
||||
$(.field(stringify!($name), &$me.$name()))+
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! delegate_flag {
|
||||
($item:ident, {$($name:ident),+ $(,)?}) => {
|
||||
$(pub fn $name(&self) -> bool {
|
||||
self.$item.map(|i| i.$name()).unwrap_or(false)
|
||||
})+
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! master_attr_reader {
|
||||
($name:ident, $kind:ty) => {
|
||||
pub fn $name(&self) -> Option<&$kind> {
|
||||
self.$name.as_ref()
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[repr(u32)]
|
||||
pub enum RequestType {
|
||||
BasicInformation = 0x00000000,
|
||||
|
|
@ -32,7 +67,7 @@ pub enum RequestType {
|
|||
BrandString1 = 0x80000002,
|
||||
BrandString2 = 0x80000003,
|
||||
BrandString3 = 0x80000004,
|
||||
// reserved = 0x80000005,
|
||||
// reserved = 0x80000005,
|
||||
CacheLine = 0x80000006,
|
||||
TimeStampCounter = 0x80000007,
|
||||
PhysicalAddressSize = 0x80000008,
|
||||
|
|
@ -70,7 +105,6 @@ pub fn master() -> Option<Master> {
|
|||
// The bit positions are inclusive.
|
||||
fn bits_of(val: u32, start_bit: u8, end_bit: u8) -> u32 {
|
||||
let mut silly = 0;
|
||||
|
||||
for _ in start_bit..end_bit + 1 {
|
||||
silly <<= 1;
|
||||
silly |= 1;
|
||||
|
|
@ -85,38 +119,6 @@ pub fn as_bytes(v: &u32) -> &[u8] {
|
|||
unsafe { slice::from_raw_parts(start, 4) }
|
||||
}
|
||||
|
||||
macro_rules! bit {
|
||||
($reg:ident, {$($idx:expr => $name:ident),+}) => {
|
||||
$(pub fn $name(self) -> bool {
|
||||
((self.$reg >> $idx) & 1) != 0
|
||||
})+
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! dump {
|
||||
($me:expr, $f: expr, $sname:expr, {$($name:ident),+}) => {
|
||||
$f.debug_struct($sname)
|
||||
$(.field(stringify!($name), &$me.$name()))+
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! delegate_flag {
|
||||
($item:ident, {$($name:ident),+}) => {
|
||||
$(pub fn $name(&self) -> bool {
|
||||
self.$item.map(|i| i.$name()).unwrap_or(false)
|
||||
})+
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! master_attr_reader {
|
||||
($name:ident, $kind:ty) => {
|
||||
pub fn $name(&self) -> Option<&$kind> {
|
||||
self.$name.as_ref()
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct VersionInformation {
|
||||
eax: u32,
|
||||
|
|
@ -246,8 +248,8 @@ impl VersionInformation {
|
|||
27 => osxsave,
|
||||
28 => avx,
|
||||
29 => f16c,
|
||||
30 => rdrand
|
||||
// 31 - unused
|
||||
30 => rdrand,
|
||||
// 31 - unused,
|
||||
});
|
||||
|
||||
bit!(edx, {
|
||||
|
|
@ -282,10 +284,16 @@ impl VersionInformation {
|
|||
28 => htt,
|
||||
29 => tm,
|
||||
// 30 -reserved
|
||||
31 => pbe
|
||||
31 => pbe,
|
||||
});
|
||||
}
|
||||
|
||||
impl Default for VersionInformation {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for VersionInformation {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
dump!(self, f, "VersionInformation", {
|
||||
|
|
@ -351,7 +359,7 @@ impl fmt::Debug for VersionInformation {
|
|||
ss,
|
||||
htt,
|
||||
tm,
|
||||
pbe
|
||||
pbe,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -373,7 +381,7 @@ impl ExtendedProcessorSignature {
|
|||
// 1-4 reserved
|
||||
5 => lzcnt,
|
||||
// 6-7 reserved
|
||||
8 => prefetchw
|
||||
8 => prefetchw,
|
||||
// 9-31 reserved
|
||||
});
|
||||
|
||||
|
|
@ -386,7 +394,7 @@ impl ExtendedProcessorSignature {
|
|||
26 => gigabyte_pages,
|
||||
27 => rdtscp_and_ia32_tsc_aux,
|
||||
// 28 reserved
|
||||
29 => intel_64_bit_architecture
|
||||
29 => intel_64_bit_architecture,
|
||||
// 30-31 reserved
|
||||
});
|
||||
}
|
||||
|
|
@ -401,14 +409,11 @@ impl fmt::Debug for ExtendedProcessorSignature {
|
|||
execute_disable,
|
||||
gigabyte_pages,
|
||||
rdtscp_and_ia32_tsc_aux,
|
||||
intel_64_bit_architecture
|
||||
intel_64_bit_architecture,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// 3 calls of 4 registers of 4 bytes
|
||||
const BRAND_STRING_LENGTH: usize = 3 * 4 * 4;
|
||||
|
||||
pub struct BrandString {
|
||||
bytes: [u8; BRAND_STRING_LENGTH],
|
||||
}
|
||||
|
|
@ -445,7 +450,7 @@ impl Clone for BrandString {
|
|||
for (d, s) in bytes.iter_mut().zip(self.bytes.iter()) {
|
||||
*d = *s;
|
||||
}
|
||||
BrandString { bytes: bytes }
|
||||
BrandString { bytes }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -501,7 +506,7 @@ impl ThermalPowerManagementInformation {
|
|||
9 => hwp_activity_window,
|
||||
10 => hwp_energy_performance_preference,
|
||||
// 12 - reserved
|
||||
13 => hdc
|
||||
13 => hdc,
|
||||
});
|
||||
|
||||
pub fn number_of_interrupt_thresholds(self) -> u32 {
|
||||
|
|
@ -529,9 +534,7 @@ impl fmt::Debug for ThermalPowerManagementInformation {
|
|||
hwp_activity_window,
|
||||
hwp_energy_performance_preference,
|
||||
hdc,
|
||||
|
||||
number_of_interrupt_thresholds,
|
||||
|
||||
hardware_coordination_feedback,
|
||||
performance_energy_bias
|
||||
})
|
||||
|
|
@ -572,7 +575,7 @@ impl StructuredExtendedInformation {
|
|||
19 => adx,
|
||||
20 => smap,
|
||||
// 21-24 - reserved
|
||||
25 => intel_processor_trace
|
||||
25 => intel_processor_trace,
|
||||
// 26-31 - reserved
|
||||
});
|
||||
|
||||
|
|
@ -601,7 +604,7 @@ impl fmt::Debug for StructuredExtendedInformation {
|
|||
adx,
|
||||
smap,
|
||||
intel_processor_trace,
|
||||
prefetchwt1
|
||||
prefetchwt1,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -619,7 +622,6 @@ pub enum CacheLineAssociativity {
|
|||
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct CacheLine(u32);
|
||||
|
||||
impl CacheLine {
|
||||
fn new() -> CacheLine {
|
||||
let (_, _, c, _) = cpuid(RequestType::CacheLine);
|
||||
|
|
@ -684,7 +686,6 @@ impl fmt::Debug for TimeStampCounter {
|
|||
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct PhysicalAddressSize(u32);
|
||||
|
||||
impl PhysicalAddressSize {
|
||||
fn new() -> PhysicalAddressSize {
|
||||
let (a, _, _, _) = cpuid(RequestType::PhysicalAddressSize);
|
||||
|
|
@ -752,12 +753,12 @@ impl Master {
|
|||
let tpm = when_supported(
|
||||
max_value,
|
||||
RequestType::ThermalPowerManagementInformation,
|
||||
|| ThermalPowerManagementInformation::new(),
|
||||
ThermalPowerManagementInformation::new,
|
||||
);
|
||||
let sei = when_supported(
|
||||
max_value,
|
||||
RequestType::StructuredExtendedInformation,
|
||||
|| StructuredExtendedInformation::new(),
|
||||
StructuredExtendedInformation::new,
|
||||
);
|
||||
|
||||
// Extended information
|
||||
|
|
@ -767,9 +768,8 @@ impl Master {
|
|||
let eps = when_supported(max_value, RequestType::ExtendedProcessorSignature, || {
|
||||
ExtendedProcessorSignature::new()
|
||||
});
|
||||
let brand_string =
|
||||
when_supported(max_value, RequestType::BrandString3, || BrandString::new());
|
||||
let cache_line = when_supported(max_value, RequestType::CacheLine, || CacheLine::new());
|
||||
let brand_string = when_supported(max_value, RequestType::BrandString3, BrandString::new);
|
||||
let cache_line = when_supported(max_value, RequestType::CacheLine, CacheLine::new);
|
||||
let tsc = when_supported(max_value, RequestType::TimeStampCounter, || {
|
||||
TimeStampCounter::new()
|
||||
});
|
||||
|
|
@ -782,8 +782,8 @@ impl Master {
|
|||
thermal_power_management_information: tpm,
|
||||
structured_extended_information: sei,
|
||||
extended_processor_signature: eps,
|
||||
brand_string: brand_string,
|
||||
cache_line: cache_line,
|
||||
brand_string,
|
||||
cache_line,
|
||||
time_stamp_counter: tsc,
|
||||
physical_address_size: pas,
|
||||
}
|
||||
|
|
@ -807,7 +807,7 @@ impl Master {
|
|||
self.brand_string
|
||||
.as_ref()
|
||||
.map(|bs| bs as &str)
|
||||
.or(self.version_information.and_then(|vi| vi.brand_string()))
|
||||
.or_else(|| self.version_information.and_then(|vi| vi.brand_string()))
|
||||
}
|
||||
|
||||
delegate_flag!(version_information, {
|
||||
|
|
@ -869,7 +869,7 @@ impl Master {
|
|||
ss,
|
||||
htt,
|
||||
tm,
|
||||
pbe
|
||||
pbe,
|
||||
});
|
||||
|
||||
delegate_flag!(thermal_power_management_information, {
|
||||
|
|
@ -885,7 +885,7 @@ impl Master {
|
|||
hwp_energy_performance_preference,
|
||||
hdc,
|
||||
hardware_coordination_feedback,
|
||||
performance_energy_bias
|
||||
performance_energy_bias,
|
||||
});
|
||||
|
||||
delegate_flag!(structured_extended_information, {
|
||||
|
|
@ -917,11 +917,18 @@ impl Master {
|
|||
execute_disable,
|
||||
gigabyte_pages,
|
||||
rdtscp_and_ia32_tsc_aux,
|
||||
intel_64_bit_architecture
|
||||
intel_64_bit_architecture,
|
||||
});
|
||||
|
||||
delegate_flag!(time_stamp_counter, { invariant_tsc });
|
||||
}
|
||||
|
||||
impl Default for Master {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
cfg_if! {
|
||||
if #[cfg(any(target_arch = "x86_64", target_arch = "x86"))] {
|
||||
|
|
|
|||
|
|
@ -1,3 +1,15 @@
|
|||
use super::systeminfo::SystemMemory;
|
||||
|
||||
// NOTE: Move to somewhere else
|
||||
pub static KINFO: KernelInfo = KernelInfo {
|
||||
kernel_version: SemanticVersion {
|
||||
major: 0,
|
||||
minor: 0,
|
||||
patch: 0,
|
||||
},
|
||||
memory: SystemMemory { used: 0, total: 0 },
|
||||
};
|
||||
|
||||
// Can be standardized
|
||||
// NOTE: Move this to relib
|
||||
pub struct SemanticVersion {
|
||||
|
|
@ -5,22 +17,13 @@ pub struct SemanticVersion {
|
|||
pub minor: u8,
|
||||
pub patch: u8,
|
||||
}
|
||||
|
||||
impl core::fmt::Display for SemanticVersion {
|
||||
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
||||
write!(f, "v{}.{}.{}", self.major, self.minor, self.patch)
|
||||
}
|
||||
}
|
||||
// NOTE: Move to somewhere else
|
||||
lazy_static! {
|
||||
pub static ref KINFO: KernelInfo = KernelInfo {
|
||||
kernel_version: SemanticVersion {
|
||||
major: 0,
|
||||
minor: 0,
|
||||
patch: 0,
|
||||
},
|
||||
memory: SystemMemory { used: 0, total: 0 }
|
||||
};
|
||||
}
|
||||
|
||||
/// simple info you would want to know in a neofetch like program
|
||||
pub struct KernelInfo {
|
||||
// os: String,
|
||||
|
|
@ -30,5 +33,3 @@ pub struct KernelInfo {
|
|||
// gpu: String,
|
||||
pub memory: SystemMemory,
|
||||
}
|
||||
use super::systeminfo::SystemMemory;
|
||||
use lazy_static::lazy_static;
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ pub struct MailBoxes {
|
|||
flags: u8,
|
||||
mailboxes: [u64; 4],
|
||||
}
|
||||
|
||||
impl MailBoxes {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
|
|
@ -12,15 +13,18 @@ impl MailBoxes {
|
|||
mailboxes: [0; 4],
|
||||
}
|
||||
}
|
||||
|
||||
pub fn reset(&mut self) {
|
||||
self.flags = 0b0000_0000;
|
||||
self.mailboxes = [0; 4];
|
||||
}
|
||||
|
||||
pub fn set_mailbox(&mut self, mailbox_num: u8, mailbox_data: u64) {
|
||||
if let 0..=3 = mailbox_num {
|
||||
self.mailboxes[mailbox_num as usize] = mailbox_data
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_flag(&mut self, flag_num: u8) {
|
||||
match flag_num {
|
||||
0 => {
|
||||
|
|
@ -101,3 +105,9 @@ impl MailBoxes {
|
|||
);
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for MailBoxes {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@
|
|||
pub mod absi;
|
||||
pub mod clip;
|
||||
pub mod futex;
|
||||
// pub mod info;
|
||||
pub mod info;
|
||||
pub mod kinfo;
|
||||
pub mod mail;
|
||||
|
|
@ -11,4 +10,5 @@ pub mod server;
|
|||
pub mod systeminfo;
|
||||
pub mod virtual_memory;
|
||||
pub mod y_compositor;
|
||||
|
||||
pub const BANNER: &str = include_str!("banner.txt");
|
||||
|
|
|
|||
|
|
@ -5,4 +5,3 @@ pub struct Notification {
|
|||
text_body: String,
|
||||
time: u64,
|
||||
}
|
||||
impl Notification {}
|
||||
|
|
|
|||
|
|
@ -1,8 +1,9 @@
|
|||
pub type PackageName = String;
|
||||
use crate::experiments::kinfo::SemanticVersion;
|
||||
|
||||
// Scuffed
|
||||
pub type Hash = u8;
|
||||
pub type PackageName = String;
|
||||
|
||||
pub struct MetaPackage {
|
||||
pub name: u8,
|
||||
pub version: SemanticVersion,
|
||||
|
|
|
|||
|
|
@ -1,10 +1,13 @@
|
|||
pub trait Server {
|
||||
/// Initialize the server and return a number
|
||||
fn initialize() -> u32;
|
||||
|
||||
/// kill the server
|
||||
fn kill() -> bool;
|
||||
|
||||
// put data in the servers outbox
|
||||
fn send();
|
||||
|
||||
// put data in the servers inbox and notify it
|
||||
fn recieve();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,36 +1,6 @@
|
|||
// Can be standardized
|
||||
// NOTE: move the file to the src/ dir
|
||||
pub struct SystemMemory {
|
||||
pub used: u64,
|
||||
pub total: u64,
|
||||
}
|
||||
impl core::fmt::Display for SystemMemory {
|
||||
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
||||
write!(f, "{} Bytes / {} Bytes", self.used, self.total)
|
||||
}
|
||||
}
|
||||
/*
|
||||
pub fn format_system_info() -> core::string::String {
|
||||
let x = format!(
|
||||
"{}
|
||||
OS: AbleOS
|
||||
Host: ComputAble
|
||||
Kernel: {}
|
||||
Uptime: 0:0:0
|
||||
Packages: 0
|
||||
Shell: Ashell
|
||||
Gpu: MIPS32 R4000 R4k
|
||||
Cpu: {}
|
||||
Memory: {}
|
||||
",
|
||||
crate::experiments::BANNER,
|
||||
crate::experiments::kinfo::KINFO.kernel_version,
|
||||
crate::arch::ARCH,
|
||||
crate::experiments::kinfo::KINFO.memory
|
||||
);
|
||||
return x;
|
||||
}
|
||||
// */
|
||||
|
||||
pub const KERNEL_VERSION: &str = env!("CARGO_PKG_VERSION");
|
||||
#[cfg(debug_assertions)]
|
||||
/// A constant to check if the kernel is in debug mode
|
||||
|
|
@ -38,3 +8,14 @@ pub const RELEASE_TYPE: &str = "debug";
|
|||
#[cfg(not(debug_assertions))]
|
||||
/// A constant to check if the kernel is in release mode
|
||||
pub const RELEASE_TYPE: &str = "release";
|
||||
|
||||
pub struct SystemMemory {
|
||||
pub used: u64,
|
||||
pub total: u64,
|
||||
}
|
||||
|
||||
impl core::fmt::Display for SystemMemory {
|
||||
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
||||
write!(f, "{} Bytes / {} Bytes", self.used, self.total)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,4 +4,4 @@ pub struct Scheduler {
|
|||
executables: usize,
|
||||
}
|
||||
|
||||
pub struct RunQueue {}
|
||||
pub struct RunQueue;
|
||||
|
|
|
|||
|
|
@ -1,7 +1,12 @@
|
|||
pub struct Compositor {}
|
||||
|
||||
pub struct Compositor;
|
||||
impl Compositor {
|
||||
pub fn new() -> Self {
|
||||
Self {}
|
||||
Self
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for Compositor {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,16 +1,17 @@
|
|||
use crate::driver_traits::graphics::Point;
|
||||
|
||||
pub type MenuBar = Vec<MenuOption>;
|
||||
|
||||
pub struct MenuOption {
|
||||
symbol: char,
|
||||
}
|
||||
|
||||
pub type MenuBar = Vec<MenuOption>;
|
||||
|
||||
pub struct Window {
|
||||
title: String,
|
||||
position: Point,
|
||||
fullscreen: bool,
|
||||
}
|
||||
|
||||
// all of these should return a result
|
||||
impl Window {
|
||||
pub fn new(title: String, position: Point, fullscreen: bool) -> Self {
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
|
||||
|
|
@ -6,24 +6,17 @@ use ext2::{
|
|||
sector::{SectorSize, Size1024},
|
||||
volume::Volume,
|
||||
};
|
||||
use spin::Lazy;
|
||||
|
||||
fn load_fs() -> Synced<Ext2<Size1024, Vec<u8>>> {
|
||||
let mut volume = Vec::new();
|
||||
volume.extend_from_slice(include_bytes!("../../../userland/root_fs/ext2.img"));
|
||||
pub static FILE_SYSTEM: Lazy<spin::Mutex<Synced<Ext2<Size1024, Vec<u8>>>>> =
|
||||
Lazy::new(|| spin::Mutex::new(load_fs()));
|
||||
|
||||
let fs = Synced::<Ext2<Size1024, _>>::new(volume).unwrap();
|
||||
|
||||
fs
|
||||
}
|
||||
|
||||
// use serde::__private::from_utf8_lossy;
|
||||
|
||||
pub fn walk<'vol, S: SectorSize, V: Volume<u8, S>>(
|
||||
fs: &'vol Synced<Ext2<S, V>>,
|
||||
pub fn walk<S: SectorSize, V: Volume<u8, S>>(
|
||||
fs: &Synced<Ext2<S, V>>,
|
||||
inode: Inode<S, V>,
|
||||
name: String,
|
||||
) {
|
||||
inode.directory().map(|dir| {
|
||||
if let Some(dir) = inode.directory() {
|
||||
for entry in dir {
|
||||
assert!(entry.is_ok());
|
||||
let entry = entry.unwrap();
|
||||
|
|
@ -38,8 +31,12 @@ pub fn walk<'vol, S: SectorSize, V: Volume<u8, S>>(
|
|||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn load_fs() -> Synced<Ext2<Size1024, Vec<u8>>> {
|
||||
let mut volume = Vec::new();
|
||||
volume.extend_from_slice(include_bytes!("../../../userland/root_fs/ext2.img"));
|
||||
|
||||
Synced::<Ext2<Size1024, _>>::new(volume).unwrap()
|
||||
}
|
||||
lazy_static::lazy_static!(
|
||||
pub static ref FILE_SYSTEM:spin::Mutex<Synced<Ext2<Size1024, Vec<u8>>>>= spin::Mutex::new(load_fs());
|
||||
);
|
||||
|
|
|
|||
|
|
@ -1,23 +1,18 @@
|
|||
// use crate::vga_e::VGAE;
|
||||
use ab_glyph::{Font, FontRef, Glyph};
|
||||
|
||||
use shadeable::{evaluate_shader, pixel_format::Rgba64};
|
||||
use spin;
|
||||
// use vga::{colors::Color16, writers::GraphicsWriter};
|
||||
use spin::Lazy;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct ScreenSize {
|
||||
pub x: usize,
|
||||
pub y: usize,
|
||||
}
|
||||
pub static SCREEN_BUFFER: Lazy<spin::Mutex<ScreenBuffer>> =
|
||||
Lazy::new(|| spin::Mutex::new(ScreenBuffer::new(640, 480)));
|
||||
|
||||
const FONT_SCALE: f32 = 1.6;
|
||||
const GLYPH_HEIGHT: f32 = 18.0;
|
||||
const GLYPH_WIDTH: f32 = 10.0;
|
||||
|
||||
lazy_static::lazy_static! {
|
||||
pub static ref SCREEN_BUFFER: spin::Mutex<ScreenBuffer> = spin::Mutex::new(ScreenBuffer::new(640, 480));
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct ScreenSize {
|
||||
pub x: usize,
|
||||
pub y: usize,
|
||||
}
|
||||
|
||||
impl ScreenSize {
|
||||
|
|
@ -34,7 +29,7 @@ pub enum GraphicsReturn {
|
|||
pub struct ScreenBuffer {
|
||||
pub size: ScreenSize,
|
||||
pub clear_color: Rgba64,
|
||||
pub buff: Box<[Rgba64]>, // Vec<Rgba64>,
|
||||
pub buff: Box<[Rgba64]>,
|
||||
}
|
||||
|
||||
impl ScreenBuffer {
|
||||
|
|
@ -46,6 +41,7 @@ impl ScreenBuffer {
|
|||
buff: vec![0u64; x * y].into_boxed_slice(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn draw_filled_circle(&mut self, cx: i32, cy: i32, radius: usize, color: Rgba64) {
|
||||
let r = radius as i32 * 2;
|
||||
for y in 0..640 {
|
||||
|
|
@ -70,6 +66,7 @@ impl ScreenBuffer {
|
|||
}
|
||||
|
||||
pub fn blit(&mut self, _width: usize, _height: usize) {}
|
||||
|
||||
pub fn draw_filled_rect(&mut self, x1: usize, y1: usize, x2: usize, y2: usize, color: Rgba64) {
|
||||
for y in y1..y2 {
|
||||
for x in x1..x2 {
|
||||
|
|
@ -199,38 +196,6 @@ impl ScreenBuffer {
|
|||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
|
||||
pub trait VgaBuffer {
|
||||
fn copy_to_buffer(&self) -> GraphicsReturn;
|
||||
}
|
||||
impl VgaBuffer for ScreenBuffer {
|
||||
fn copy_to_buffer(&self) -> GraphicsReturn {
|
||||
let mode = VGAE.lock();
|
||||
for y in 0..self.size.y {
|
||||
for x in 0..self.size.x {
|
||||
|
||||
use shadeable::pixel_format::into_vga_16;
|
||||
let vga_color = into_vga_16(self.buff[y * self.size.x + x]);
|
||||
// let vga_color = vga::colors::Color16::Cyan;
|
||||
|
||||
if Color16::Cyan != vga_color {
|
||||
mode.set_pixel(x, y, vga_color);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
GraphicsReturn::Ok
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
*/
|
||||
|
||||
pub fn get_coordinates(x1: i32, y1: i32, x2: i32, y2: i32) -> Vec<(usize, usize)> {
|
||||
let mut coordinates: Vec<(usize, usize)> = vec![];
|
||||
|
|
@ -272,5 +237,6 @@ pub fn get_coordinates(x1: i32, y1: i32, x2: i32, y2: i32) -> Vec<(usize, usize)
|
|||
current_y += sy;
|
||||
}
|
||||
}
|
||||
|
||||
coordinates
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,7 @@
|
|||
use lazy_static::lazy_static;
|
||||
use spin::Lazy;
|
||||
|
||||
lazy_static! {
|
||||
pub static ref KERNEL_STATE: spin::Mutex<KernelInternalState> =
|
||||
spin::Mutex::new(KernelInternalState::new());
|
||||
}
|
||||
pub static KERNEL_STATE: Lazy<spin::Mutex<KernelInternalState>> =
|
||||
Lazy::new(|| spin::Mutex::new(KernelInternalState::new()));
|
||||
|
||||
pub struct KernelInternalState {
|
||||
pub hostname: String,
|
||||
|
|
@ -30,3 +28,9 @@ impl KernelInternalState {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for KernelInternalState {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,104 +2,382 @@ use crate::{
|
|||
DecodedKey, HandleControl, KeyCode, KeyboardLayout, LayoutEntry, LayoutEntryKind, Modifiers,
|
||||
};
|
||||
|
||||
// Do not edit this file directly. Instead, create a `Keyboard` and modify that.
|
||||
|
||||
pub struct CustomLayout {
|
||||
mapping: [LayoutEntry; 256],
|
||||
}
|
||||
|
||||
impl Default for CustomLayout {
|
||||
fn default() -> Self {
|
||||
Self::new_us104key()
|
||||
}
|
||||
}
|
||||
#[rustfmt::skip]
|
||||
|
||||
impl CustomLayout {
|
||||
pub fn new_us104key() -> Self {
|
||||
let mut mapping = Self {
|
||||
mapping: [LayoutEntry::default(); 256],
|
||||
};
|
||||
mapping.set(KeyCode::BackTick, LayoutEntry::regular().unshifted('`').shifted('`'));
|
||||
mapping.set(KeyCode::Escape, LayoutEntry::regular().unshifted('\x1B'));
|
||||
mapping.set(KeyCode::Key0, LayoutEntry::regular().unshifted('0').shifted(')'));
|
||||
mapping.set(KeyCode::Key1, LayoutEntry::regular().unshifted('1').shifted('!'));
|
||||
mapping.set(KeyCode::Key2, LayoutEntry::regular().unshifted('2').shifted('@'));
|
||||
mapping.set(KeyCode::Key3, LayoutEntry::regular().unshifted('3').shifted('#'));
|
||||
mapping.set(KeyCode::Key4, LayoutEntry::regular().unshifted('4').shifted('$'));
|
||||
mapping.set(KeyCode::Key5, LayoutEntry::regular().unshifted('5').shifted('%'));
|
||||
mapping.set(KeyCode::Key6, LayoutEntry::regular().unshifted('6').shifted('^'));
|
||||
mapping.set(KeyCode::Key7, LayoutEntry::regular().unshifted('7').shifted('&'));
|
||||
mapping.set(KeyCode::Key8, LayoutEntry::regular().unshifted('8').shifted('*'));
|
||||
mapping.set(KeyCode::Key9, LayoutEntry::regular().unshifted('9').shifted('('));
|
||||
mapping.set(KeyCode::Minus, LayoutEntry::regular().unshifted('-').shifted('_'));
|
||||
mapping.set(KeyCode::Equals, LayoutEntry::regular().unshifted('=').shifted('+'));
|
||||
mapping.set(KeyCode::Backspace, LayoutEntry::regular().all('\x08'));
|
||||
mapping.set(KeyCode::Tab, LayoutEntry::regular().all('\x09'));
|
||||
mapping.set(KeyCode::Q, LayoutEntry::alphabet().low('q').high('Q').raw_unicode('\u{0011}'));
|
||||
mapping.set(KeyCode::W, LayoutEntry::alphabet().low('w').high('W').raw_unicode('\u{0017}'));
|
||||
mapping.set(KeyCode::E, LayoutEntry::alphabet().low('e').high('E').raw_unicode('\u{0005}'));
|
||||
mapping.set(KeyCode::R, LayoutEntry::alphabet().low('r').high('R').raw_unicode('\u{0012}'));
|
||||
mapping.set(KeyCode::T, LayoutEntry::alphabet().low('t').high('T').raw_unicode('\u{0014}'));
|
||||
mapping.set(KeyCode::Y, LayoutEntry::alphabet().low('y').high('Y').raw_unicode('\u{0019}'));
|
||||
mapping.set(KeyCode::U, LayoutEntry::alphabet().low('u').high('U').raw_unicode('\u{0015}'));
|
||||
mapping.set(KeyCode::I, LayoutEntry::alphabet().low('i').high('I').raw_unicode('\u{0009}'));
|
||||
mapping.set(KeyCode::O, LayoutEntry::alphabet().low('o').high('O').raw_unicode('\u{000F}'));
|
||||
mapping.set(KeyCode::P, LayoutEntry::alphabet().low('p').high('P').raw_unicode('\u{0010}'));
|
||||
mapping.set(KeyCode::A, LayoutEntry::alphabet().low('a').high('A').raw_unicode('\u{0001}'));
|
||||
mapping.set(KeyCode::S, LayoutEntry::alphabet().low('s').high('S').raw_unicode('\u{0013}'));
|
||||
mapping.set(KeyCode::D, LayoutEntry::alphabet().low('d').high('D').raw_unicode('\u{0004}'));
|
||||
mapping.set(KeyCode::F, LayoutEntry::alphabet().low('f').high('F').raw_unicode('\u{0006}'));
|
||||
mapping.set(KeyCode::G, LayoutEntry::alphabet().low('g').high('G').raw_unicode('\u{0007}'));
|
||||
mapping.set(KeyCode::H, LayoutEntry::alphabet().low('h').high('H').raw_unicode('\u{0008}'));
|
||||
mapping.set(KeyCode::J, LayoutEntry::alphabet().low('j').high('J').raw_unicode('\u{000A}'));
|
||||
mapping.set(KeyCode::K, LayoutEntry::alphabet().low('k').high('K').raw_unicode('\u{000B}'));
|
||||
mapping.set(KeyCode::L, LayoutEntry::alphabet().low('l').high('L').raw_unicode('\u{000C}'));
|
||||
mapping.set(KeyCode::Z, LayoutEntry::alphabet().low('z').high('Z').raw_unicode('\u{001A}'));
|
||||
mapping.set(KeyCode::X, LayoutEntry::alphabet().low('x').high('X').raw_unicode('\u{0018}'));
|
||||
mapping.set(KeyCode::C, LayoutEntry::alphabet().low('c').high('C').raw_unicode('\u{0003}'));
|
||||
mapping.set(KeyCode::V, LayoutEntry::alphabet().low('v').high('V').raw_unicode('\u{0016}'));
|
||||
mapping.set(KeyCode::B, LayoutEntry::alphabet().low('b').high('B').raw_unicode('\u{0002}'));
|
||||
mapping.set(KeyCode::N, LayoutEntry::alphabet().low('n').high('N').raw_unicode('\u{000E}'));
|
||||
mapping.set(KeyCode::M, LayoutEntry::alphabet().low('m').high('M').raw_unicode('\u{000D}'));
|
||||
mapping.set(KeyCode::BracketSquareLeft, LayoutEntry::regular().unshifted('{').shifted('['));
|
||||
mapping.set(KeyCode::BracketSquareRight, LayoutEntry::regular().unshifted('}').shifted(']'));
|
||||
mapping.set(KeyCode::BackSlash, LayoutEntry::regular().unshifted('|').shifted('\\'));
|
||||
mapping.set(KeyCode::SemiColon, LayoutEntry::regular().unshifted(';').shifted(':'));
|
||||
mapping.set(KeyCode::Quote, LayoutEntry::regular().unshifted('\'').shifted('"'));
|
||||
mapping.set(KeyCode::Enter, LayoutEntry::regular().all('\x0A'));
|
||||
mapping.set(KeyCode::Comma, LayoutEntry::regular().unshifted(',').shifted('<'));
|
||||
mapping.set(KeyCode::Fullstop, LayoutEntry::regular().unshifted('.').shifted('>'));
|
||||
mapping.set(KeyCode::Slash, LayoutEntry::regular().unshifted('/').shifted('?'));
|
||||
mapping.set(KeyCode::Spacebar, LayoutEntry::regular().all(' '));
|
||||
mapping.set(KeyCode::Delete, LayoutEntry::regular().all('\x7F'));
|
||||
mapping.set(KeyCode::NumpadSlash, LayoutEntry::numpad().all('/'));
|
||||
mapping.set(KeyCode::NumpadStar, LayoutEntry::numpad().all('*'));
|
||||
mapping.set(KeyCode::NumpadMinus, LayoutEntry::numpad().all('-'));
|
||||
mapping.set(KeyCode::Numpad7, LayoutEntry::numpad().low('7').high(KeyCode::Home));
|
||||
mapping.set(KeyCode::Numpad8, LayoutEntry::numpad().low('8').high(KeyCode::ArrowUp));
|
||||
mapping.set(KeyCode::Numpad9, LayoutEntry::numpad().low('9').high(KeyCode::PageUp));
|
||||
mapping.set(KeyCode::NumpadPlus, LayoutEntry::numpad().all('+'));
|
||||
mapping.set(KeyCode::Numpad4, LayoutEntry::numpad().low('4').high(KeyCode::ArrowLeft));
|
||||
mapping.set(KeyCode::Numpad5, LayoutEntry::numpad().all('5'));
|
||||
mapping.set(KeyCode::Numpad6, LayoutEntry::numpad().low('6').high(KeyCode::ArrowRight));
|
||||
mapping.set(KeyCode::Numpad1, LayoutEntry::numpad().low('1').high(KeyCode::End));
|
||||
mapping.set(KeyCode::Numpad2, LayoutEntry::numpad().low('2').high(KeyCode::ArrowDown));
|
||||
mapping.set(KeyCode::Numpad3, LayoutEntry::numpad().low('3').high(KeyCode::PageDown));
|
||||
mapping.set(KeyCode::Numpad0, LayoutEntry::numpad().low('0').high(KeyCode::Insert));
|
||||
mapping.set(KeyCode::NumpadPeriod, LayoutEntry::numpad().low('.').high('\x7F'));
|
||||
mapping.set(KeyCode::NumpadEnter, LayoutEntry::numpad().all('\x0A'));
|
||||
mapping
|
||||
}
|
||||
pub fn new_us105key() -> Self {
|
||||
let mut mapping = Self::new_us104key();
|
||||
mapping.set(KeyCode::BackTick, LayoutEntry::regular().unshifted('`').shifted('¬').altgr('|'));
|
||||
mapping.set(KeyCode::Key2, LayoutEntry::regular().unshifted('2').shifted('"'));
|
||||
mapping.set(KeyCode::Quote, LayoutEntry::regular().unshifted('\'').shifted('@'));
|
||||
mapping.set(KeyCode::Key3, LayoutEntry::regular().unshifted('3').shifted('£'));
|
||||
mapping.set(KeyCode::BackTick, LayoutEntry::regular().unshifted('4').shifted('$').altgr('€'));
|
||||
mapping.set(KeyCode::HashTilde, LayoutEntry::regular().unshifted('#').shifted('~'));
|
||||
mapping
|
||||
}
|
||||
pub fn new_us104key() -> Self {
|
||||
let mut mapping = Self {
|
||||
mapping: [LayoutEntry::default(); 256],
|
||||
};
|
||||
|
||||
mapping.set(
|
||||
KeyCode::BackTick,
|
||||
LayoutEntry::regular().unshifted('`').shifted('`'),
|
||||
);
|
||||
mapping.set(KeyCode::Escape, LayoutEntry::regular().unshifted('\x1B'));
|
||||
mapping.set(
|
||||
KeyCode::Key0,
|
||||
LayoutEntry::regular().unshifted('0').shifted(')'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Key1,
|
||||
LayoutEntry::regular().unshifted('1').shifted('!'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Key2,
|
||||
LayoutEntry::regular().unshifted('2').shifted('@'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Key3,
|
||||
LayoutEntry::regular().unshifted('3').shifted('#'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Key4,
|
||||
LayoutEntry::regular().unshifted('4').shifted('$'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Key5,
|
||||
LayoutEntry::regular().unshifted('5').shifted('%'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Key6,
|
||||
LayoutEntry::regular().unshifted('6').shifted('^'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Key7,
|
||||
LayoutEntry::regular().unshifted('7').shifted('&'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Key8,
|
||||
LayoutEntry::regular().unshifted('8').shifted('*'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Key9,
|
||||
LayoutEntry::regular().unshifted('9').shifted('('),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Minus,
|
||||
LayoutEntry::regular().unshifted('-').shifted('_'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Equals,
|
||||
LayoutEntry::regular().unshifted('=').shifted('+'),
|
||||
);
|
||||
mapping.set(KeyCode::Backspace, LayoutEntry::regular().all('\x08'));
|
||||
mapping.set(KeyCode::Tab, LayoutEntry::regular().all('\x09'));
|
||||
mapping.set(
|
||||
KeyCode::Q,
|
||||
LayoutEntry::alphabet()
|
||||
.low('q')
|
||||
.high('Q')
|
||||
.raw_unicode('\u{0011}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::W,
|
||||
LayoutEntry::alphabet()
|
||||
.low('w')
|
||||
.high('W')
|
||||
.raw_unicode('\u{0017}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::E,
|
||||
LayoutEntry::alphabet()
|
||||
.low('e')
|
||||
.high('E')
|
||||
.raw_unicode('\u{0005}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::R,
|
||||
LayoutEntry::alphabet()
|
||||
.low('r')
|
||||
.high('R')
|
||||
.raw_unicode('\u{0012}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::T,
|
||||
LayoutEntry::alphabet()
|
||||
.low('t')
|
||||
.high('T')
|
||||
.raw_unicode('\u{0014}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Y,
|
||||
LayoutEntry::alphabet()
|
||||
.low('y')
|
||||
.high('Y')
|
||||
.raw_unicode('\u{0019}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::U,
|
||||
LayoutEntry::alphabet()
|
||||
.low('u')
|
||||
.high('U')
|
||||
.raw_unicode('\u{0015}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::I,
|
||||
LayoutEntry::alphabet()
|
||||
.low('i')
|
||||
.high('I')
|
||||
.raw_unicode('\u{0009}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::O,
|
||||
LayoutEntry::alphabet()
|
||||
.low('o')
|
||||
.high('O')
|
||||
.raw_unicode('\u{000F}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::P,
|
||||
LayoutEntry::alphabet()
|
||||
.low('p')
|
||||
.high('P')
|
||||
.raw_unicode('\u{0010}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::A,
|
||||
LayoutEntry::alphabet()
|
||||
.low('a')
|
||||
.high('A')
|
||||
.raw_unicode('\u{0001}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::S,
|
||||
LayoutEntry::alphabet()
|
||||
.low('s')
|
||||
.high('S')
|
||||
.raw_unicode('\u{0013}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::D,
|
||||
LayoutEntry::alphabet()
|
||||
.low('d')
|
||||
.high('D')
|
||||
.raw_unicode('\u{0004}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::F,
|
||||
LayoutEntry::alphabet()
|
||||
.low('f')
|
||||
.high('F')
|
||||
.raw_unicode('\u{0006}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::G,
|
||||
LayoutEntry::alphabet()
|
||||
.low('g')
|
||||
.high('G')
|
||||
.raw_unicode('\u{0007}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::H,
|
||||
LayoutEntry::alphabet()
|
||||
.low('h')
|
||||
.high('H')
|
||||
.raw_unicode('\u{0008}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::J,
|
||||
LayoutEntry::alphabet()
|
||||
.low('j')
|
||||
.high('J')
|
||||
.raw_unicode('\u{000A}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::K,
|
||||
LayoutEntry::alphabet()
|
||||
.low('k')
|
||||
.high('K')
|
||||
.raw_unicode('\u{000B}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::L,
|
||||
LayoutEntry::alphabet()
|
||||
.low('l')
|
||||
.high('L')
|
||||
.raw_unicode('\u{000C}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Z,
|
||||
LayoutEntry::alphabet()
|
||||
.low('z')
|
||||
.high('Z')
|
||||
.raw_unicode('\u{001A}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::X,
|
||||
LayoutEntry::alphabet()
|
||||
.low('x')
|
||||
.high('X')
|
||||
.raw_unicode('\u{0018}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::C,
|
||||
LayoutEntry::alphabet()
|
||||
.low('c')
|
||||
.high('C')
|
||||
.raw_unicode('\u{0003}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::V,
|
||||
LayoutEntry::alphabet()
|
||||
.low('v')
|
||||
.high('V')
|
||||
.raw_unicode('\u{0016}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::B,
|
||||
LayoutEntry::alphabet()
|
||||
.low('b')
|
||||
.high('B')
|
||||
.raw_unicode('\u{0002}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::N,
|
||||
LayoutEntry::alphabet()
|
||||
.low('n')
|
||||
.high('N')
|
||||
.raw_unicode('\u{000E}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::M,
|
||||
LayoutEntry::alphabet()
|
||||
.low('m')
|
||||
.high('M')
|
||||
.raw_unicode('\u{000D}'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::BracketSquareLeft,
|
||||
LayoutEntry::regular().unshifted('{').shifted('['),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::BracketSquareRight,
|
||||
LayoutEntry::regular().unshifted('}').shifted(']'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::BackSlash,
|
||||
LayoutEntry::regular().unshifted('|').shifted('\\'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::SemiColon,
|
||||
LayoutEntry::regular().unshifted(';').shifted(':'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Quote,
|
||||
LayoutEntry::regular().unshifted('\'').shifted('"'),
|
||||
);
|
||||
mapping.set(KeyCode::Enter, LayoutEntry::regular().all('\x0A'));
|
||||
mapping.set(
|
||||
KeyCode::Comma,
|
||||
LayoutEntry::regular().unshifted(',').shifted('<'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Fullstop,
|
||||
LayoutEntry::regular().unshifted('.').shifted('>'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Slash,
|
||||
LayoutEntry::regular().unshifted('/').shifted('?'),
|
||||
);
|
||||
mapping.set(KeyCode::Spacebar, LayoutEntry::regular().all(' '));
|
||||
mapping.set(KeyCode::Delete, LayoutEntry::regular().all('\x7F'));
|
||||
mapping.set(KeyCode::NumpadSlash, LayoutEntry::numpad().all('/'));
|
||||
mapping.set(KeyCode::NumpadStar, LayoutEntry::numpad().all('*'));
|
||||
mapping.set(KeyCode::NumpadMinus, LayoutEntry::numpad().all('-'));
|
||||
mapping.set(
|
||||
KeyCode::Numpad7,
|
||||
LayoutEntry::numpad().low('7').high(KeyCode::Home),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Numpad8,
|
||||
LayoutEntry::numpad().low('8').high(KeyCode::ArrowUp),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Numpad9,
|
||||
LayoutEntry::numpad().low('9').high(KeyCode::PageUp),
|
||||
);
|
||||
mapping.set(KeyCode::NumpadPlus, LayoutEntry::numpad().all('+'));
|
||||
mapping.set(
|
||||
KeyCode::Numpad4,
|
||||
LayoutEntry::numpad().low('4').high(KeyCode::ArrowLeft),
|
||||
);
|
||||
mapping.set(KeyCode::Numpad5, LayoutEntry::numpad().all('5'));
|
||||
mapping.set(
|
||||
KeyCode::Numpad6,
|
||||
LayoutEntry::numpad().low('6').high(KeyCode::ArrowRight),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Numpad1,
|
||||
LayoutEntry::numpad().low('1').high(KeyCode::End),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Numpad2,
|
||||
LayoutEntry::numpad().low('2').high(KeyCode::ArrowDown),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Numpad3,
|
||||
LayoutEntry::numpad().low('3').high(KeyCode::PageDown),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Numpad0,
|
||||
LayoutEntry::numpad().low('0').high(KeyCode::Insert),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::NumpadPeriod,
|
||||
LayoutEntry::numpad().low('.').high('\x7F'),
|
||||
);
|
||||
mapping.set(KeyCode::NumpadEnter, LayoutEntry::numpad().all('\x0A'));
|
||||
mapping
|
||||
}
|
||||
pub fn new_us105key() -> Self {
|
||||
let mut mapping = Self::new_us104key();
|
||||
mapping.set(
|
||||
KeyCode::BackTick,
|
||||
LayoutEntry::regular()
|
||||
.unshifted('`')
|
||||
.shifted('¬')
|
||||
.altgr('|'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Key2,
|
||||
LayoutEntry::regular().unshifted('2').shifted('"'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Quote,
|
||||
LayoutEntry::regular().unshifted('\'').shifted('@'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::Key3,
|
||||
LayoutEntry::regular().unshifted('3').shifted('£'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::BackTick,
|
||||
LayoutEntry::regular()
|
||||
.unshifted('4')
|
||||
.shifted('$')
|
||||
.altgr('€'),
|
||||
);
|
||||
mapping.set(
|
||||
KeyCode::HashTilde,
|
||||
LayoutEntry::regular().unshifted('#').shifted('~'),
|
||||
);
|
||||
mapping
|
||||
}
|
||||
|
||||
pub fn set(&mut self, pos: KeyCode, entry: LayoutEntry) {
|
||||
self.mapping[pos as usize] = entry;
|
||||
}
|
||||
}
|
||||
|
||||
impl KeyboardLayout for CustomLayout {
|
||||
fn map_keycode(
|
||||
&self,
|
||||
|
|
@ -164,13 +442,3 @@ impl KeyboardLayout for CustomLayout {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Note(elfein) Not super hard to get right, but still- DO NOT TOUCH
|
||||
impl CustomLayout {
|
||||
// See how hard this is to get right?
|
||||
// See the complexity of all the methods?
|
||||
// Yeah- if you don't know what you're doing, ask before you touch!
|
||||
pub fn set(&mut self, pos: KeyCode, entry: LayoutEntry) {
|
||||
self.mapping[pos as usize] = entry;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,17 +6,20 @@ pub struct CustomScancodeSet {
|
|||
single_byte: [Option<KeyCode>; 256],
|
||||
extended: [Option<KeyCode>; 256],
|
||||
}
|
||||
|
||||
impl Default for CustomScancodeSet {
|
||||
fn default() -> Self {
|
||||
Self::scancode_set1()
|
||||
}
|
||||
}
|
||||
|
||||
impl CustomScancodeSet {
|
||||
pub fn scancode_set1() -> Self {
|
||||
let mut scancode_set = Self {
|
||||
single_byte: [None; 256],
|
||||
extended: [None; 256],
|
||||
};
|
||||
|
||||
scancode_set.single_byte[0x01] = Some(KeyCode::Escape); // 01
|
||||
scancode_set.single_byte[0x02] = Some(KeyCode::Key1); // 02
|
||||
scancode_set.single_byte[0x03] = Some(KeyCode::Key2); // 03
|
||||
|
|
@ -181,6 +184,7 @@ impl CustomScancodeSet {
|
|||
}
|
||||
scancode_set
|
||||
}
|
||||
|
||||
pub fn scancode_set2() -> Self {
|
||||
Self {
|
||||
single_byte: [None; 256],
|
||||
|
|
@ -188,6 +192,7 @@ impl CustomScancodeSet {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ScancodeSet for CustomScancodeSet {
|
||||
fn advance_state(&self, state: &mut DecodeState, code: u8) -> Result<Option<KeyEvent>, Error> {
|
||||
match *state {
|
||||
|
|
@ -238,6 +243,7 @@ impl ScancodeSet for CustomScancodeSet {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn map_scancode(&self, code: u8) -> Result<KeyCode, Error> {
|
||||
if let Some(kc) = self.single_byte[code as usize] {
|
||||
Ok(kc)
|
||||
|
|
@ -245,6 +251,7 @@ impl ScancodeSet for CustomScancodeSet {
|
|||
Err(Error::UnknownKeyCode)
|
||||
}
|
||||
}
|
||||
|
||||
fn map_extended_scancode(&self, code: u8) -> Result<KeyCode, Error> {
|
||||
if let Some(kc) = self.extended[code as usize] {
|
||||
Ok(kc)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
use super::DecodedKey;
|
||||
use crate::DecodedKey;
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub enum LayoutEntryKind {
|
||||
|
|
@ -32,6 +32,7 @@ impl LayoutEntry {
|
|||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn numpad() -> Self {
|
||||
Self {
|
||||
|
|
@ -39,6 +40,7 @@ impl LayoutEntry {
|
|||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn alphabet() -> Self {
|
||||
Self {
|
||||
|
|
@ -46,36 +48,43 @@ impl LayoutEntry {
|
|||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn unshifted(mut self, c: impl Into<DecodedKey>) -> Self {
|
||||
self.unshifted = Some(c.into());
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn shifted(mut self, c: impl Into<DecodedKey>) -> Self {
|
||||
self.shifted = Some(c.into());
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn altgr(mut self, c: impl Into<DecodedKey>) -> Self {
|
||||
self.altgr = Some(c.into());
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn raw_unicode(mut self, c: impl Into<DecodedKey>) -> Self {
|
||||
self.raw_unicode = Some(c.into());
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn locked(mut self, c: impl Into<DecodedKey>) -> Self {
|
||||
self.locked = Some(c.into());
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn locked_shifted(mut self, c: impl Into<DecodedKey>) -> Self {
|
||||
self.locked_shifted = Some(c.into());
|
||||
self
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn common(self, c: impl Into<DecodedKey> + Clone) -> Self {
|
||||
self.unshifted(c.clone())
|
||||
|
|
@ -83,14 +92,17 @@ impl LayoutEntry {
|
|||
.locked(c.clone())
|
||||
.locked_shifted(c)
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn low(self, c: impl Into<DecodedKey> + Clone) -> Self {
|
||||
self.unshifted(c.clone()).locked_shifted(c)
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn high(self, c: impl Into<DecodedKey> + Clone) -> Self {
|
||||
self.shifted(c.clone()).locked(c)
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn all(self, c: impl Into<DecodedKey> + Clone) -> Self {
|
||||
self.unshifted(c.clone())
|
||||
|
|
|
|||
|
|
@ -1,5 +1,3 @@
|
|||
use super::*;
|
||||
|
||||
mod custom_layout;
|
||||
mod custom_scancode_set;
|
||||
mod layout_entry;
|
||||
|
|
|
|||
|
|
@ -1,13 +1,17 @@
|
|||
#![allow(dead_code)]
|
||||
|
||||
mod abstractions;
|
||||
mod small_types;
|
||||
mod traits;
|
||||
|
||||
pub use abstractions::*;
|
||||
pub use small_types::*;
|
||||
pub use traits::*;
|
||||
const KEYCODE_BITS: u8 = 11;
|
||||
|
||||
const EXTENDED_KEY_CODE: u8 = 0xE0;
|
||||
const KEYCODE_BITS: u8 = 11;
|
||||
const KEY_RELEASE_CODE: u8 = 0xF0;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Keyboard<T, S>
|
||||
where
|
||||
|
|
@ -22,6 +26,7 @@ where
|
|||
layout: T,
|
||||
set: S,
|
||||
}
|
||||
|
||||
impl<T, S> Keyboard<T, S>
|
||||
where
|
||||
T: KeyboardLayout + Default,
|
||||
|
|
@ -47,14 +52,17 @@ where
|
|||
set: S::default(),
|
||||
}
|
||||
}
|
||||
// /// Change the Ctrl key mapping.
|
||||
|
||||
/// Change the Ctrl key mapping.
|
||||
pub fn set_ctrl_handling(&mut self, new_value: HandleControl) {
|
||||
self.handle_ctrl = new_value;
|
||||
}
|
||||
// /// Get the current Ctrl key mapping.
|
||||
|
||||
/// Get the current Ctrl key mapping.
|
||||
pub fn get_ctrl_handling(&self) -> HandleControl {
|
||||
self.handle_ctrl
|
||||
}
|
||||
|
||||
/// Clears the bit register.
|
||||
///
|
||||
/// Call this when there is a timeout reading data from the keyboard.
|
||||
|
|
@ -63,6 +71,7 @@ where
|
|||
self.num_bits = 0;
|
||||
self.decode_state = DecodeState::Start;
|
||||
}
|
||||
|
||||
/// Processes a 16-bit word from the keyboard.
|
||||
///
|
||||
/// * The start bit (0) must be in bit 0.
|
||||
|
|
@ -74,6 +83,7 @@ where
|
|||
let byte = self.check_word(word)?;
|
||||
self.add_byte(byte)
|
||||
}
|
||||
|
||||
/// Processes an 8-bit byte from the keyboard.
|
||||
///
|
||||
/// We assume the start, stop and parity bits have been processed and
|
||||
|
|
@ -81,6 +91,7 @@ where
|
|||
pub fn add_byte(&mut self, byte: u8) -> Result<Option<KeyEvent>, Error> {
|
||||
self.set.advance_state(&mut self.decode_state, byte)
|
||||
}
|
||||
|
||||
/// Shift a bit into the register.
|
||||
///
|
||||
/// Call this /or/ call `add_word` - don't call both.
|
||||
|
|
@ -97,6 +108,7 @@ where
|
|||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
/// Processes a `KeyEvent` returned from `add_bit`, `add_byte` or `add_word`
|
||||
/// and produces a decoded key.
|
||||
///
|
||||
|
|
@ -199,12 +211,15 @@ where
|
|||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn get_bit(&self, word: u16, offset: usize) -> bool {
|
||||
((word >> offset) & 0x0001) != 0
|
||||
}
|
||||
|
||||
fn has_even_number_bits(&self, data: u8) -> bool {
|
||||
(data.count_ones() % 2) == 0
|
||||
}
|
||||
|
||||
/// Check 11-bit word has 1 start bit, 1 stop bit and an odd parity bit.
|
||||
fn check_word(&self, word: u16) -> Result<u8, Error> {
|
||||
let start_bit = self.get_bit(word, 0);
|
||||
|
|
@ -222,9 +237,11 @@ where
|
|||
if need_parity != parity_bit {
|
||||
return Err(Error::ParityError);
|
||||
}
|
||||
|
||||
Ok(data)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse_format() {
|
||||
let test = include_str!("../../keymaps/qwerty.keymap").lines();
|
||||
// r#"0-NONE\n1-HI#Says HI"#
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
#![allow(non_snake_case)]
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Modifiers {
|
||||
pub lshift: bool,
|
||||
|
|
@ -9,17 +10,21 @@ pub struct Modifiers {
|
|||
pub capslock: bool,
|
||||
pub alt_gr: bool,
|
||||
}
|
||||
|
||||
impl Modifiers {
|
||||
pub fn is_shifted(&self) -> bool {
|
||||
self.lshift | self.rshift
|
||||
}
|
||||
|
||||
pub fn is_ctrl(&self) -> bool {
|
||||
self.lctrl | self.rctrl
|
||||
}
|
||||
|
||||
pub fn is_caps(&self) -> bool {
|
||||
self.capslock
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
||||
pub enum KeyState {
|
||||
Up,
|
||||
|
|
@ -30,11 +35,13 @@ pub struct KeyEvent {
|
|||
pub code: KeyCode,
|
||||
pub state: KeyState,
|
||||
}
|
||||
|
||||
impl KeyEvent {
|
||||
pub fn new(code: KeyCode, state: KeyState) -> KeyEvent {
|
||||
KeyEvent { code, state }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
||||
pub enum HandleControl {
|
||||
/// If either Ctrl key is held down, convert the letters A through Z into
|
||||
|
|
@ -45,6 +52,7 @@ pub enum HandleControl {
|
|||
/// and leave the letters as letters.
|
||||
Ignore,
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
|
||||
pub enum DecodeState {
|
||||
Start,
|
||||
|
|
@ -52,6 +60,7 @@ pub enum DecodeState {
|
|||
Release,
|
||||
ExtendedRelease,
|
||||
}
|
||||
|
||||
/// Indicates different error conditions.
|
||||
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
||||
pub enum Error {
|
||||
|
|
@ -61,6 +70,7 @@ pub enum Error {
|
|||
UnknownKeyCode,
|
||||
InvalidState,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
|
||||
#[repr(u8)]
|
||||
pub enum DecodedKeyKind {
|
||||
|
|
@ -73,6 +83,7 @@ pub struct DecodedKey {
|
|||
pub kind: DecodedKeyKind,
|
||||
pub value: u32,
|
||||
}
|
||||
|
||||
impl From<char> for DecodedKey {
|
||||
fn from(ch: char) -> Self {
|
||||
Self {
|
||||
|
|
@ -81,6 +92,7 @@ impl From<char> for DecodedKey {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<KeyCode> for DecodedKey {
|
||||
fn from(kc: KeyCode) -> Self {
|
||||
Self {
|
||||
|
|
@ -89,6 +101,7 @@ impl From<KeyCode> for DecodedKey {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl DecodedKey {
|
||||
pub const ZERO: Self = Self {
|
||||
kind: DecodedKeyKind::Unicode,
|
||||
|
|
@ -107,6 +120,7 @@ impl DecodedKey {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! keycode_enum {
|
||||
(@get_last $Variant:ident) => {
|
||||
Self::$Variant
|
||||
|
|
@ -134,6 +148,7 @@ macro_rules! keycode_enum {
|
|||
keycode_enum!($($Variant=$Value,)* );
|
||||
};
|
||||
}
|
||||
|
||||
// This will be a way to map keys to other keys / keyyngs / macros
|
||||
keycode_enum! {
|
||||
AltLeft = 0x00,
|
||||
|
|
|
|||
|
|
@ -1,13 +1,18 @@
|
|||
use super::*;
|
||||
use super::Error;
|
||||
use crate::{DecodeState, DecodedKey, HandleControl, KeyCode, KeyEvent, Modifiers};
|
||||
|
||||
pub trait ScancodeSet {
|
||||
/// Handles the state logic for the decoding of scan codes into key events.
|
||||
fn advance_state(&self, state: &mut DecodeState, code: u8) -> Result<Option<KeyEvent>, Error>;
|
||||
|
||||
/// Convert a Scan Code set X byte to our 'KeyType' enum
|
||||
fn map_scancode(&self, code: u8) -> Result<KeyCode, Error>;
|
||||
|
||||
/// Convert a Scan Code Set X extended byte (prefixed E0) to our `KeyType`
|
||||
/// enum.
|
||||
fn map_extended_scancode(&self, code: u8) -> Result<KeyCode, Error>;
|
||||
}
|
||||
|
||||
pub trait KeyboardLayout {
|
||||
/// Convert a `KeyType` enum to a Unicode character, if possible.
|
||||
/// `KeyType::A` maps to `Some('a')` (or `Some('A')` if shifted), while
|
||||
|
|
|
|||
|
|
@ -1,23 +1,18 @@
|
|||
#![allow(clippy::empty_loop)]
|
||||
|
||||
// use acpi::AcpiTables;
|
||||
// use x86_64::instructions::interrupts::{disable, enable};
|
||||
|
||||
// use crate::{scratchpad, SCHEDULER, SCREEN_BUFFER};
|
||||
|
||||
use {
|
||||
crate::{
|
||||
arch::{init, sloop},
|
||||
relib::network::socket::{SimpleSock, Socket},
|
||||
scratchpad,
|
||||
},
|
||||
lazy_static::lazy_static,
|
||||
use crate::info::master;
|
||||
use crate::scheduler::SCHEDULER;
|
||||
use crate::{
|
||||
arch::{init, sloop},
|
||||
relib::network::socket::{SimpleSock, Socket},
|
||||
scratchpad,
|
||||
};
|
||||
use crate::{boot_conf::KernelConfig, systeminfo::RELEASE_TYPE};
|
||||
use kernel::KERNEL_VERSION;
|
||||
use spin::Lazy;
|
||||
|
||||
lazy_static! {
|
||||
// TODO: Change this structure to allow for multiple cores loaded
|
||||
pub static ref KERNEL_CONF: KernelConfig = KernelConfig::new();
|
||||
}
|
||||
// TODO: Change this structure to allow for multiple cores loaded
|
||||
pub static KERNEL_CONF: Lazy<KernelConfig> = Lazy::new(KernelConfig::new);
|
||||
|
||||
/// The main entry point of the kernel
|
||||
#[no_mangle]
|
||||
|
|
@ -29,7 +24,7 @@ pub fn kernel_main() -> ! {
|
|||
} else {
|
||||
log::set_max_level(log::LevelFilter::Off);
|
||||
}
|
||||
let mut scheduler = SCHEDULER.lock();
|
||||
let scheduler = SCHEDULER.lock();
|
||||
for proc in &scheduler.execution_queue {
|
||||
trace!("{:?}", proc);
|
||||
}
|
||||
|
|
@ -57,12 +52,3 @@ pub fn log_version_data() {
|
|||
master().unwrap().brand_string().unwrap()
|
||||
);
|
||||
}
|
||||
|
||||
use crate::info::master;
|
||||
|
||||
use kernel::KERNEL_VERSION;
|
||||
|
||||
use crate::scheduler::SCHEDULER;
|
||||
use crate::{
|
||||
boot_conf::KernelConfig, scheduler::capabilities::FileAccess, systeminfo::RELEASE_TYPE,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -4,109 +4,80 @@
|
|||
//!
|
||||
|
||||
#![no_std]
|
||||
#![feature(
|
||||
abi_x86_interrupt,
|
||||
asm_sym,
|
||||
alloc_error_handler,
|
||||
core_intrinsics,
|
||||
exclusive_range_pattern,
|
||||
lang_items,
|
||||
naked_functions,
|
||||
slice_pattern,
|
||||
prelude_import
|
||||
)]
|
||||
#![feature(abi_x86_interrupt)]
|
||||
#![feature(alloc_error_handler)]
|
||||
#![feature(prelude_import)]
|
||||
|
||||
#[macro_use]
|
||||
pub extern crate log;
|
||||
|
||||
pub extern crate alloc;
|
||||
pub extern crate externc_libm as libm;
|
||||
|
||||
/// Contains architecture specific code for aarch64.
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
#[path = "arch/aarch64/mod.rs"]
|
||||
pub mod arch;
|
||||
|
||||
/// Contains architecture specific code for x86_64.
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
#[path = "arch/x86_64/mod.rs"]
|
||||
pub mod arch;
|
||||
|
||||
/// Contains architecture specific code for riscv64.
|
||||
#[cfg(target_arch = "riscv64")]
|
||||
#[path = "arch/riscv/mod.rs"]
|
||||
pub mod arch;
|
||||
|
||||
#[macro_use]
|
||||
pub mod print;
|
||||
pub mod devices;
|
||||
pub mod rhai_shell;
|
||||
pub mod wasm_jumploader;
|
||||
/// Contains architecture specific code for x86_64.
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
#[path = "arch/x86_64/mod.rs"]
|
||||
pub mod arch;
|
||||
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
pub mod port_io;
|
||||
|
||||
#[macro_use]
|
||||
pub mod serial_print;
|
||||
pub mod time;
|
||||
pub mod print;
|
||||
|
||||
#[macro_use]
|
||||
pub extern crate log;
|
||||
pub mod serial_print;
|
||||
|
||||
/////////////
|
||||
// Modules //
|
||||
/////////////
|
||||
pub mod allocator;
|
||||
pub mod boot_conf;
|
||||
pub mod devices;
|
||||
pub mod driver_traits;
|
||||
pub mod experiments;
|
||||
pub mod filesystem;
|
||||
pub mod graphics;
|
||||
pub mod kernel_state;
|
||||
pub mod keyboard;
|
||||
pub mod kmain;
|
||||
pub mod logger;
|
||||
pub mod relib;
|
||||
pub mod scheduler;
|
||||
mod unicode_utils;
|
||||
pub mod utils;
|
||||
// pub mod vga_e;
|
||||
pub mod wasm;
|
||||
|
||||
pub extern crate alloc;
|
||||
pub extern crate externc_libm as libm;
|
||||
|
||||
//////////////////
|
||||
// Re-exports ///
|
||||
////////////////
|
||||
pub use allocator::*;
|
||||
pub use driver_traits::*;
|
||||
pub use experiments::*;
|
||||
pub use graphics::*;
|
||||
pub use kernel_state::*;
|
||||
pub use keyboard::*;
|
||||
pub use logger::*;
|
||||
pub use relib::*;
|
||||
// pub use scheduler::*;
|
||||
pub use utils::*;
|
||||
// pub use vga_e::*;
|
||||
pub use wasm::*;
|
||||
pub mod boot_conf;
|
||||
pub mod virtio;
|
||||
pub use virtio::*;
|
||||
|
||||
// pub mod alias_table;
|
||||
// pub use alias_table::*;
|
||||
|
||||
// pub mod tests;
|
||||
// pub use tests::*;
|
||||
|
||||
pub mod scratchpad;
|
||||
pub use scratchpad::*;
|
||||
pub mod filesystem;
|
||||
|
||||
///////////////
|
||||
/// Kernel ///
|
||||
/////////////
|
||||
pub use kernel;
|
||||
pub use kernel::messaging;
|
||||
pub use kernel::panic;
|
||||
|
||||
pub mod prelude;
|
||||
pub mod relib;
|
||||
pub mod rhai_shell;
|
||||
pub mod scheduler;
|
||||
pub mod scratchpad;
|
||||
pub mod stdio;
|
||||
pub mod time;
|
||||
pub mod utils;
|
||||
pub mod virtio;
|
||||
pub mod wasm;
|
||||
pub mod wasm_jumploader;
|
||||
|
||||
mod unicode_utils;
|
||||
|
||||
#[prelude_import]
|
||||
pub use prelude::rust_2021::*;
|
||||
|
||||
pub mod stdio;
|
||||
pub use allocator::*;
|
||||
pub use driver_traits::*;
|
||||
pub use experiments::*;
|
||||
pub use graphics::*;
|
||||
pub use kernel;
|
||||
pub use kernel::messaging;
|
||||
pub use kernel::panic;
|
||||
pub use kernel_state::*;
|
||||
pub use keyboard::*;
|
||||
pub use logger::*;
|
||||
pub use relib::*;
|
||||
pub use scratchpad::*;
|
||||
pub use utils::*;
|
||||
pub use virtio::*;
|
||||
pub use wasm::*;
|
||||
|
|
|
|||
|
|
@ -1,34 +1,31 @@
|
|||
use crate::boot_conf;
|
||||
use crate::kmain::KERNEL_CONF;
|
||||
use crate::network::socket::{SimpleSock, Socket};
|
||||
use crate::time::fetch_time;
|
||||
use core::sync::atomic::Ordering;
|
||||
|
||||
use kernel::TICK;
|
||||
use lliw::{Fg, Reset};
|
||||
use log::{Level, Metadata, Record};
|
||||
use log::{LevelFilter, SetLoggerError};
|
||||
|
||||
struct SimpleLogger;
|
||||
static LOGGER: SimpleLogger = SimpleLogger;
|
||||
// TODO: Rebuild this to take advantage of sockets
|
||||
// DETAIL: Log to a socket instead of the screen
|
||||
// So that we can log in the kernel and display it in userland
|
||||
// So that we can log in the kernel and display it in userland
|
||||
struct SimpleLogger;
|
||||
impl log::Log for SimpleLogger {
|
||||
fn enabled(&self, metadata: &Metadata) -> bool {
|
||||
metadata.level() <= Level::Trace
|
||||
}
|
||||
fn log(&self, record: &Record) {
|
||||
if self.enabled(record.metadata()) {
|
||||
let color;
|
||||
|
||||
let time_float = fetch_time();
|
||||
|
||||
match record.level() {
|
||||
log::Level::Error => color = (Fg::Red, "$RED$"),
|
||||
log::Level::Warn => color = (Fg::LightYellow, "$LIGHTYELLOW$"),
|
||||
log::Level::Info => color = (Fg::LightWhite, "$LIGHTGRAY$"),
|
||||
log::Level::Debug => color = (Fg::Blue, "$BLUE$"),
|
||||
log::Level::Trace => color = (Fg::Yellow, "$YELLOW$"),
|
||||
}
|
||||
let color = match record.level() {
|
||||
log::Level::Error => (Fg::Red, "$RED$"),
|
||||
log::Level::Warn => (Fg::LightYellow, "$LIGHTYELLOW$"),
|
||||
log::Level::Info => (Fg::LightWhite, "$LIGHTGRAY$"),
|
||||
log::Level::Debug => (Fg::Blue, "$BLUE$"),
|
||||
log::Level::Trace => (Fg::Yellow, "$YELLOW$"),
|
||||
};
|
||||
|
||||
let msg = format!(
|
||||
"[{}{}$RESET$][$GREEN${}$RESET$]{}\n",
|
||||
color.1,
|
||||
|
|
@ -66,10 +63,6 @@ impl log::Log for SimpleLogger {
|
|||
fn flush(&self) {}
|
||||
}
|
||||
|
||||
use log::{LevelFilter, SetLoggerError};
|
||||
|
||||
static LOGGER: SimpleLogger = SimpleLogger;
|
||||
|
||||
pub fn init() -> Result<(), SetLoggerError> {
|
||||
log::set_logger(&LOGGER).map(|()| log::set_max_level(LevelFilter::Trace))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ use cpuio::{inb, inl, outb, outl};
|
|||
pub fn read32(reg: u16) -> u32 {
|
||||
unsafe { inl(reg) }
|
||||
}
|
||||
|
||||
pub fn read8(reg: u16) -> u8 {
|
||||
unsafe { inb(reg) }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,10 +1,7 @@
|
|||
pub use crate::print::*;
|
||||
pub use crate::serial_print::*;
|
||||
pub use alloc::{boxed::Box, format, string::*, vec, vec::*};
|
||||
pub use core::arch::asm;
|
||||
pub use core::prelude::rust_2021::*;
|
||||
pub use core::prelude::v1::*;
|
||||
|
||||
pub use crate::print::*;
|
||||
pub use crate::serial_print::*;
|
||||
|
||||
pub use log::{debug, info, trace, warn};
|
||||
|
||||
pub use alloc::{boxed::Box, format, string::*, vec, vec::*};
|
||||
|
|
|
|||
|
|
@ -1,8 +1,10 @@
|
|||
// TODO: refactor this file
|
||||
// TODO: make STDOUT redirect to a socket owned
|
||||
// by the process named "stdout"
|
||||
pub struct Stdout;
|
||||
|
||||
use core::fmt::{Arguments, Error};
|
||||
|
||||
pub struct Stdout;
|
||||
impl Stdout {
|
||||
pub fn write_fmt(&mut self, arg: Arguments<'_>) /*-> Result<(), Error> */
|
||||
{
|
||||
|
|
@ -10,6 +12,7 @@ impl Stdout {
|
|||
// Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl core::fmt::Write for Stdout {
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
fn write_str(&mut self, s: &str) -> Result<(), Error> {
|
||||
|
|
@ -33,6 +36,7 @@ impl core::fmt::Write for Stdout {
|
|||
core::fmt::write(&mut self, args)
|
||||
}
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
macro_rules! print {
|
||||
() => {
|
||||
|
|
|
|||
|
|
@ -1,9 +1,6 @@
|
|||
/*
|
||||
clparse
|
||||
* A simple command line parser for ableOS
|
||||
*/
|
||||
/// # clparse
|
||||
/// simple command line parser for ableOS
|
||||
|
||||
// use std::collections::HashMap;
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Argument {
|
||||
key: String,
|
||||
|
|
@ -19,25 +16,22 @@ pub struct Command {
|
|||
|
||||
impl Command {
|
||||
pub fn parse(command: String) -> Command {
|
||||
let split_command = command.split("?");
|
||||
let split_command = command.split('?');
|
||||
let mut root = "".to_string();
|
||||
let mut root_count = 0;
|
||||
let mut args: Vec<Argument> = vec![];
|
||||
for subcommand in split_command {
|
||||
for (root_count, subcommand) in split_command.enumerate() {
|
||||
match root_count {
|
||||
0 => root = subcommand.to_string(),
|
||||
1 => {
|
||||
for subarg in subcommand.split("&") {
|
||||
for subarg in subcommand.split('&') {
|
||||
let mut arg1 = "";
|
||||
let mut arg2 = "";
|
||||
let mut arg_count = 0;
|
||||
for arg in subarg.split("=") {
|
||||
if arg_count == 0 {
|
||||
for (n, arg) in subarg.split('=').enumerate() {
|
||||
if n == 0 {
|
||||
arg1 = arg;
|
||||
} else {
|
||||
arg2 = arg;
|
||||
}
|
||||
arg_count += 1;
|
||||
}
|
||||
let arg_struct = Argument {
|
||||
key: arg1.to_string(),
|
||||
|
|
@ -48,7 +42,6 @@ impl Command {
|
|||
}
|
||||
_ => {}
|
||||
}
|
||||
root_count += 1;
|
||||
}
|
||||
|
||||
Command {
|
||||
|
|
@ -57,6 +50,7 @@ impl Command {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn test() {
|
||||
let x = Command::parse("hi?there=uwu&hi=abc".to_string());
|
||||
|
||||
|
|
|
|||
|
|
@ -1,11 +1,9 @@
|
|||
pub fn encode(bytes: &[u8]) -> Vec<u8> {
|
||||
let mut encoding;
|
||||
|
||||
if bytes.first().is_none() {
|
||||
let mut encoding = if bytes.first().is_none() {
|
||||
return vec![];
|
||||
} else {
|
||||
encoding = vec![*bytes.first().unwrap()];
|
||||
}
|
||||
vec![*bytes.first().unwrap()]
|
||||
};
|
||||
|
||||
let mut occurrences = 1;
|
||||
|
||||
|
|
@ -19,13 +17,12 @@ pub fn encode(bytes: &[u8]) -> Vec<u8> {
|
|||
}
|
||||
|
||||
encoding.push(occurrences);
|
||||
|
||||
encoding
|
||||
}
|
||||
|
||||
/// Read a run-length encoding and return its decoded contents.
|
||||
///
|
||||
/// * `bytes` - The bytes to be decoded.
|
||||
/// - `bytes` - The bytes to be decoded.
|
||||
pub fn decode(bytes: &[u8]) -> Vec<u8> {
|
||||
let mut decoding = Vec::<u8>::new();
|
||||
|
||||
|
|
|
|||
|
|
@ -1,3 +1 @@
|
|||
pub mod mono_bitmap;
|
||||
|
||||
pub mod stupid_simple_image;
|
||||
|
|
|
|||
|
|
@ -1,10 +1,8 @@
|
|||
use shadeable::pixel_format::new_rgba64;
|
||||
|
||||
use crate::{
|
||||
graphics::SCREEN_BUFFER,
|
||||
relib::encoding::rle::{decode, encode},
|
||||
};
|
||||
// use super::qoi;
|
||||
use shadeable::pixel_format::new_rgba64;
|
||||
|
||||
pub fn bruh() {
|
||||
#[rustfmt::skip]
|
||||
|
|
|
|||
|
|
@ -1,6 +0,0 @@
|
|||
/*
|
||||
r[255,0,0]
|
||||
g[0,0,0]
|
||||
b[0,0,0]
|
||||
a[0,0,0]
|
||||
*/
|
||||
|
|
@ -1,3 +1,6 @@
|
|||
pub static SOCKETS: spin::Mutex<SocketState> = spin::Mutex::new(vec![]);
|
||||
|
||||
pub type SocketState = Vec<SimpleSock>;
|
||||
pub type Stream = Vec<u8>;
|
||||
|
||||
#[derive(Debug)]
|
||||
|
|
@ -7,12 +10,7 @@ pub struct SocketID {
|
|||
|
||||
impl SocketID {
|
||||
pub fn protocol(self) -> Option<String> {
|
||||
let x = SOCKETS.lock()[self.id].protocol.clone();
|
||||
|
||||
match x {
|
||||
Some(protocol_name) => Some(protocol_name),
|
||||
None => None,
|
||||
}
|
||||
SOCKETS.lock()[self.id].protocol.clone()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -37,11 +35,6 @@ impl Socket for SocketID {
|
|||
}
|
||||
}
|
||||
|
||||
pub type SocketState = Vec<SimpleSock>;
|
||||
|
||||
lazy_static::lazy_static! {
|
||||
pub static ref SOCKETS: spin::Mutex<SocketState> = spin::Mutex::new(vec![]);
|
||||
}
|
||||
pub trait Socket {
|
||||
fn peek(&mut self) -> SocketReturns;
|
||||
|
||||
|
|
@ -54,6 +47,7 @@ pub trait Socket {
|
|||
|
||||
fn close(&mut self) {}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum SocketReturns {
|
||||
ReadOk(Stream),
|
||||
|
|
@ -116,10 +110,11 @@ impl Socket for SimpleSock {
|
|||
let mut return_vec = vec![];
|
||||
|
||||
for x in &self.stream {
|
||||
return_vec.push(x.clone());
|
||||
return_vec.push(*x);
|
||||
}
|
||||
SocketReturns::ReadOk(return_vec)
|
||||
}
|
||||
|
||||
fn read(&mut self, length: usize) -> SocketReturns {
|
||||
let mut return_vec = vec![];
|
||||
if length > self.stream.len() {
|
||||
|
|
@ -132,9 +127,11 @@ impl Socket for SimpleSock {
|
|||
SocketReturns::ReadOk(return_vec)
|
||||
}
|
||||
}
|
||||
|
||||
fn register_protocol(&mut self, protocol_name: String) {
|
||||
self.protocol = Some(protocol_name);
|
||||
}
|
||||
|
||||
fn check_protocol(&mut self, protocol_name: String) -> bool {
|
||||
if self.protocol == Some(protocol_name) {
|
||||
return true;
|
||||
|
|
@ -142,11 +139,13 @@ impl Socket for SimpleSock {
|
|||
|
||||
false
|
||||
}
|
||||
|
||||
fn write(&mut self, stream: Stream) -> SocketReturns {
|
||||
for byte in stream {
|
||||
self.stream.push(byte);
|
||||
}
|
||||
SocketReturns::WriteOk
|
||||
}
|
||||
|
||||
fn close(&mut self) {}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,8 +1,27 @@
|
|||
use super::Time;
|
||||
use core::fmt::{Display, Error, Formatter};
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
#[repr(transparent)]
|
||||
pub struct Kilosecond(usize);
|
||||
impl Kilosecond {
|
||||
pub fn from_ms(ms: usize) -> Self {
|
||||
Self(ms)
|
||||
}
|
||||
pub fn from_sec(sec: usize) -> Self {
|
||||
Self(sec * 1000)
|
||||
}
|
||||
pub fn from_minutes(min: usize) -> Self {
|
||||
Self(min * 60 * 1000)
|
||||
}
|
||||
pub fn from_hours(hrs: usize) -> Self {
|
||||
Self(hrs * 60 * 60 * 1000)
|
||||
}
|
||||
pub fn from_days(days: usize) -> Self {
|
||||
Self(days * 24 * 60 * 60 * 1000)
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for Kilosecond {
|
||||
fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
|
||||
let mut reg = self.0;
|
||||
|
|
@ -36,37 +55,23 @@ impl Display for Kilosecond {
|
|||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl core::ops::Add for Kilosecond {
|
||||
type Output = Self;
|
||||
fn add(self, rhs: Self) -> Self {
|
||||
Self(self.0 + rhs.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl core::ops::Sub for Kilosecond {
|
||||
type Output = Self;
|
||||
fn sub(self, rhs: Self) -> Self {
|
||||
Self(self.0 - rhs.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Time> for Kilosecond {
|
||||
fn from(t: Time) -> Self {
|
||||
Self((t.hour as usize * 3600 + t.minutes as usize * 60 + t.seconds as usize) * 1000)
|
||||
}
|
||||
}
|
||||
impl Kilosecond {
|
||||
pub fn from_ms(ms: usize) -> Self {
|
||||
Self(ms)
|
||||
}
|
||||
pub fn from_sec(sec: usize) -> Self {
|
||||
Self(sec * 1000)
|
||||
}
|
||||
pub fn from_minutes(min: usize) -> Self {
|
||||
Self(min * 60 * 1000)
|
||||
}
|
||||
pub fn from_hours(hrs: usize) -> Self {
|
||||
Self(hrs * 60 * 60 * 1000)
|
||||
}
|
||||
pub fn from_days(days: usize) -> Self {
|
||||
Self(days * 24 * 60 * 60 * 1000)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,3 +1,7 @@
|
|||
pub mod kilotime;
|
||||
|
||||
use core::fmt;
|
||||
|
||||
pub struct Time {
|
||||
pub year: u16,
|
||||
pub month: u16,
|
||||
|
|
@ -7,6 +11,7 @@ pub struct Time {
|
|||
pub seconds: u16,
|
||||
pub microseconds: u32,
|
||||
}
|
||||
|
||||
impl fmt::Display for Time {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(
|
||||
|
|
@ -16,5 +21,3 @@ impl fmt::Display for Time {
|
|||
)
|
||||
}
|
||||
}
|
||||
pub mod kilotime;
|
||||
use core::fmt;
|
||||
|
|
|
|||
|
|
@ -1,9 +1,27 @@
|
|||
use crate::filesystem::FILE_SYSTEM;
|
||||
use crate::info::master;
|
||||
use crate::time::fetch_time;
|
||||
use crate::wasm_jumploader::interp;
|
||||
use crate::ALLOCATOR;
|
||||
use crate::{
|
||||
arch::{shutdown, sloop},
|
||||
systeminfo::{KERNEL_VERSION, RELEASE_TYPE},
|
||||
KERNEL_STATE,
|
||||
};
|
||||
use genfs::{Fs, OpenOptions};
|
||||
use rhai::Engine;
|
||||
use spin::Lazy;
|
||||
use x86_64::instructions::interrupts::{disable, enable};
|
||||
|
||||
pub static KEYBUFF: spin::Mutex<Vec<char>> = spin::Mutex::new(Vec::new());
|
||||
pub static CURRENT_DIR: Lazy<spin::Mutex<String>> = Lazy::new(|| spin::Mutex::new("/".to_string()));
|
||||
|
||||
#[cfg(target_arch = "riscv64")]
|
||||
pub fn shell() {}
|
||||
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
pub fn shell() {
|
||||
let mut current_dir = "/".to_string();
|
||||
let _current_dir = "/".to_string();
|
||||
let engine = engine_construction();
|
||||
let mut scope = rhai::Scope::new();
|
||||
|
||||
|
|
@ -38,23 +56,6 @@ pub fn shell() {
|
|||
}
|
||||
}
|
||||
}
|
||||
lazy_static::lazy_static!(
|
||||
pub static ref KEYBUFF: spin::Mutex<Vec<char>> = spin::Mutex::new(Vec::new());
|
||||
pub static ref CURRENT_DIR: spin::Mutex<String> = spin::Mutex::new("/".to_string());
|
||||
);
|
||||
|
||||
use rhai::Engine;
|
||||
use x86_64::instructions::interrupts::{disable, enable};
|
||||
|
||||
use crate::info::master;
|
||||
use crate::time::fetch_time;
|
||||
use crate::wasm_jumploader::interp;
|
||||
use crate::{allocator, ALLOCATOR};
|
||||
use crate::{
|
||||
arch::{shutdown, sloop},
|
||||
systeminfo::{KERNEL_VERSION, RELEASE_TYPE},
|
||||
KERNEL_STATE,
|
||||
};
|
||||
|
||||
pub fn afetch() {
|
||||
let kstate = KERNEL_STATE.lock();
|
||||
|
|
@ -81,51 +82,26 @@ pub fn afetch() {
|
|||
);
|
||||
drop(kstate);
|
||||
}
|
||||
|
||||
pub fn set_hostname(name: String) {
|
||||
let mut kstate = KERNEL_STATE.lock();
|
||||
kstate.hostname = name;
|
||||
}
|
||||
|
||||
fn engine_construction() -> Engine {
|
||||
let mut engine = rhai::Engine::new();
|
||||
|
||||
engine.on_print(|x| println!("{}", x));
|
||||
|
||||
engine.on_debug(|x, src, pos| {
|
||||
let src = src.unwrap_or("unknown");
|
||||
println!("DEBUG: {} at {:?}: {}", src, pos, x);
|
||||
debug!("{} at {:?}: {}", src, pos, x);
|
||||
});
|
||||
|
||||
engine.register_fn("ls", ls);
|
||||
engine.register_fn("cat", echo_file);
|
||||
engine.register_fn("cd", change_directory);
|
||||
engine.register_fn("afetch", afetch);
|
||||
engine.register_fn("set_hostname", set_hostname);
|
||||
engine.register_fn("shutdown", shutdown);
|
||||
engine.register_fn("peek", peek_memory);
|
||||
engine.register_fn("poke", poke_memory);
|
||||
engine.register_fn("sloop", sloop);
|
||||
engine.register_fn("wasm", interp);
|
||||
engine.register_fn("log_dump", log_dump);
|
||||
|
||||
engine
|
||||
}
|
||||
|
||||
/// Examine a memory pointer
|
||||
pub fn peek_memory(ptr: i64) -> u8 {
|
||||
let ptr: usize = ptr.abs() as usize;
|
||||
let ptr: usize = ptr.unsigned_abs() as _;
|
||||
println!(">:(");
|
||||
unsafe { *(ptr as *const u8) }
|
||||
}
|
||||
|
||||
pub fn poke_memory(ptr: i64, val: u8) {
|
||||
let ptr: usize = ptr.abs() as usize;
|
||||
let ptr: usize = ptr.unsigned_abs() as _;
|
||||
unsafe { *(ptr as *mut u8) = val }
|
||||
}
|
||||
|
||||
pub fn ls() {
|
||||
let mut current_dir = CURRENT_DIR.lock();
|
||||
let current_dir = CURRENT_DIR.lock();
|
||||
|
||||
let fs = &*FILE_SYSTEM.lock();
|
||||
|
||||
|
|
@ -165,9 +141,6 @@ pub fn log_dump() {
|
|||
}
|
||||
}
|
||||
|
||||
use crate::filesystem::FILE_SYSTEM;
|
||||
use genfs::{DirEntry, Fs, OpenOptions};
|
||||
|
||||
pub fn echo_file(path: String) {
|
||||
let mut current_dir = CURRENT_DIR.lock();
|
||||
|
||||
|
|
@ -181,12 +154,10 @@ pub fn echo_file(path: String) {
|
|||
|
||||
if file.is_dir() {
|
||||
println!("{} is a directory", path);
|
||||
|
||||
return;
|
||||
} else {
|
||||
let mut file_contents = Vec::new();
|
||||
|
||||
let ret = file.read_to_end(&mut file_contents).unwrap();
|
||||
let _ret = file.read_to_end(&mut file_contents).unwrap();
|
||||
|
||||
let file_contents_str = String::from_utf8_lossy(&file_contents);
|
||||
|
||||
|
|
@ -197,13 +168,13 @@ pub fn echo_file(path: String) {
|
|||
pub fn change_directory(path: String) {
|
||||
let mut current_dir = CURRENT_DIR.lock();
|
||||
|
||||
let fs = &*FILE_SYSTEM.lock();
|
||||
let _fs = &*FILE_SYSTEM.lock();
|
||||
if path == "." || path == ".." {
|
||||
let mut split_dir = current_dir.split("/").collect::<Vec<&str>>();
|
||||
let mut split_dir = current_dir.split('/').collect::<Vec<&str>>();
|
||||
let mut new_dir = String::new();
|
||||
split_dir.remove(split_dir.len() - 1);
|
||||
println!("{:?}", split_dir);
|
||||
if split_dir.len() == 0 {
|
||||
if split_dir.is_empty() {
|
||||
new_dir = "/".to_string();
|
||||
} else {
|
||||
for x in split_dir {
|
||||
|
|
@ -214,8 +185,33 @@ pub fn change_directory(path: String) {
|
|||
*current_dir = new_dir;
|
||||
} else {
|
||||
if !current_dir.ends_with('/') {
|
||||
current_dir.push_str("/");
|
||||
current_dir.push('/');
|
||||
}
|
||||
current_dir.push_str(&path);
|
||||
}
|
||||
}
|
||||
|
||||
fn engine_construction() -> Engine {
|
||||
let mut engine = rhai::Engine::new();
|
||||
|
||||
engine.on_print(|x| println!("{}", x));
|
||||
engine.on_debug(|x, src, pos| {
|
||||
let src = src.unwrap_or("unknown");
|
||||
println!("DEBUG: {} at {:?}: {}", src, pos, x);
|
||||
debug!("{} at {:?}: {}", src, pos, x);
|
||||
});
|
||||
|
||||
engine.register_fn("ls", ls);
|
||||
engine.register_fn("cat", echo_file);
|
||||
engine.register_fn("cd", change_directory);
|
||||
engine.register_fn("afetch", afetch);
|
||||
engine.register_fn("set_hostname", set_hostname);
|
||||
engine.register_fn("shutdown", shutdown);
|
||||
engine.register_fn("peek", peek_memory);
|
||||
engine.register_fn("poke", poke_memory);
|
||||
engine.register_fn("sloop", sloop);
|
||||
engine.register_fn("wasm", interp);
|
||||
engine.register_fn("log_dump", log_dump);
|
||||
|
||||
engine
|
||||
}
|
||||
|
|
|
|||
|
|
@ -54,6 +54,7 @@ pub struct Capabilities {
|
|||
pub sound_cards: SoundCardAccess,
|
||||
pub network_access: NetworkAccess,
|
||||
}
|
||||
|
||||
impl Capabilities {
|
||||
/// Generate a set of empty capabilities
|
||||
pub fn empty() -> Self {
|
||||
|
|
|
|||
|
|
@ -1,13 +1,15 @@
|
|||
use crate::{arch::generate_process_pass, stdio::StdIO};
|
||||
|
||||
use crate::scheduler::capabilities::Capabilities;
|
||||
|
||||
use kernel::proccess::PID;
|
||||
pub mod capabilities;
|
||||
pub mod priority;
|
||||
pub mod proc;
|
||||
|
||||
use crate::scheduler::capabilities::Capabilities;
|
||||
use crate::{arch::generate_process_pass, stdio::StdIO};
|
||||
use kernel::proccess::PID;
|
||||
use priority::Priority;
|
||||
use proc::Process;
|
||||
|
||||
pub static SCHEDULER: spin::Mutex<Scheduler> = spin::Mutex::new(Scheduler::new());
|
||||
|
||||
/// Add additional wake conditions to the list
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum WakeCondition {
|
||||
|
|
@ -34,11 +36,12 @@ pub struct Scheduler {
|
|||
pub execution_queue: Vec<Process>,
|
||||
pub sleeping_queue: Vec<BlockedProcess>,
|
||||
pub blocked_queue: Vec<BlockedProcess>,
|
||||
// / All timed processes sorted by wake time
|
||||
// All timed processes sorted by wake time
|
||||
}
|
||||
|
||||
impl Scheduler {
|
||||
/// Create a new scheduler
|
||||
pub fn new() -> Self {
|
||||
pub const fn new() -> Self {
|
||||
Self {
|
||||
free_pid: 0,
|
||||
process_exec_time: 0,
|
||||
|
|
@ -69,15 +72,14 @@ impl Scheduler {
|
|||
working_dir: String,
|
||||
stdio: StdIO,
|
||||
) -> Process {
|
||||
let mut process = Process {
|
||||
Process {
|
||||
pid: 0,
|
||||
priority,
|
||||
working_dir,
|
||||
stdio,
|
||||
password: generate_process_pass(),
|
||||
capabilities,
|
||||
};
|
||||
process
|
||||
}
|
||||
}
|
||||
|
||||
pub fn sleep_process(&mut self, process: &mut Process) {
|
||||
|
|
@ -86,11 +88,7 @@ impl Scheduler {
|
|||
wake_condition: WakeCondition::TimerInterrupt(0),
|
||||
};
|
||||
|
||||
self.sleeping_queue.push(sleeping_process.clone());
|
||||
self.sleeping_queue.push(sleeping_process);
|
||||
self.execution_queue.remove(0);
|
||||
}
|
||||
}
|
||||
|
||||
lazy_static::lazy_static! {
|
||||
pub static ref SCHEDULER: spin::Mutex<Scheduler> = spin::Mutex::new(Scheduler::new());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,5 +22,3 @@ pub struct Process {
|
|||
pub working_dir: String,
|
||||
pub stdio: StdIO,
|
||||
}
|
||||
|
||||
impl Process {}
|
||||
|
|
|
|||
|
|
@ -1,41 +1,5 @@
|
|||
use acpi::AcpiTables;
|
||||
use kernel::device_interface::character::CharacterDevice;
|
||||
|
||||
use crate::devices::DEVICE_TABLE;
|
||||
use crate::rhai_shell::shell;
|
||||
|
||||
use crate::stdio::StdIO;
|
||||
|
||||
use crate::devices::Device::Vterm;
|
||||
|
||||
/// Experimental scratchpad for testing.
|
||||
pub fn scratchpad() {
|
||||
let axel_raw = "kernel{
|
||||
vals=
|
||||
time: 123
|
||||
fn|
|
||||
print: (None) -> (None);
|
||||
foo: (None) -> (Num);
|
||||
}";
|
||||
let axel = axel::parse(axel_raw.to_string());
|
||||
for node in axel {
|
||||
info!("{:?}", node);
|
||||
}
|
||||
|
||||
shell();
|
||||
}
|
||||
|
||||
use core::fmt::Write;
|
||||
|
||||
pub fn pci_fun() {}
|
||||
|
||||
pub fn acpi() {
|
||||
let acpi_handler = AcpiStruct {};
|
||||
let _table;
|
||||
unsafe {
|
||||
_table = AcpiTables::search_for_rsdp_bios(acpi_handler);
|
||||
}
|
||||
}
|
||||
use acpi::AcpiTables;
|
||||
|
||||
// TODO: move to a better place
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
|
|
@ -54,3 +18,30 @@ impl acpi::AcpiHandler for AcpiStruct {
|
|||
todo!("unmap_physical_region");
|
||||
}
|
||||
}
|
||||
|
||||
/// Experimental scratchpad for testing.
|
||||
pub fn scratchpad() {
|
||||
let axel_raw = "kernel{
|
||||
vals=
|
||||
time: 123
|
||||
fn|
|
||||
print: (None) -> (None);
|
||||
foo: (None) -> (Num);
|
||||
}";
|
||||
let axel = axel::parse(axel_raw.to_string());
|
||||
for node in axel {
|
||||
info!("{:?}", node);
|
||||
}
|
||||
|
||||
shell();
|
||||
}
|
||||
|
||||
pub fn pci_fun() {}
|
||||
|
||||
pub fn acpi() {
|
||||
let acpi_handler = AcpiStruct {};
|
||||
let _table;
|
||||
unsafe {
|
||||
_table = AcpiTables::search_for_rsdp_bios(acpi_handler);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
pub struct Serialout;
|
||||
use core::fmt::{Arguments, Error};
|
||||
|
||||
pub struct Serialout;
|
||||
impl Serialout {
|
||||
pub fn write_fmt(&mut self, arg: Arguments<'_>) /*-> Result<(), Error> */
|
||||
{
|
||||
|
|
@ -7,6 +8,7 @@ impl Serialout {
|
|||
// Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl core::fmt::Write for Serialout {
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
fn write_str(&mut self, s: &str) -> Result<(), Error> {
|
||||
|
|
@ -30,6 +32,7 @@ impl core::fmt::Write for Serialout {
|
|||
core::fmt::write(&mut self, args)
|
||||
}
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
macro_rules! serial_print {
|
||||
() => {
|
||||
|
|
@ -39,6 +42,7 @@ macro_rules! serial_print {
|
|||
::core::write!($crate::serial_print::Serialout, $($tt)*)
|
||||
};
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
macro_rules! serial_println {
|
||||
($($tt:tt)*) => {
|
||||
|
|
|
|||
|
|
@ -1,8 +1,5 @@
|
|||
use {
|
||||
crate::{
|
||||
devices::Device::{Character, Vterm},
|
||||
kprintln,
|
||||
},
|
||||
crate::devices::Device::{Character, Vterm},
|
||||
core::fmt::{Arguments, Error, Write},
|
||||
kernel::device_interface::character::CharacterDevice,
|
||||
};
|
||||
|
|
@ -40,6 +37,7 @@ impl StdIO {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read(&mut self) {
|
||||
todo!();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,15 +1,14 @@
|
|||
use picorand::PicoRandGenerate;
|
||||
use rkyv::{ser::serializers::AllocSerializer, Deserialize};
|
||||
use shadeable::pixel_format::from_vga_16;
|
||||
use vga::colors::Color16;
|
||||
use y_compositor_protocol::Version;
|
||||
|
||||
use crate::{
|
||||
kmain::KERNEL_CONF,
|
||||
network::socket::{SimpleSock, Socket, SocketReturns},
|
||||
num_to_vga16, VgaBuffer, SCREEN_BUFFER,
|
||||
};
|
||||
use kernel::TICK;
|
||||
use picorand::PicoRandGenerate;
|
||||
use rkyv::{ser::serializers::AllocSerializer, Deserialize};
|
||||
use shadeable::pixel_format::from_vga_16;
|
||||
use vga::colors::Color16;
|
||||
use y_compositor_protocol::Version;
|
||||
|
||||
pub fn run_tests() {
|
||||
if KERNEL_CONF.tests.run_tests {
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
use core::sync::atomic::Ordering;
|
||||
use kernel::TICK;
|
||||
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
pub fn fetch_time() -> f64 {
|
||||
use x86_64::instructions::interrupts::{disable, enable};
|
||||
|
|
@ -8,8 +11,6 @@ pub fn fetch_time() -> f64 {
|
|||
time
|
||||
}
|
||||
|
||||
use core::sync::atomic::Ordering;
|
||||
use kernel::TICK;
|
||||
#[cfg(target_arch = "riscv64")]
|
||||
pub fn fetch_time() -> f64 {
|
||||
let time = TICK.load(Ordering::Relaxed) as f64;
|
||||
|
|
|
|||
|
|
@ -1,2 +1,2 @@
|
|||
pub const POWER_SIGN: &str = "\u{23FB}";
|
||||
pub const CONSOLE: &str = "\u{E795}";
|
||||
pub const POWER_SIGN: &str = "\u{23FB}";
|
||||
|
|
|
|||
|
|
@ -1,16 +1,15 @@
|
|||
//!
|
||||
//!
|
||||
//!
|
||||
//!
|
||||
//!
|
||||
|
||||
pub enum UsbSpeed {
|
||||
/// Super-speed functions operate at up to 5 Gb/s.
|
||||
Super,
|
||||
|
||||
/// High-speed functions operate at up to 480 Mb/s.
|
||||
High,
|
||||
|
||||
/// Full-speed functions operate at up to 12 Mb/s.
|
||||
Full,
|
||||
|
||||
/// Low-speed functions operate at up to 1.5 Mb/s.
|
||||
Low,
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,12 +1,18 @@
|
|||
//! Small generic utilities
|
||||
//!
|
||||
//!
|
||||
//!
|
||||
|
||||
#[inline]
|
||||
pub fn type_of<T>(_: &T) -> &str {
|
||||
core::any::type_name::<T>()
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
#[allow(unconditional_recursion)]
|
||||
pub extern "C" fn stack_overflow() -> u8 {
|
||||
stack_overflow();
|
||||
// meme number
|
||||
69 // NOTE: Any specific reason for this number aside from memes?
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
|
@ -16,11 +22,3 @@ mod tests {
|
|||
assert_eq!(type_of(&1), "i32");
|
||||
}
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
#[allow(unconditional_recursion)]
|
||||
pub extern "C" fn stack_overflow() -> u8 {
|
||||
stack_overflow();
|
||||
// meme number
|
||||
69 // NOTE: Any specific reason for this number aside from memes?
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,19 +3,18 @@ use vga::{
|
|||
writers::{Graphics640x480x16, GraphicsWriter},
|
||||
};
|
||||
|
||||
lazy_static::lazy_static! {
|
||||
pub static ref VGAE: spin::Mutex<Graphics640x480x16> = {
|
||||
let xyz = Graphics640x480x16::new();
|
||||
xyz.set_mode();
|
||||
spin::Mutex::new(xyz)
|
||||
};
|
||||
pub static ref VGAE_BUFF_OFFSET_X: spin::Mutex<u8> = spin::Mutex::new(0);
|
||||
pub static ref VGAE_BUFF_OFFSET_Y: spin::Mutex<u8> = spin::Mutex::new(0);
|
||||
}
|
||||
pub static VGAE_BUFF_OFFSET_X: spin::Mutex<u8> = spin::Mutex::new(0);
|
||||
pub static VGAE_BUFF_OFFSET_Y: spin::Mutex<u8> = spin::Mutex::new(0);
|
||||
pub static VGAE: spin::Mutex<Graphics640x480x16> = {
|
||||
let xyz = Graphics640x480x16::new();
|
||||
xyz.set_mode();
|
||||
spin::Mutex::new(xyz)
|
||||
};
|
||||
|
||||
/// Converts a number to ... i forgor 💀
|
||||
pub fn num_to_vga16(num: u8) -> Color16 {
|
||||
pub const fn num_to_vga16(num: u8) -> Color16 {
|
||||
use Color16::*;
|
||||
|
||||
match num {
|
||||
0 => Black,
|
||||
1 => Blue,
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
/// `NULL a s m` as an array of 4 bytes
|
||||
pub const WASM_BINARY_MAGIC: [u8; 4] = [0x00, 0x61, 0x73, 0x6d];
|
||||
|
||||
/// `1 0 0 0` as an array of 4 bytes
|
||||
pub const WASM_VERSION: [u8; 4] = [0x01, 0x00, 0x00, 0x00];
|
||||
|
||||
|
|
@ -104,6 +105,6 @@ impl WasmProgram {
|
|||
if self.raw_bytes[4..8] == WASM_VERSION {
|
||||
byte_version_valid = true;
|
||||
}
|
||||
return (byte_magic_valid, byte_version_valid);
|
||||
(byte_magic_valid, byte_version_valid)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,20 +1,124 @@
|
|||
use core::arch;
|
||||
|
||||
use crate::{arch::generate_process_pass, rhai_shell::KEYBUFF};
|
||||
use wasmi::{
|
||||
Error, Externals, FuncInstance, FuncRef, ModuleImportResolver, RuntimeArgs, RuntimeValue,
|
||||
Signature, Trap, ValueType,
|
||||
};
|
||||
|
||||
pub struct HostExternals {}
|
||||
|
||||
const ADD_FUNC_INDEX: usize = 0;
|
||||
const SEND_SIGNAL_INDEX: usize = 1;
|
||||
const GET_TIME_INDEX: usize = 2;
|
||||
const GET_RANDOM_INDEX: usize = 3;
|
||||
|
||||
const GET_INPUT_INDEX: usize = 4;
|
||||
|
||||
const PRINT_CLEVER_HACK: usize = 5;
|
||||
const SEND_SIGNAL_INDEX: usize = 1;
|
||||
|
||||
pub struct HostExternals;
|
||||
impl HostExternals {
|
||||
fn check_signature(&self, index: usize, signature: &Signature) -> bool {
|
||||
match index {
|
||||
ADD_FUNC_INDEX => {
|
||||
let (params, ret_ty): (&[ValueType], Option<ValueType>) =
|
||||
(&[ValueType::I32, ValueType::I32], Some(ValueType::I32));
|
||||
if params.len() != signature.params().len() {
|
||||
return false;
|
||||
}
|
||||
if ret_ty != signature.return_type() {
|
||||
return false;
|
||||
}
|
||||
for (ty, param) in params.iter().zip(signature.params()) {
|
||||
if *ty != *param {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
SEND_SIGNAL_INDEX => {
|
||||
let (params, ret_ty): (&[ValueType], Option<ValueType>) =
|
||||
(&[ValueType::I32, ValueType::I32], Some(ValueType::I32));
|
||||
if params.len() != signature.params().len() {
|
||||
return false;
|
||||
}
|
||||
if ret_ty != signature.return_type() {
|
||||
return false;
|
||||
}
|
||||
for (ty, param) in params.iter().zip(signature.params()) {
|
||||
if *ty != *param {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
GET_TIME_INDEX => {
|
||||
let (params, ret_ty): (&[ValueType], Option<ValueType>) =
|
||||
(&[], Some(ValueType::I32));
|
||||
if params.len() != signature.params().len() {
|
||||
return false;
|
||||
}
|
||||
if ret_ty != signature.return_type() {
|
||||
return false;
|
||||
}
|
||||
for (ty, param) in params.iter().zip(signature.params()) {
|
||||
if *ty != *param {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
GET_RANDOM_INDEX => {
|
||||
let (params, ret_ty): (&[ValueType], Option<ValueType>) =
|
||||
(&[], Some(ValueType::I32));
|
||||
if params.len() != signature.params().len() {
|
||||
return false;
|
||||
}
|
||||
if ret_ty != signature.return_type() {
|
||||
return false;
|
||||
}
|
||||
for (ty, param) in params.iter().zip(signature.params()) {
|
||||
if *ty != *param {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
GET_INPUT_INDEX => {
|
||||
let (params, ret_ty): (&[ValueType], Option<ValueType>) =
|
||||
(&[], Some(ValueType::I32));
|
||||
if params.len() != signature.params().len() {
|
||||
return false;
|
||||
}
|
||||
if ret_ty != signature.return_type() {
|
||||
return false;
|
||||
}
|
||||
for (ty, param) in params.iter().zip(signature.params()) {
|
||||
if *ty != *param {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
PRINT_CLEVER_HACK => {
|
||||
let (params, ret_ty): (&[ValueType], Option<ValueType>) = (&[ValueType::I64], None);
|
||||
if params.len() != signature.params().len() {
|
||||
return false;
|
||||
}
|
||||
if ret_ty != signature.return_type() {
|
||||
return false;
|
||||
}
|
||||
for (ty, param) in params.iter().zip(signature.params()) {
|
||||
if *ty != *param {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Externals for HostExternals {
|
||||
fn invoke_index(
|
||||
|
|
@ -30,6 +134,7 @@ impl Externals for HostExternals {
|
|||
trace!("SYSCALL: {} + {} = {}", a, b, result);
|
||||
Ok(Some(RuntimeValue::I32(result as i32)))
|
||||
}
|
||||
|
||||
SEND_SIGNAL_INDEX => {
|
||||
let pid: u32 = args.nth_checked(0)?;
|
||||
let signal: u32 = args.nth_checked(1)?;
|
||||
|
|
@ -49,6 +154,7 @@ impl Externals for HostExternals {
|
|||
let ret = RuntimeValue::I32(tick_time.try_into().unwrap());
|
||||
Ok(Some(ret))
|
||||
}
|
||||
|
||||
GET_RANDOM_INDEX => {
|
||||
trace!("SYSCALL: get random");
|
||||
let rand = generate_process_pass();
|
||||
|
|
@ -93,113 +199,6 @@ impl Externals for HostExternals {
|
|||
}
|
||||
}
|
||||
|
||||
use crate::rhai_shell::KEYBUFF;
|
||||
|
||||
use crate::arch::generate_process_pass;
|
||||
impl HostExternals {
|
||||
fn check_signature(&self, index: usize, signature: &Signature) -> bool {
|
||||
match index {
|
||||
ADD_FUNC_INDEX => {
|
||||
let (params, ret_ty): (&[ValueType], Option<ValueType>) =
|
||||
(&[ValueType::I32, ValueType::I32], Some(ValueType::I32));
|
||||
if params.len() != signature.params().len() {
|
||||
return false;
|
||||
}
|
||||
if ret_ty != signature.return_type() {
|
||||
return false;
|
||||
}
|
||||
for (ty, param) in params.iter().zip(signature.params()) {
|
||||
if *ty != *param {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
SEND_SIGNAL_INDEX => {
|
||||
let (params, ret_ty): (&[ValueType], Option<ValueType>) =
|
||||
(&[ValueType::I32, ValueType::I32], Some(ValueType::I32));
|
||||
if params.len() != signature.params().len() {
|
||||
return false;
|
||||
}
|
||||
if ret_ty != signature.return_type() {
|
||||
return false;
|
||||
}
|
||||
for (ty, param) in params.iter().zip(signature.params()) {
|
||||
if *ty != *param {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
GET_TIME_INDEX => {
|
||||
let (params, ret_ty): (&[ValueType], Option<ValueType>) =
|
||||
(&[], Some(ValueType::I32));
|
||||
if params.len() != signature.params().len() {
|
||||
return false;
|
||||
}
|
||||
if ret_ty != signature.return_type() {
|
||||
return false;
|
||||
}
|
||||
for (ty, param) in params.iter().zip(signature.params()) {
|
||||
if *ty != *param {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
GET_RANDOM_INDEX => {
|
||||
let (params, ret_ty): (&[ValueType], Option<ValueType>) =
|
||||
(&[], Some(ValueType::I32));
|
||||
if params.len() != signature.params().len() {
|
||||
return false;
|
||||
}
|
||||
if ret_ty != signature.return_type() {
|
||||
return false;
|
||||
}
|
||||
for (ty, param) in params.iter().zip(signature.params()) {
|
||||
if *ty != *param {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
GET_INPUT_INDEX => {
|
||||
let (params, ret_ty): (&[ValueType], Option<ValueType>) =
|
||||
(&[], Some(ValueType::I32));
|
||||
if params.len() != signature.params().len() {
|
||||
return false;
|
||||
}
|
||||
if ret_ty != signature.return_type() {
|
||||
return false;
|
||||
}
|
||||
for (ty, param) in params.iter().zip(signature.params()) {
|
||||
if *ty != *param {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
PRINT_CLEVER_HACK => {
|
||||
let (params, ret_ty): (&[ValueType], Option<ValueType>) = (&[ValueType::I64], None);
|
||||
if params.len() != signature.params().len() {
|
||||
return false;
|
||||
}
|
||||
if ret_ty != signature.return_type() {
|
||||
return false;
|
||||
}
|
||||
for (ty, param) in params.iter().zip(signature.params()) {
|
||||
if *ty != *param {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ModuleImportResolver for HostExternals {
|
||||
fn resolve_func(&self, field_name: &str, signature: &Signature) -> Result<FuncRef, Error> {
|
||||
let index = match field_name {
|
||||
|
|
@ -223,9 +222,8 @@ impl ModuleImportResolver for HostExternals {
|
|||
field_name, signature
|
||||
)));
|
||||
}
|
||||
trace!("Resolved export {} as func {}", field_name, index);
|
||||
|
||||
trace!("Resolved export {} as func {}", field_name, index);
|
||||
Ok(FuncInstance::alloc_host(signature.clone(), index))
|
||||
}
|
||||
}
|
||||
use crate::wasm_jumploader::host_functions::ValueType::I32;
|
||||
|
|
|
|||
|
|
@ -1,13 +1,9 @@
|
|||
pub mod host_functions;
|
||||
|
||||
extern crate wasmi;
|
||||
// extern crate wabt;
|
||||
|
||||
use crate::{filesystem::FILE_SYSTEM, wasm_jumploader::host_functions::HostExternals};
|
||||
use genfs::{Fs, OpenOptions};
|
||||
use wasmi::{ImportsBuilder, ModuleInstance};
|
||||
|
||||
use crate::{filesystem::FILE_SYSTEM, wasm_jumploader::host_functions::HostExternals};
|
||||
|
||||
pub fn interp() {
|
||||
trace!("Interpreting...");
|
||||
let fs = &*FILE_SYSTEM.lock();
|
||||
|
|
@ -35,25 +31,23 @@ pub fn interp() {
|
|||
|
||||
match instance {
|
||||
Ok(inst) => {
|
||||
let mut instance = inst.assert_no_start();
|
||||
|
||||
let instance = inst.assert_no_start();
|
||||
let mut is_driver = false;
|
||||
let mut is_program = false;
|
||||
|
||||
let _is_program = false;
|
||||
let mut has_driver_entry = false;
|
||||
let mut has_driver_exit = false;
|
||||
let mut has_start = false;
|
||||
|
||||
if let Some(val) = instance.export_by_name("driver_entry") {
|
||||
if let Some(_val) = instance.export_by_name("driver_entry") {
|
||||
has_driver_entry = true;
|
||||
}
|
||||
|
||||
if let Some(val) = instance.export_by_name("driver_exit") {
|
||||
if let Some(_val) = instance.export_by_name("driver_exit") {
|
||||
has_driver_exit = true;
|
||||
}
|
||||
|
||||
match instance.export_by_name("start") {
|
||||
Some(val) => {
|
||||
Some(_val) => {
|
||||
trace!("Program start function found");
|
||||
has_start = true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,5 @@
|
|||
#![no_std]
|
||||
|
||||
// extern crate alloc;
|
||||
|
||||
use log::*;
|
||||
|
||||
pub const VERSION: &str = env!("CARGO_PKG_VERSION");
|
||||
|
|
|
|||
|
|
@ -3,13 +3,8 @@ edition = "2021"
|
|||
name = "kernel"
|
||||
version = "0.1.2"
|
||||
|
||||
|
||||
[dependencies]
|
||||
log = "0.4.14"
|
||||
|
||||
[dependencies.lazy_static]
|
||||
version = "1.4.0"
|
||||
default-features = false
|
||||
|
||||
[dependencies.versioning]
|
||||
git = "https://git.ablecorp.us/able/aos_userland"
|
||||
|
|
@ -4,14 +4,19 @@
|
|||
pub trait CharacterDevice {
|
||||
/// Returns true if the device can be read from.
|
||||
fn can_read(&self) -> bool;
|
||||
|
||||
/// Returns true if the device can be written to
|
||||
fn can_write(&self) -> bool;
|
||||
|
||||
/// Reads a single character from the device
|
||||
fn read_char(&mut self) -> Option<char>;
|
||||
|
||||
/// Writes a single character to the device and returns true if the write was successful
|
||||
fn write_char(&mut self, c: char) -> bool;
|
||||
|
||||
/// Reset the device to its initial state
|
||||
fn reset(&mut self);
|
||||
|
||||
/// initializes the device, returns true if successful
|
||||
fn initialize(&mut self) -> bool;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
//! The ableOS kernel.
|
||||
|
||||
#![deny(missing_docs)]
|
||||
#![no_std]
|
||||
#![feature(prelude_import)]
|
||||
|
||||
//! The ableOS kernel.
|
||||
|
||||
pub mod device_interface;
|
||||
pub mod messaging;
|
||||
pub mod panic;
|
||||
|
|
@ -12,9 +12,18 @@ pub mod syscalls;
|
|||
pub mod time;
|
||||
|
||||
use core::sync::atomic::{AtomicU64, Ordering::Relaxed};
|
||||
|
||||
use versioning::Version;
|
||||
|
||||
/// The number of ticks since the first CPU was started
|
||||
pub static TICK: AtomicU64 = AtomicU64::new(0);
|
||||
|
||||
/// Kernel's version
|
||||
pub const KERNEL_VERSION: Version = Version {
|
||||
major: 0,
|
||||
minor: 1,
|
||||
patch: 2,
|
||||
};
|
||||
|
||||
/// called by arch specific timers to tick up all kernel related functions
|
||||
pub fn tick() {
|
||||
let mut data = TICK.load(Relaxed);
|
||||
|
|
@ -22,15 +31,3 @@ pub fn tick() {
|
|||
|
||||
TICK.store(data, Relaxed)
|
||||
}
|
||||
|
||||
lazy_static::lazy_static! {
|
||||
/// The number of ticks since the first CPU was started
|
||||
pub static ref TICK: AtomicU64 = AtomicU64::new(0);
|
||||
}
|
||||
|
||||
///
|
||||
pub const KERNEL_VERSION: Version = Version {
|
||||
major: 0,
|
||||
minor: 1,
|
||||
patch: 2,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,12 +1,10 @@
|
|||
//!
|
||||
use core::panic::PanicInfo;
|
||||
//! Panic-related stuff
|
||||
|
||||
// #[macro_use]
|
||||
use core::panic::PanicInfo;
|
||||
use log::error;
|
||||
|
||||
#[panic_handler]
|
||||
fn panic_handler(info: &PanicInfo) -> ! {
|
||||
error!("{}", info);
|
||||
|
||||
loop {}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,11 +3,12 @@
|
|||
/// A process ID
|
||||
pub type PID = u64;
|
||||
|
||||
#[repr(C)]
|
||||
/// Signals that can be sent to a process
|
||||
#[repr(C)]
|
||||
pub enum Signals {
|
||||
/// Terminate the process
|
||||
Terminate,
|
||||
|
||||
/// Shutdown the process and allow it to shutdown cleanly
|
||||
Quit,
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,24 +1,26 @@
|
|||
//!
|
||||
|
||||
use crate::proccess::{Signals, PID};
|
||||
|
||||
/// All possible system calls
|
||||
pub enum Syscall {
|
||||
/// Create a new process and return its PID
|
||||
CreateProcess,
|
||||
|
||||
/// Send a signal to a process
|
||||
SendSignal(PID, Signals),
|
||||
|
||||
/// Get the current process ID
|
||||
GetPID,
|
||||
|
||||
/// Get the current time
|
||||
GetTime,
|
||||
|
||||
/// Set the time
|
||||
SetTime,
|
||||
/*
|
||||
ListInodes,
|
||||
CreateInode,
|
||||
RemoveInode,
|
||||
OpenInode,
|
||||
CloseInode,
|
||||
*/
|
||||
// ListInodes,
|
||||
// CreateInode,
|
||||
// RemoveInode,
|
||||
// OpenInode,
|
||||
// CloseInode,
|
||||
}
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue