send/recv socket syscalls

Author: xor-bits

Cargo.lock

@@ -29,7 +29,7 @@ pc-keyboard = { git = "https://github.com/rust-embedded-community/pc-keyboard",
 paste = "1.0"       # macro ident concat
 bit_field = "0.10"
 bytemuck = { version = "1.13", features = ["derive"] }
-lock_api = "0.4"
+lock_api = { version = "0.4", features = ["arc_lock"] }
 ringbuf = { version = "0.3", default-features = false, features = ["alloc"] }
 # rpds = { version = "1.1", default-features = false }
 # image = "0.24"

Cargo.toml

@@ -19,6 +19,7 @@ x86_64.workspace = true
 time.workspace = true
 futures-util.workspace = true
 crossbeam.workspace = true
+lock_api.workspace = true
 
 hyperion-arch.path = "../arch"
 hyperion-backtrace.path = "../backtrace"

crates/kernel/Cargo.toml

@@ -31,6 +31,7 @@ use hyperion_vfs::{
     path::Path,
     tree::{FileRef, Node},
 };
+use lock_api::ArcMutexGuard;
 use time::Duration;
 use x86_64::{structures::paging::PageTableFlags, VirtAddr};
 
@@ -242,39 +243,6 @@ pub fn pfree(args: &mut SyscallRegs) -> Result<usize> {
     return Ok(0);
 }
 
-/// send data to an input channel of a process
-///
-/// # arguments
-///  - `syscall_id` : 11
-///  - `arg0`       : target PID
-///  - `arg1`       : data ptr
-///  - `arg2`       : data len (bytes)
-pub fn send(args: &mut SyscallRegs) -> Result<usize> {
-    let target_pid = args.arg0;
-    let data = read_untrusted_bytes(args.arg1, args.arg2)?;
-
-    let pid = hyperion_scheduler::task::Pid::new(target_pid as usize);
-
-    if hyperion_scheduler::send(pid, data).is_err() {
-        return Err(Error::NO_SUCH_PROCESS);
-    }
-
-    return Ok(0);
-}
-
-/// recv data from this process input channel
-///
-/// returns the number of bytes read
-///
-/// # arguments
-///  - `syscall_id` : 12
-///  - `arg0`       : data ptr
-///  - `arg1`       : data len (bytes)
-pub fn recv(args: &mut SyscallRegs) -> Result<usize> {
-    let buf = read_untrusted_bytes_mut(args.arg0, args.arg1)?;
-    return Ok(hyperion_scheduler::recv(buf));
-}
-
 /// rename the current process
 ///
 /// # arguments
@@ -503,24 +471,16 @@ fn _bind(socket: SocketDesc, addr: &str) -> Result<()> {
         return Err(Error::NOT_FOUND);
     };
 
-    let this = process();
-    let ext = process_ext_with(&this);
+    let socket = get_socket(socket)?;
 
-    let sockets = ext.sockets.lock();
-    let socket_file = sockets
-        .get(socket.0)
-        .and_then(|s| s.as_ref())
-        .ok_or(Error::BAD_FILE_DESCRIPTOR)?
-        .socket_ref
-        .clone();
-    drop(sockets);
-
-    let dir = VFS_ROOT
+    VFS_ROOT
+        // find the directory node
         .find_dir(dir, false)
-        .map_err(map_vfs_err_to_syscall_err)?;
-
-    dir.lock()
-        .create_node(sock_file, Node::File(socket_file))
+        .map_err(map_vfs_err_to_syscall_err)?
+        // lock the directory
+        .lock_arc()
+        // create the socket file in that directory
+        .create_node(sock_file, Node::File(socket))
         .map_err(map_vfs_err_to_syscall_err)?;
 
     return Ok(());
@@ -535,17 +495,9 @@ fn listen(args: &mut SyscallRegs) -> Result<usize> {
 }
 
 fn _listen(socket: SocketDesc) -> Result<()> {
-    let this = process();
-    let ext = process_ext_with(&this);
-
-    ext.sockets
-        .lock()
-        .get(socket.0)
-        .and_then(|s| s.as_ref())
-        .ok_or(Error::BAD_FILE_DESCRIPTOR)?
-        .socket_ref
-        .lock()
-        .conn = Some(Arc::new(Channel::new()));
+    get_socket_locked(socket)?
+        .conn
+        .get_or_insert_with(|| Arc::new(Channel::new()));
 
     Ok(())
 }
@@ -560,19 +512,7 @@ fn accept(args: &mut SyscallRegs) -> Result<usize> {
 }
 
 fn _accept(socket: SocketDesc) -> Result<SocketDesc> {
-    let this = process();
-    let ext = process_ext_with(&this);
-
-    let sockets = ext.sockets.lock();
-    let socket = sockets
-        .get(socket.0)
-        .and_then(|s| s.as_ref())
-        .ok_or(Error::BAD_FILE_DESCRIPTOR)?
-        .socket_ref
-        .clone();
-    drop(sockets);
-
-    let mut socket = socket.lock();
+    let mut socket = get_socket_locked(socket)?;
 
     let domain = socket.domain;
     let ty = socket.ty;
@@ -609,22 +549,13 @@ fn connect(args: &mut SyscallRegs) -> Result<usize> {
 }
 
 fn _connect(socket: SocketDesc, addr: &str) -> Result<()> {
-    let this = process();
-    let ext = process_ext_with(&this);
-
-    let sockets = ext.sockets.lock();
-    let client = sockets
-        .get(socket.0)
-        .and_then(|s| s.as_ref())
-        .ok_or(Error::BAD_FILE_DESCRIPTOR)?
-        .socket_ref
-        .clone();
-    drop(sockets);
+    // get the client socket early to test for errors, but lock it late
+    let client = get_socket(socket)?;
 
     let server = VFS_ROOT
         .find_file(addr, false, false)
-        .map_err(map_vfs_err_to_syscall_err)?;
-    let server = server.lock();
+        .map_err(map_vfs_err_to_syscall_err)?
+        .lock_arc();
 
     // TODO: inode
     let conn = server
@@ -642,13 +573,62 @@ fn _connect(socket: SocketDesc, addr: &str) -> Result<()> {
     drop(server);
 
     let pipe = Arc::new(Pipe::new());
-    conn.send(pipe.clone());
-
-    client.lock().pipe = Some(pipe);
+    client.lock().pipe = Some(pipe.clone());
+    conn.send(pipe);
 
     Ok(())
 }
 
+/// send data to a socket
+///
+/// [`hyperion_syscall::send`]
+pub fn send(args: &mut SyscallRegs) -> Result<usize> {
+    let socket = SocketDesc(args.arg0 as _);
+    let data = read_untrusted_bytes(args.arg1, args.arg2)?;
+    let flags = args.arg3 as _;
+
+    _send(socket, data, flags).map(|_| 0)
+}
+
+fn _send(socket: SocketDesc, data: &[u8], _flags: usize) -> Result<()> {
+    let socket = get_socket_locked(socket)?;
+
+    let Some(pipe) = socket.pipe.as_ref().cloned() else {
+        return Err(Error::BAD_FILE_DESCRIPTOR);
+    };
+
+    drop(socket);
+
+    pipe.send_slice(data);
+
+    return Ok(());
+}
+
+/// recv data from a socket
+///
+/// [`hyperion_syscall::recv`]
+pub fn recv(args: &mut SyscallRegs) -> Result<usize> {
+    let socket = SocketDesc(args.arg0 as _);
+    let buf = read_untrusted_bytes_mut(args.arg1, args.arg2)?;
+    let flags = args.arg3 as _;
+
+    _recv(socket, buf, flags)
+}
+
+fn _recv(socket: SocketDesc, buf: &mut [u8], _flags: usize) -> Result<usize> {
+    let socket = get_socket_locked(socket)?;
+
+    let Some(pipe) = socket.pipe.as_ref().cloned() else {
+        return Err(Error::BAD_FILE_DESCRIPTOR);
+    };
+
+    drop(socket);
+
+    let bytes = pipe.recv_slice(buf);
+
+    return Ok(bytes);
+}
+
 //
 
 struct ProcessExtra {
@@ -711,6 +691,26 @@ impl ProcessExt for ProcessExtra {
 
 //
 
+fn get_socket_locked(socket: SocketDesc) -> Result<ArcMutexGuard<Futex, SocketFile>> {
+    get_socket(socket).map(|v| v.lock_arc())
+}
+
+fn get_socket(socket: SocketDesc) -> Result<Arc<Mutex<SocketFile>>> {
+    let this = process();
+    let ext = process_ext_with(&this);
+
+    let socket = ext
+        .sockets
+        .lock()
+        .get(socket.0)
+        .and_then(|s| s.as_ref())
+        .ok_or(Error::BAD_FILE_DESCRIPTOR)?
+        .socket_ref
+        .clone();
+
+    Ok(socket)
+}
+
 fn process_ext_with(proc: &Process) -> &ProcessExtra {
     proc.ext
         .call_once(|| {

crates/kernel/src/syscall.rs

@@ -1,4 +1,4 @@
-use alloc::{format, string::String, vec::Vec};
+use alloc::{string::String, vec::Vec};
 use core::slice::memchr;
 
 //
@@ -11,7 +11,9 @@ pub struct SimpleIpcInputChannel;
 
 impl Read for SimpleIpcInputChannel {
     fn recv(&mut self, buf: &mut [u8]) -> Result<usize, String> {
-        hyperion_syscall::recv(buf).map_err(|err| format!("failed to recv: {err}"))
+        _ = buf;
+        todo!()
+        // hyperion_syscall::recv(buf).map_err(|err| format!("failed to recv: {err}"))
     }
 }
 

crates/sample-elf/src/io.rs

@@ -40,11 +40,11 @@ pub fn main(_args: CliArgs) {
 
         bind(server, "/dev/server.sock").unwrap();
 
-        let _conn = accept(server).unwrap();
+        let conn = accept(server).unwrap();
 
         println!("connected");
 
-        // TODO: send(conn, b"Hello").unwrap();
+        send(conn, b"Hello", 0).unwrap();
     });
 
     // wait for the server to be up
@@ -56,10 +56,11 @@ pub fn main(_args: CliArgs) {
 
     println!("connected");
 
-    // TODO:
-    // let mut buf = [0u8; 64];
-    // let len = recv(client, &mut buf).unwrap();
-    // assert_eq!(&buf[..len], b"Hello");
+    let mut buf = [0u8; 64];
+    let len = recv(client, &mut buf, 0).unwrap();
+    assert_eq!(&buf[..len], b"Hello");
+
+    println!("got `{:?}`", core::str::from_utf8(&buf[..len]));
 
     /* match args.iter().next().expect("arg0 to be present") {
         // busybox style single binary 'coreutils'

crates/sample-elf/src/main.rs

@@ -30,16 +30,16 @@ pub mod id {
     pub const RECV: usize = 12;
     pub const RENAME: usize = 13;
 
-    pub const OPEN: usize = 1000;
-    pub const CLOSE: usize = 1100;
-    pub const READ: usize = 1200;
-    pub const WRITE: usize = 1300;
+    pub const OPEN: usize = 14;
+    pub const CLOSE: usize = 15;
+    pub const READ: usize = 16;
+    pub const WRITE: usize = 17;
 
-    pub const SOCKET: usize = 2000;
-    pub const BIND: usize = 2100;
-    pub const LISTEN: usize = 2200;
-    pub const ACCEPT: usize = 2300;
-    pub const CONNECT: usize = 2400;
+    pub const SOCKET: usize = 18;
+    pub const BIND: usize = 19;
+    pub const LISTEN: usize = 20;
+    pub const ACCEPT: usize = 21;
+    pub const CONNECT: usize = 22;
 }
 
 //
@@ -168,17 +168,6 @@ pub fn pfree(ptr: NonNull<u8>, pages: usize) -> Result<()> {
     unsafe { syscall_2(id::PFREE, ptr.as_ptr() as usize, pages) }.map(|_| {})
 }
 
-/// send data to a PID based single naïve IPC channel
-#[inline(always)]
-pub fn send(target: usize, data: &[u8]) -> Result<()> {
-    unsafe { syscall_3(id::SEND, target, data.as_ptr() as usize, data.len()) }.map(|_| {})
-}
-
-/// read data from a PID based single naïve IPC channel
-pub fn recv(buf: &mut [u8]) -> Result<usize> {
-    unsafe { syscall_2(id::RECV, buf.as_mut_ptr() as usize, buf.len()) }
-}
-
 /// rename the current process
 #[inline(always)]
 pub fn rename(new_name: &str) -> Result<()> {
@@ -247,3 +236,16 @@ pub fn accept(socket: SocketDesc) -> Result<SocketDesc> {
 pub fn connect(socket: SocketDesc, addr: &str) -> Result<()> {
     unsafe { syscall_3(id::CONNECT, socket.0, addr.as_ptr() as _, addr.len()) }.map(|_| {})
 }
+
+/// send data to a socket
+#[inline(always)]
+pub fn send(socket: SocketDesc, data: &[u8], flags: usize) -> Result<()> {
+    let (data, data_len) = (data.as_ptr() as usize, data.len());
+    unsafe { syscall_4(id::SEND, socket.0, data, data_len, flags) }.map(|_| {})
+}
+
+/// read data from a socket
+pub fn recv(socket: SocketDesc, buf: &mut [u8], flags: usize) -> Result<usize> {
+    let (buf, buf_len) = (buf.as_ptr() as usize, buf.len());
+    unsafe { syscall_4(id::RECV, socket.0, buf, buf_len, flags) }
+}