UnixSocket::accept(): initial implementation

* VM: more deadlock fixes
* mlibc::sys_getsockopt and mlibc::sys_setsockopt stubs
* syscall::accept: fix signature

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

patches/mlibc/mlibc.patch

@@ -1,4 +1,4 @@
-From 32d24edf161f338847c32fa2f44dc80422d4795e Mon Sep 17 00:00:00 2001
+From bb17d740b50e98b67c4bdc6449e874568993aa84 Mon Sep 17 00:00:00 2001
 From: Andy-Python-Programmer <[email protected]>
 Date: Fri, 8 Jul 2022 12:32:32 +1000
 Subject: [PATCH] yes
@@ -8,11 +8,11 @@ Signed-off-by: Andy-Python-Programmer <[email protected]>
  options/ansi/generic/stdlib-stubs.cpp | 142 +++++++++++++++++++++-----
  options/glibc/generic/execinfo.cpp    |   5 +-
  options/rtdl/generic/linker.cpp       |   2 +-
- sysdeps/aero/generic/aero.cpp         |  14 +--
+ sysdeps/aero/generic/aero.cpp         |  38 +++----
  sysdeps/aero/generic/filesystem.cpp   |  25 ++++-
- sysdeps/aero/generic/sockets.cpp      |   4 +-
+ sysdeps/aero/generic/sockets.cpp      |  65 +++++++++++-
  sysdeps/aero/include/aero/syscall.h   |   2 +
- 7 files changed, 152 insertions(+), 42 deletions(-)
+ 7 files changed, 225 insertions(+), 54 deletions(-)
 
 diff --git a/options/ansi/generic/stdlib-stubs.cpp b/options/ansi/generic/stdlib-stubs.cpp
 index 4836391e..2a73c6d0 100644
@@ -198,9 +198,44 @@ index 6716ef4f..e5ec8cff 100644
  constexpr bool eagerBinding = true;
 
 diff --git a/sysdeps/aero/generic/aero.cpp b/sysdeps/aero/generic/aero.cpp
-index 29fb9610..645a84d5 100644
+index 29fb9610..a27da559 100644
 --- a/sysdeps/aero/generic/aero.cpp
 +++ b/sysdeps/aero/generic/aero.cpp
+@@ -69,22 +69,22 @@ int sys_futex_tid() {
+ }
+ 
+ int sys_futex_wait(int *pointer, int expected, const struct timespec *time) {
+-    auto result = syscall(SYS_FUTEX_WAIT, pointer, expected, time);
+-
+-    if (result < 0) {
+-        return -result;
+-    }
+-
++    // auto result = syscall(SYS_FUTEX_WAIT, pointer, expected, time);
++    //
++    // if (result < 0) {
++    //     return -result;
++    // }
++    //
+     return 0;
+ }
+ 
+ int sys_futex_wake(int *pointer) {
+-    auto result = syscall(SYS_FUTEX_WAKE, pointer);
+-
+-    if (result < 0) {
+-        return -result;
+-    }
+-
++    // auto result = syscall(SYS_FUTEX_WAKE, pointer);
++    //
++    // if (result < 0) {
++    //     return -result;
++    // }
++    //
+     return 0;
+ }
+ 
 @@ -124,7 +124,9 @@ int sys_anon_free(void *pointer, size_t size) {
  }
 
@@ -240,7 +275,7 @@ index 29fb9610..645a84d5 100644
  }
 
 diff --git a/sysdeps/aero/generic/filesystem.cpp b/sysdeps/aero/generic/filesystem.cpp
-index a3e2aca2..09e6444f 100644
+index a3e2aca2..4187059e 100644
 --- a/sysdeps/aero/generic/filesystem.cpp
 +++ b/sysdeps/aero/generic/filesystem.cpp
 @@ -158,11 +158,6 @@ int sys_tcsetattr(int fd, int optional_action, const struct termios *attr) {
@@ -269,7 +304,7 @@ index a3e2aca2..09e6444f 100644
 +    }
 +
 +    *num_events = result;
-+        return 0;
++    return 0;
 +}
 +
 +int sys_poll(struct pollfd *fds, nfds_t count, int timeout, int *num_events) {
@@ -281,10 +316,17 @@ index a3e2aca2..09e6444f 100644
 +}
  } // namespace mlibc
 diff --git a/sysdeps/aero/generic/sockets.cpp b/sysdeps/aero/generic/sockets.cpp
-index b6b18fe7..111dc570 100644
+index b6b18fe7..33609ca4 100644
 --- a/sysdeps/aero/generic/sockets.cpp
 +++ b/sysdeps/aero/generic/sockets.cpp
-@@ -46,8 +46,8 @@ int sys_listen(int fd, int backlog) {
+@@ -1,5 +1,6 @@
+ #include <mlibc/all-sysdeps.hpp>
+ #include <mlibc/thread-entry.hpp>
++#include <mlibc/debug.hpp>
+ 
+ #include <aero/syscall.h>
+ #include <stdint.h>
+@@ -46,8 +47,8 @@ int sys_listen(int fd, int backlog) {
      return 0;
  }
 
@@ -295,6 +337,71 @@ index b6b18fe7..111dc570 100644
 
      if (result < 0) {
          return -result;
+@@ -56,4 +57,64 @@ int sys_accept(int fd, int *newfd) {
+     *newfd = 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) {
++		mlibc::infoLogger() << "\e[31mmlibc: getsockopt() call with SOL_SOCKET and SO_PEERCRED is unimplemented\e[39m" << frg::endlog;
++		*(int *)buffer = 0;
++		return 0;
++	} else if(layer == SOL_SOCKET && number == SO_SNDBUF) {
++		mlibc::infoLogger() << "\e[31mmlibc: getsockopt() call with SOL_SOCKET and SO_SNDBUF is unimplemented\e[39m" << frg::endlog;
++		*(int *)buffer = 4096;
++		return 0;
++	} else if(layer == SOL_SOCKET && number == SO_TYPE) {
++		mlibc::infoLogger() << "\e[31mmlibc: getsockopt() call with SOL_SOCKET and SO_TYPE is unimplemented, hardcoding SOCK_STREAM\e[39m" << frg::endlog;
++		*(int *)buffer = SOCK_STREAM;
++		return 0;
++	} else if(layer == SOL_SOCKET && number == SO_ERROR) {
++		mlibc::infoLogger() << "\e[31mmlibc: getsockopt() call with SOL_SOCKET and SO_ERROR is unimplemented, hardcoding 0\e[39m" << frg::endlog;
++		*(int *)buffer = 0;
++		return 0;
++	} else if(layer == SOL_SOCKET && number == SO_KEEPALIVE) {
++		mlibc::infoLogger() << "\e[31mmlibc: getsockopt() call with SOL_SOCKET and SO_KEEPALIVE is unimplemented, hardcoding 0\e[39m" << frg::endlog;
++		*(int *)buffer = 0;
++		return 0;
++	} else{
++		mlibc::panicLogger() << "\e[31mmlibc: Unexpected getsockopt() call, layer: " << layer << " number: " << number << "\e[39m" << frg::endlog;
++		__builtin_unreachable();
++	}
++
++	return 0;
++}
++
++int sys_setsockopt(int fd, int layer, int number, const void *buffer, socklen_t size) {
++	(void)fd; (void)buffer; (void)size;
++
++	if (layer == SOL_SOCKET && number == SO_PASSCRED) {
++		mlibc::infoLogger() << "\e[31mmlibc: setsockopt(SO_PASSCRED) is not implemented correctly\e[39m" << frg::endlog;
++		return 0;
++	} else if (layer == SOL_SOCKET && number == SO_ATTACH_FILTER) {
++		mlibc::infoLogger() << "\e[31mmlibc: setsockopt(SO_ATTACH_FILTER) is not implemented correctly\e[39m" << frg::endlog;
++		return 0;
++	} else if (layer == SOL_SOCKET && number == SO_RCVBUFFORCE) {
++		mlibc::infoLogger() << "\e[31mmlibc: setsockopt(SO_RCVBUFFORCE) is not implemented correctly\e[39m" << frg::endlog;
++		return 0;
++	} else if (layer == SOL_SOCKET && number == SO_SNDBUF) {
++		mlibc::infoLogger() << "\e[31mmlibc: setsockopt() call with SOL_SOCKET and SO_SNDBUF is unimplemented\e[39m" << frg::endlog;
++		return 0;
++	} else if (layer == SOL_SOCKET && number == SO_KEEPALIVE) {
++		mlibc::infoLogger() << "\e[31mmlibc: setsockopt() call with SOL_SOCKET and SO_KEEPALIVE is unimplemented\e[39m" << frg::endlog;
++		return 0;
++	} else if (layer == SOL_SOCKET && number == SO_REUSEADDR) {
++		mlibc::infoLogger() << "\e[31mmlibc: setsockopt() call with SOL_SOCKET and SO_REUSEADDR is unimplemented\e[39m" << frg::endlog;
++		return 0;
++	} else if (layer == AF_NETLINK && number == SO_ACCEPTCONN) {
++		mlibc::infoLogger() << "\e[31mmlibc: setsockopt() call with AF_NETLINK and SO_ACCEPTCONN is unimplemented\e[39m" << frg::endlog;
++		return 0;
++	} else {
++		mlibc::panicLogger() << "\e[31mmlibc: Unexpected setsockopt() call, layer: " << layer << " number: " << number << "\e[39m" << frg::endlog;
++		__builtin_unreachable();
++	}
++}
+ } // namespace mlibc
 diff --git a/sysdeps/aero/include/aero/syscall.h b/sysdeps/aero/include/aero/syscall.h
 index 12f8dc61..fcc219a9 100644
 --- a/sysdeps/aero/include/aero/syscall.h

src/aero_kernel/src/fs/inode.rs

@@ -30,6 +30,7 @@ use intrusive_collections::UnsafeRef;
 use spin::Once;
 
 use crate::mem::paging::PhysFrame;
+use crate::socket::unix::UnixSocket;
 use crate::socket::SocketAddr;
 use crate::userland::scheduler;
 use crate::utils::sync::BlockQueue;
@@ -226,7 +227,7 @@ pub trait INodeInterface: Send + Sync {
         Err(FileSystemError::NotSocket)
     }
 
-    fn accept(&self, _address: SocketAddr) -> Result<()> {
+    fn accept(&self, _address: &mut SocketAddr) -> Result<Arc<UnixSocket>> {
         Err(FileSystemError::NotSocket)
     }
 

src/aero_kernel/src/socket/unix.rs

@@ -21,12 +21,11 @@ use aero_syscall::SocketAddrUnix;
 
 use alloc::sync::{Arc, Weak};
 use alloc::vec::Vec;
-use spin::RwLock;
 
 use crate::fs;
 use crate::fs::inode::{DirEntry, FileType, INodeInterface, Metadata, PollFlags, PollTable};
 use crate::fs::{FileSystemError, Path, Result};
-use crate::utils::sync::BlockQueue;
+use crate::utils::sync::{BlockQueue, Mutex};
 
 use super::SocketAddr;
 
@@ -66,6 +65,10 @@ impl UnixSocketBacklog {
         self.backlog.as_ref().map(|e| e.len()).unwrap_or_default()
     }
 
+    pub fn pop(&mut self) -> Option<Arc<UnixSocket>> {
+        self.backlog.as_mut().map(|e| e.pop()).unwrap_or_default()
+    }
+
     pub fn update_capacity(&mut self, capacity: usize) {
         assert!(
             self.backlog.is_none(),
@@ -80,29 +83,43 @@ impl UnixSocketBacklog {
 struct UnixSocketInner {
     backlog: UnixSocketBacklog,
     listening: bool,
+    peer: Option<Arc<UnixSocket>>,
+    connected: bool,
 }
 
 pub struct UnixSocket {
-    inner: RwLock<UnixSocketInner>,
+    inner: Mutex<UnixSocketInner>,
     wq: BlockQueue,
     weak: Weak<UnixSocket>,
 }
 
 impl UnixSocket {
-    pub fn new() -> Arc<UnixSocket> {
-        Arc::new_cyclic(|weak| UnixSocket {
-            inner: RwLock::new(UnixSocketInner::default()),
+    pub fn new(peer: Option<Arc<UnixSocket>>) -> Arc<Self> {
+        Arc::new_cyclic(|weak| Self {
+            inner: Mutex::new(UnixSocketInner {
+                peer,
+                ..Default::default()
+            }),
+
             wq: BlockQueue::new(),
             weak: weak.clone(),
         })
     }
 
-    pub fn sref(&self) -> Arc<UnixSocket> {
+    pub fn sref(&self) -> Arc<Self> {
         self.weak.upgrade().unwrap()
     }
 }
 
 impl INodeInterface for UnixSocket {
+    fn read_at(&self, _offset: usize, _buffer: &mut [u8]) -> Result<usize> {
+        unimplemented!()
+    }
+
+    fn write_at(&self, _offset: usize, _buffer: &[u8]) -> Result<usize> {
+        unimplemented!()
+    }
+
     fn metadata(&self) -> Result<Metadata> {
         Ok(Metadata {
             id: 0,
@@ -140,7 +157,7 @@ impl INodeInterface for UnixSocket {
             .downcast_arc::<UnixSocket>()
             .ok_or(FileSystemError::NotSocket)?; // NOTE: the provided socket was not a unix socket.
 
-        let mut itarget = target.inner.write();
+        let mut itarget = target.inner.lock_irq();
 
         // ensure that the target socket is listening for new connections.
         if !itarget.listening {
@@ -149,30 +166,62 @@ impl INodeInterface for UnixSocket {
 
         itarget.backlog.push(self.sref());
         target.wq.notify_complete();
+        core::mem::drop(itarget); // release the lock
 
+        let _ = self.wq.block_on(&self.inner, |e| e.connected);
         Ok(())
     }
 
     fn listen(&self, backlog: usize) -> Result<()> {
-        let mut this = self.inner.write();
+        let mut this = self.inner.lock_irq();
 
         this.backlog.update_capacity(backlog);
         this.listening = true;
 
         Ok(())
     }
 
-    fn accept(&self, _address: SocketAddr) -> Result<()> {
-        unimplemented!()
+    fn accept(&self, _address: &mut SocketAddr) -> Result<Arc<UnixSocket>> {
+        if !self.inner.lock_irq().listening {
+            return Err(FileSystemError::ConnectionRefused);
+        }
+
+        let mut this = self.wq.block_on(&self.inner, |e| e.backlog.len() != 0)?;
+
+        let peer = this
+            .backlog
+            .pop()
+            .expect("UnixSocket::accept(): backlog is empty");
+
+        let sock = Self::new(Some(peer.clone()));
+
+        {
+            let mut sock_inner = sock.inner.lock_irq();
+            sock_inner.connected = true;
+        }
+
+        {
+            let mut peer_data = peer.inner.lock_irq();
+            peer_data.peer = Some(sock.clone());
+            peer_data.connected = true;
+        }
+
+        peer.wq.notify_complete();
+        Ok(sock)
     }
 
     fn poll(&self, table: Option<&mut PollTable>) -> Result<PollFlags> {
         table.map(|e| e.insert(&self.wq));
 
         let mut events = PollFlags::empty();
+        let sock_data = self.inner.lock_irq();
+
+        if sock_data.backlog.len() > 0 {
+            events.insert(PollFlags::IN | PollFlags::OUT);
+        }
 
-        if self.inner.read().backlog.len() > 0 {
-            events.insert(PollFlags::OUT);
+        if sock_data.connected {
+            events.insert(PollFlags::IN | PollFlags::OUT);
         }
 
         Ok(events)

src/aero_kernel/src/syscall/net.rs

@@ -35,16 +35,21 @@ pub fn connect(fd: usize, address: usize, length: usize) -> Result<usize, Syscal
 
 /// Accept a connection on a socket.
 #[syscall]
-pub fn accept(fd: usize, address: usize, _length: &mut u32) -> Result<usize, SyscallError> {
-    let address = socket_addr_from_addr(VirtAddr::new(address as u64))?;
-    let file = scheduler::get_scheduler()
-        .current_task()
-        .file_table
-        .get_handle(fd)
-        .ok_or(SyscallError::EINVAL)?;
-
-    file.inode().accept(address)?;
-    Ok(0)
+pub fn accept(
+    fd: usize,
+    address: &mut SocketAddr,
+    _length: &mut u32,
+) -> Result<usize, SyscallError> {
+    let file_table = scheduler::get_scheduler().current_task().file_table.clone();
+    let socket = file_table.get_handle(fd).ok_or(SyscallError::EINVAL)?;
+
+    let connection_sock = socket.inode().accept(address)?;
+    let handle = file_table.open_file(
+        DirEntry::from_inode(connection_sock, String::from("<socket>")),
+        OpenFlags::O_RDWR,
+    )?;
+
+    Ok(handle)
 }
 
 /// Marks the socket as a passive socket (i.e. as a socket that will be used to accept incoming
@@ -64,7 +69,7 @@ pub fn listen(fd: usize, backlog: usize) -> Result<usize, SyscallError> {
 #[syscall]
 pub fn socket(domain: usize, socket_type: usize, protocol: usize) -> Result<usize, SyscallError> {
     let socket = match domain as u32 {
-        AF_UNIX => UnixSocket::new(),
+        AF_UNIX => UnixSocket::new(None),
         _ => {
             log::warn!(
                 "unsupported socket type: domain={domain}, socket_type={socket_type}, protocol={protocol}"