syscalls::sock_recv: init

Signed-off-by: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>

Author: Andy-Python-Programmer

patches/mlibc/mlibc.patch

@@ -1,19 +1,30 @@
-From bb17d740b50e98b67c4bdc6449e874568993aa84 Mon Sep 17 00:00:00 2001
+From 24a4e9494f8b2d78936d08ffdfe4cf84cf35e76b Mon Sep 17 00:00:00 2001
 From: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>
 Date: Fri, 8 Jul 2022 12:32:32 +1000
 Subject: [PATCH] yes
 
 Signed-off-by: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>
 ---
+ .gitignore                            |   2 +
  options/ansi/generic/stdlib-stubs.cpp | 142 +++++++++++++++++++++-----
  options/glibc/generic/execinfo.cpp    |   5 +-
  options/rtdl/generic/linker.cpp       |   2 +-
  sysdeps/aero/generic/aero.cpp         |  38 +++----
  sysdeps/aero/generic/filesystem.cpp   |  25 ++++-
- sysdeps/aero/generic/sockets.cpp      |  65 +++++++++++-
- sysdeps/aero/include/aero/syscall.h   |   2 +
- 7 files changed, 225 insertions(+), 54 deletions(-)
+ sysdeps/aero/generic/sockets.cpp      |  77 +++++++++++++-
+ sysdeps/aero/include/aero/syscall.h   |   4 +
+ 8 files changed, 241 insertions(+), 54 deletions(-)
 
+diff --git a/.gitignore b/.gitignore
+index fdd60a00..9f811f47 100644
+--- a/.gitignore
++++ b/.gitignore
+@@ -3,3 +3,5 @@ subprojects
+ *.xbstrap
+ # editor configs:
+ .vscode
++# clangd cache files:
++.cache
 diff --git a/options/ansi/generic/stdlib-stubs.cpp b/options/ansi/generic/stdlib-stubs.cpp
 index 4836391e..2a73c6d0 100644
 --- a/options/ansi/generic/stdlib-stubs.cpp
@@ -316,7 +327,7 @@ index a3e2aca2..4187059e 100644
 +}
  } // namespace mlibc
 diff --git a/sysdeps/aero/generic/sockets.cpp b/sysdeps/aero/generic/sockets.cpp
-index b6b18fe7..33609ca4 100644
+index b6b18fe7..e03c634b 100644
 --- a/sysdeps/aero/generic/sockets.cpp
 +++ b/sysdeps/aero/generic/sockets.cpp
 @@ -1,5 +1,6 @@
@@ -332,16 +343,28 @@ index b6b18fe7..33609ca4 100644
 
 -int sys_accept(int fd, int *newfd) {
 -    auto result = syscall(SYS_ACCEPT, fd);
-+int sys_accept(int fd, int *newfd, struct sockaddr *addr_ptr, socklen_t *addr_length) {
-+    auto result = syscall(SYS_ACCEPT, fd, addr_ptr, addr_length);
++int sys_accept(int sockfd, int *newfd, struct sockaddr *addr_ptr, socklen_t *addr_length) {
++    auto result = syscall(SYS_ACCEPT, sockfd, addr_ptr, addr_length);
 
      if (result < 0) {
          return -result;
-@@ -56,4 +57,64 @@ int sys_accept(int fd, int *newfd) {
+@@ -56,4 +57,76 @@ int sys_accept(int fd, int *newfd) {
      *newfd = result;
      return 0;
  }
 +
++
++int sys_msg_recv(int sockfd, struct msghdr *msg_hdr, int flags, ssize_t *length) {
++	auto result = syscall(SYS_SOCK_RECV, sockfd, msg_hdr, flags);
++	
++	if (result < 0) {
++		return -result;
++	}
++
++	*length = result;
++	return 0;
++}
++
 +int sys_getsockopt(int fd, int layer, int number, void *__restrict buffer, socklen_t *__restrict size) {
 +	(void)fd; (void)size;
 +	if (layer == SOL_SOCKET && number == SO_PEERCRED) {
@@ -403,15 +426,17 @@ index b6b18fe7..33609ca4 100644
 +}
  } // namespace mlibc
 diff --git a/sysdeps/aero/include/aero/syscall.h b/sysdeps/aero/include/aero/syscall.h
-index 12f8dc61..fcc219a9 100644
+index 12f8dc61..50f8cfa7 100644
 --- a/sysdeps/aero/include/aero/syscall.h
 +++ b/sysdeps/aero/include/aero/syscall.h
-@@ -64,6 +64,8 @@
+@@ -64,6 +64,10 @@
  #define SYS_FUTEX_WAIT 57
  #define SYS_FUTEX_WAKE 58
  #define SYS_LINK 59
 +#define SYS_BACKTRACE 60
 +#define SYS_POLL 61
++#define SYS_EXIT_THREAD 62
++#define SYS_SOCK_RECV 63
 
  // Invalid syscall used to trigger a log error in the kernel (as a hint)
  // so, that we can implement the syscall in the kernel.

src/aero_kernel/src/fs/inode.rs

@@ -20,6 +20,7 @@
 use core::sync::atomic::{AtomicUsize, Ordering};
 
 use aero_syscall::prelude::{EPollEventFlags, PollEventFlags};
+use aero_syscall::socket::MessageHeader;
 use aero_syscall::{MMapFlags, OpenFlags};
 
 use alloc::sync::Arc;
@@ -231,6 +232,10 @@ pub trait INodeInterface: Send + Sync {
         Err(FileSystemError::NotSocket)
     }
 
+    fn recv(&self, _message_header: &mut MessageHeader) -> Result<()> {
+        Err(FileSystemError::NotSocket)
+    }
+
     /// Returns the inner UNIX socket inode if bound to one.
     fn as_unix_socket(&self) -> Result<Arc<dyn INodeInterface>> {
         Err(FileSystemError::NotSocket)

src/aero_kernel/src/fs/pipe.rs

@@ -1,46 +1,13 @@
 use core::sync::atomic::{AtomicUsize, Ordering};
 
 use aero_syscall::OpenFlags;
-use alloc::{sync::Arc, vec::Vec};
+use alloc::sync::Arc;
 
+use crate::utils::buffer::Buffer;
 use crate::utils::sync::{BlockQueue, Mutex};
 
 use super::inode::{INodeInterface, PollFlags, PollTable};
 
-struct Buffer {
-    data: Vec<u8>,
-}
-
-impl Buffer {
-    fn new() -> Self {
-        Self { data: Vec::new() }
-    }
-
-    fn has_data(&self) -> bool {
-        !self.data.is_empty()
-    }
-
-    fn read_data(&mut self, buffer: &mut [u8]) -> usize {
-        // nothing to read mate
-        if self.data.is_empty() {
-            return 0;
-        }
-
-        let count = core::cmp::min(buffer.len(), self.data.len());
-
-        for (i, b) in self.data.drain(..count).enumerate() {
-            buffer[i] = b;
-        }
-
-        count
-    }
-
-    fn write_data(&mut self, data: &[u8]) -> usize {
-        self.data.extend_from_slice(data);
-        data.len() - 1
-    }
-}
-
 pub struct Pipe {
     queue: Mutex<Buffer>,
 

src/aero_kernel/src/socket/unix.rs

@@ -19,12 +19,14 @@
 
 use aero_syscall::SocketAddrUnix;
 
+use aero_syscall::socket::MessageHeader;
 use alloc::sync::{Arc, Weak};
 use alloc::vec::Vec;
 
 use crate::fs;
 use crate::fs::inode::{DirEntry, FileType, INodeInterface, Metadata, PollFlags, PollTable};
 use crate::fs::{FileSystemError, Path, Result};
+use crate::utils::buffer::Buffer;
 use crate::utils::sync::{BlockQueue, Mutex};
 
 use super::SocketAddr;
@@ -89,6 +91,7 @@ struct UnixSocketInner {
 
 pub struct UnixSocket {
     inner: Mutex<UnixSocketInner>,
+    buffer: Mutex<Buffer>,
     wq: BlockQueue,
     weak: Weak<UnixSocket>,
 }
@@ -101,6 +104,7 @@ impl UnixSocket {
                 ..Default::default()
             }),
 
+            buffer: Mutex::new(Buffer::new()),
             wq: BlockQueue::new(),
             weak: weak.clone(),
         })
@@ -112,8 +116,11 @@ impl UnixSocket {
 }
 
 impl INodeInterface for UnixSocket {
-    fn read_at(&self, _offset: usize, _buffer: &mut [u8]) -> Result<usize> {
-        unimplemented!()
+    fn read_at(&self, _offset: usize, user_buffer: &mut [u8]) -> Result<usize> {
+        let mut buffer = self.wq.block_on(&self.buffer, |lock| lock.has_data())?;
+
+        let read = buffer.read_data(user_buffer);
+        Ok(read)
     }
 
     fn write_at(&self, _offset: usize, _buffer: &[u8]) -> Result<usize> {
@@ -210,6 +217,10 @@ impl INodeInterface for UnixSocket {
         Ok(sock)
     }
 
+    fn recv(&self, _message_header: &mut MessageHeader) -> Result<()> {
+        Ok(())
+    }
+
     fn poll(&self, table: Option<&mut PollTable>) -> Result<PollFlags> {
         table.map(|e| e.insert(&self.wq));
 

src/aero_kernel/src/syscall/mod.rs

@@ -219,6 +219,7 @@ pub fn generic_do_syscall(
         SYS_CONNECT => net::connect(b, c, d),
         SYS_LISTEN => net::listen(b, c),
         SYS_ACCEPT => net::accept(b, c, d),
+        SYS_SOCK_RECV => net::sock_recv(b, c, d),
 
         SYS_GETTIME => time::gettime(b, c),
         SYS_SLEEP => time::sleep(b),

src/aero_kernel/src/syscall/net.rs

@@ -1,3 +1,4 @@
+use aero_syscall::socket::MessageHeader;
 use aero_syscall::*;
 
 use crate::fs::inode::DirEntry;
@@ -52,6 +53,24 @@ pub fn accept(
     Ok(handle)
 }
 
+#[syscall]
+pub fn sock_recv(
+    sockfd: usize,
+    header: &mut MessageHeader,
+    flags: usize,
+) -> Result<usize, SyscallError> {
+    assert!(flags == 0, "sock_recv: flags are not currently supported");
+
+    let current_task = scheduler::get_scheduler().current_task();
+    let socket = current_task
+        .file_table
+        .get_handle(sockfd)
+        .ok_or(SyscallError::EINVAL)?;
+
+    socket.inode().recv(header)?;
+    Ok(0)
+}
+
 /// Marks the socket as a passive socket (i.e. as a socket that will be used to accept incoming
 /// connection requests).
 #[syscall]

src/aero_kernel/src/unwind.rs

@@ -111,7 +111,7 @@ pub fn unwind_stack_trace() {
 
     log::trace!("{:-^80}", " BACKTRACE ");
 
-    for depth in 0..64 {
+    for depth in 0../*64*/16 {
         if let Some(rip_rbp) = rbp.checked_add(core::mem::size_of::<usize>()) {
             if offset_table
                 .translate_addr(VirtAddr::new(rip_rbp as u64))

src/aero_kernel/src/utils/buffer.rs

@@ -19,6 +19,42 @@
 
 use core::fmt::Write;
 
+use alloc::vec::Vec;
+
+pub struct Buffer {
+    data: Vec<u8>,
+}
+
+impl Buffer {
+    pub fn new() -> Self {
+        Self { data: Vec::new() }
+    }
+
+    pub fn has_data(&self) -> bool {
+        !self.data.is_empty()
+    }
+
+    pub fn read_data(&mut self, buffer: &mut [u8]) -> usize {
+        // nothing to read
+        if self.data.is_empty() {
+            return 0;
+        }
+
+        let count = core::cmp::min(buffer.len(), self.data.len());
+
+        for (i, b) in self.data.drain(..count).enumerate() {
+            buffer[i] = b;
+        }
+
+        count
+    }
+
+    pub fn write_data(&mut self, data: &[u8]) -> usize {
+        self.data.extend_from_slice(data);
+        data.len() - 1
+    }
+}
+
 /// Special special kind of buffer that stores valid UTF-8 text
 /// is always a constant size, removing the oldest messages when
 /// new messages are received without allocating memory on the

src/aero_syscall/src/consts.rs

@@ -83,6 +83,7 @@ pub const SYS_LINK: usize = 59;
 pub const SYS_BACKTRACE: usize = 60;
 pub const SYS_POLL: usize = 61;
 pub const SYS_EXIT_THREAD: usize = 62;
+pub const SYS_SOCK_RECV: usize = 63;
 
 // constants for fcntl()'s command argument:
 pub const F_DUPFD: usize = 1;

src/aero_syscall/src/lib.rs

@@ -22,6 +22,7 @@
 
 pub mod consts;
 pub mod signal;
+pub mod socket;
 pub mod syscall;
 
 pub use crate::syscall::*;