1
1
Fork 1
forked from AbleOS/ableos

begin work on ipc protocols

This commit is contained in:
able 2024-03-22 05:13:17 -05:00
parent cc4de4ab5e
commit 5e73e7a370
5 changed files with 106 additions and 33 deletions
kernel/src
sysdata/test-programs

View file

@ -1,30 +1,74 @@
use {
crate::{
alloc::string::ToString,
arch::hardware_random_u64,
holeybytes::{ecah::LogError, kernel_services::block_read, Vm},
ipc::{protocol, protocol::Protocol},
},
alloc::string::String,
hashbrown::HashMap,
log::info,
spin::{lazy::Lazy, Mutex},
};
pub struct Services(HashMap<u64, String>);
pub struct Services(HashMap<u64, Protocol>);
pub static SERVICES: Lazy<Mutex<Services>> = Lazy::new(|| {
let mut dt = Services(HashMap::new());
dt.0.insert(0, "SDS".to_string());
info!("test");
dt.0.insert(0, Protocol::void());
Mutex::new(dt)
});
pub fn sds_msg_handler(vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), LogError> {
let mut msg_vec = block_read(mem_addr, length);
let buffer_id_raw = &msg_vec[0..8];
let mut arr = [0u8; 8];
arr.copy_from_slice(&buffer_id_raw);
let buffer_id = u64::from_le_bytes(arr);
info!("BufferID({:x?})", buffer_id);
let sds_event_type: ServiceEventType = msg_vec[0].into();
msg_vec.remove(0);
use ServiceEventType::*;
match sds_event_type {
CreateService => {
let string = String::from_utf8(msg_vec).expect("Our bytes should be valid utf8");
sds_create_service(string);
}
DeleteService => todo!(),
SearchServices => todo!(),
}
// let buffer_id_raw = &msg_vec[0..8];
// let mut arr = [0u8; 8];
// arr.copy_from_slice(&buffer_id_raw);
// let buffer_id = u64::from_le_bytes(arr);
// info!("BufferID({:x?})", buffer_id);
// let mut services = SERVICES.lock();
// let string = String::from_utf8(msg_vec).expect("Our bytes should be valid utf8");
// use core::borrow::BorrowMut;
// services.borrow_mut().0.insert(buffer_id, string);
Ok(())
}
enum ServiceEventType {
CreateService = 0,
// UpdateService = 1,
DeleteService = 2,
SearchServices = 3,
}
impl From<u8> for ServiceEventType {
fn from(value: u8) -> Self {
use self::*;
match value {
0 => Self::CreateService,
// 1 =>
2 => Self::DeleteService,
3 => Self::SearchServices,
1_u8 | 4_u8..=u8::MAX => todo!(),
}
}
}
fn sds_create_service(protocol: String) -> u64 {
let buff_id = hardware_random_u64();
let mut services = SERVICES.lock();
services.0.insert(buff_id, protocol.clone().into());
info!("BufferID({}) => {}", buff_id, protocol);
let a: protocol::Protocol = protocol.into();
buff_id
}

View file

@ -1,10 +1,9 @@
//!
use {
super::message::Message,
super::{message::Message, protocol::Protocol},
crossbeam_queue::{ArrayQueue, SegQueue},
};
pub enum BufferTypes {
Unbound(SegQueue<Message>),
Bound(ArrayQueue<Message>),
@ -30,14 +29,14 @@ impl IpcBuffer {
let buftype = BufferTypes::Unbound(SegQueue::new());
Self {
protocol: Protocol {},
protocol: Protocol::void(),
buffer: buftype,
}
}
(true, length) => {
let buftype = BufferTypes::Bound(ArrayQueue::new(length as usize));
Self {
protocol: Protocol {},
protocol: Protocol::void(),
buffer: buftype,
}
}
@ -72,17 +71,3 @@ pub enum IpcError {
/// An invalid message error returned to the sender
InvalidMessage,
}
/// TODO: define this, possibly as the binary form of the IDL
/// DEPEND: This depends on an IDL
pub struct Protocol {
// TODO: add in settings
// like `invalid_message_handler` with some options similar to
// `Deny` Drops the message
// `Allow` Allows invalid messages (This disables validators IPC side and relies on programs to handle invalid messages)
// `CustomFunct` a callback
// and `report_invalid_messages_to_sender`
// `True`
// `False`
// settings: PSettings,
}

View file

@ -1,3 +1,4 @@
//! Interprocess communication
pub mod buffer;
pub mod message;
pub mod protocol;

View file

@ -0,0 +1,40 @@
use {
alloc::{string::String, vec::Vec},
hashbrown::HashMap,
log::info,
};
pub struct Type {}
pub struct Funct {
takes: Vec<String>,
gives: Vec<String>,
}
pub struct Protocol {
types: HashMap<String, Type>,
fns: HashMap<String, Funct>,
}
impl Protocol {
pub fn void() -> Self {
Self {
types: HashMap::new(),
fns: HashMap::new(),
}
}
// Check if a protocol defines all types it needs too
fn validate_protocol() -> bool {
false
}
}
impl From<String> for Protocol {
fn from(value: alloc::string::String) -> Self {
if value.starts_with("protocol") {
info!("ABC");
}
Self {
types: HashMap::new(),
fns: HashMap::new(),
}
}
}

View file

@ -1,7 +1,7 @@
fn set_buffer_protocol(buffer_id, string) {
let str = data::str("01234567" + string);
li64(r10, buffer_id);
str(r10, r0, str, 8);
fn create_buffer_protocol(string) {
let str = data::str("0" + string);
li8(r10, 0);
str(r10, r0, str, 1);
li64(r1, 3);
li64(r2, 0);
@ -11,6 +11,9 @@ fn set_buffer_protocol(buffer_id, string) {
}
set_buffer_protocol(1, "string");
create_buffer_protocol("protocol Math {\n\r"+
"\tfn add(i64, i64) -> i64;\n\r"+
"\tfn div(i64, i64) -> i64;\n\r"+
"}");
tx();