aipc, an async ipc library for aero

userland/Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["apps/*", "servers/*"]
+members = ["apps/*", "servers/*", "libs/*"]
 
 [profile.release]
 debug = true

userland/apps/aero_shell/Cargo.toml

@@ -7,4 +7,3 @@ edition = "2021"
 [dependencies]
 std = { path = "../../libs/aero_std" }
 aero_syscall = { path = "../../../src/aero_syscall" }
-aero_ipc = { path = "../../libs/aero_ipc" }

userland/apps/aero_shell/src/main.rs

@@ -21,7 +21,6 @@ extern crate alloc;
 
 use core::sync::atomic::{AtomicU32, Ordering};
 
-use aero_ipc::SystemService;
 use aero_syscall::signal::*;
 use aero_syscall::*;
 
@@ -126,17 +125,15 @@ fn repl(history: &mut Vec<String>) -> Result<(), AeroSyscallError> {
                 // if the test kernel is built instead of randomly bloating the shell
                 // with tests :).
 
-                // let fb = sys_open("/dev/fb", OpenFlags::O_RDWR)?;
+                let fb = sys_open("/dev/fb", OpenFlags::O_RDWR)?;
 
-                // let buffer = &[u32::MAX; (1024 * 768)];
-                // let casted = buffer.as_ptr() as *mut u8;
-                // let casted = unsafe { core::slice::from_raw_parts(casted, (1024 * 768) as usize) };
+                let buffer = &[u32::MAX; (1024 * 768)];
+                let casted = buffer.as_ptr() as *mut u8;
+                let casted = unsafe { core::slice::from_raw_parts(casted, (1024 * 768) as usize) };
 
-                // println!("writing to fb");
-                // sys_write(fb, casted)?;
-                // sys_close(fb)?;
-
-                uwutest()?;
+                println!("writing to fb");
+                sys_write(fb, casted)?;
+                sys_close(fb)?;
             }
 
             "pid" => {
@@ -295,21 +292,6 @@ fn print_kernel_log() -> Result<(), AeroSyscallError> {
     cat_file(Some("/dev/kmsg"))
 }
 
-fn uwutest() -> Result<(), AeroSyscallError> {
-    let my_pid = sys_getpid()?;
-    let ipc = SystemService::open(sys_ipc_discover_root()?);
-
-    ipc.announce(my_pid, "TestServer")
-        .expect("Failed to announce");
-
-    println!(
-        "TestServer is at {}",
-        ipc.discover("TestServer").expect("Failed to discover")
-    );
-
-    Ok(())
-}
-
 fn get_uptime() -> Result<String, AeroSyscallError> {
     let mut info = unsafe { core::mem::zeroed() };
 

userland/apps/aipc_test/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "aipc_test"
+version = "0.1.0"
+edition = "2021"
+authors = ["pitust <[email protected]>"]
+
+[dependencies]
+std = { path = "../../libs/aero_std" }
+aero_syscall = { path = "../../../src/aero_syscall" }
+aipc = { path = "../../libs/aipc" }
+postcard = { version = "0.7.3", features = ["alloc"] }
+spin = "0.9"

userland/apps/aipc_test/src/main.rs

@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2021-2022 The Aero Project Developers.
+ *
+ * This file is part of The Aero Project.
+ *
+ * Aero is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Aero is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Aero. If not, see <https://www.gnu.org/licenses/>.
+ */
+use core::sync::atomic::{AtomicUsize, Ordering, AtomicBool};
+
+use aero_syscall::{sys_fork, sys_exit};
+use aipc::async_runtime::Listener;
+
+#[aipc::def("TestObj")]
+trait TestObj {
+    async fn create() -> TestObj;
+    async fn foo(&self);
+    async fn kill(&self);
+}
+#[aipc::def("ServerControlObj")]
+trait ServerControlObj {
+    async fn create() -> ServerControlObj;
+    async fn can_control(&self) -> bool;
+    async fn quit(&self);
+}
+
+static COUNTER: AtomicUsize = AtomicUsize::new(1);
+
+struct NoData {
+    data: usize,
+}
+
+#[aipc::object(TestObjSrv as TestObj)]
+impl NoData {
+    fn create() -> NoData {
+        return NoData {
+            data: COUNTER.fetch_add(1, Ordering::SeqCst),
+        };
+    }
+    fn foo(&self) {
+        println!("Hello from obj {}!", self.data);
+    }
+}
+
+static SCS_PERMIT_ONCE: AtomicBool = AtomicBool::new(true);
+pub struct ServerControlState {
+    permitted: bool
+}
+#[aipc::object(ServerControlSrv as ServerControlObj)]
+impl ServerControlState {
+    pub fn create() -> ServerControlState {
+        return ServerControlState {
+            permitted: SCS_PERMIT_ONCE.swap(false, Ordering::SeqCst)
+        };
+    }
+    pub fn can_control(&self) -> bool {
+        self.permitted
+    }
+    pub fn quit(&self) {
+        if self.permitted {
+            println!("[ServerControlSrv] exiting!");
+            aipc::async_runtime::spawn(async {
+                sys_exit(0);
+            });
+        }
+    }
+}
+
+
+fn main() {
+    let mut rt = aipc::async_runtime::AsyncRuntime::new();
+    rt.spawn(async {
+        let pid = sys_fork().unwrap();
+        if pid == 0 {
+            // server
+            ServerControlSrv::listen();
+            TestObjSrv::listen();
+        } else {
+            // client
+            let ctl = ServerControlObj::create(pid).await;
+            let o = TestObj::create(pid).await;
+            o.foo().await;
+            ctl.quit().await;
+            sys_exit(0);
+        }
+    });
+    rt.run();
+}

userland/apps/utest/Cargo.toml

@@ -7,5 +7,5 @@ authors = ["Anhad Singh <[email protected]>"]
 [dependencies]
 std = { path = "../../libs/aero_std" }
 aero_syscall = { path = "../../../src/aero_syscall" }
-aero_ipc = { path = "../../libs/aero_ipc" }
+aipc = { path = "../../libs/aipc" }
 utest-proc = { path = "../utest-proc" }