Initial layout for networking syscalls

src/arch/arm64/exceptions/syscall.rs

@@ -39,6 +39,10 @@ use crate::{
         brk::sys_brk,
         mmap::{sys_mmap, sys_mprotect, sys_munmap},
     },
+    net::syscalls::{
+        recv::sys_recvfrom, send::sys_sendto, sys_accept, sys_bind, sys_connect, sys_listen,
+        sys_shutdown, sys_socket,
+    },
     process::{
         clone::sys_clone,
         creds::{
@@ -348,7 +352,34 @@ pub async fn handle_syscall() {
         0xb1 => sys_getegid().map_err(|e| match e {}),
         0xb2 => sys_gettid().map_err(|e| match e {}),
         0xb3 => sys_sysinfo(TUA::from_value(arg1 as _)).await,
-        0xc6 => Err(KernelError::NotSupported),
+        0xc6 => sys_socket(arg1 as _, arg2 as _, arg3 as _).await,
+        0xc8 => sys_bind(arg1.into(), TUA::from_value(arg2 as _), arg3 as _).await,
+        0xc9 => sys_listen(arg1.into(), arg2 as _).await,
+        0xca => sys_accept(arg1.into(), TUA::from_value(arg2 as _), arg3 as _).await,
+        0xcb => sys_connect(arg1.into(), TUA::from_value(arg2 as _), arg3 as _).await,
+        0xce => {
+            sys_sendto(
+                arg1.into(),
+                TUA::from_value(arg2 as _),
+                arg3 as _,
+                arg4 as _,
+                TUA::from_value(arg5 as _),
+                arg6 as _,
+            )
+            .await
+        }
+        0xcf => {
+            sys_recvfrom(
+                arg1.into(),
+                TUA::from_value(arg2 as _),
+                arg3 as _,
+                arg4 as _,
+                TUA::from_value(arg5 as _),
+                arg6 as _,
+            )
+            .await
+        }
+        0xd2 => sys_shutdown(arg1.into(), arg2 as _).await,
         0xd6 => sys_brk(VA::from_value(arg1 as _))
             .await
             .map_err(|e| match e {}),

src/console/chardev.rs

@@ -28,7 +28,7 @@ impl OpenableDevice for TtyDev {
         Ok(task
             .fd_table
             .lock_save_irq()
-            .get(Fd(0))
+            .get_file(Fd(0))
             .ok_or(FsError::NoDevice)?)
     }
 }

src/fs/dir.rs

@@ -136,7 +136,7 @@ pub async fn sys_getdents64(fd: Fd, mut ubuf: UA, size: u32) -> Result<usize> {
     let file = task
         .fd_table
         .lock_save_irq()
-        .get(fd)
+        .get_file(fd)
         .ok_or(KernelError::BadFd)?;
 
     let (ops, ctx) = &mut *file.lock().await;

src/fs/syscalls/at/mod.rs

@@ -50,7 +50,7 @@
         let file = task
             .fd_table
             .lock_save_irq()
-            .get(dirfd)
+            .get_file(dirfd)
             .ok_or(KernelError::BadFd)?;
 
         let inode = file.inode().ok_or(KernelError::NotSupported)?;
@@ -83,7 +83,7 @@
                 .get(dirfd)
                 .ok_or(KernelError::BadFd)?;
 
             file.inode().ok_or(KernelError::NotSupported)?
         });
     };
 

src/fs/syscalls/chdir.rs

@@ -62,7 +62,7 @@ pub async fn sys_fchdir(fd: Fd) -> Result<usize> {
     let file = task
         .fd_table
         .lock_save_irq()
-        .get(fd)
+        .get_file(fd)
         .ok_or(KernelError::BadFd)?;
 
     *task.cwd.lock_save_irq() = (

src/fs/syscalls/close.rs

@@ -1,20 +1,29 @@
+use crate::process::fd_table::FileDescriptorEntryItem;
 use crate::{process::fd_table::Fd, sched::current_task};
 use alloc::sync::Arc;
 use libkernel::error::{KernelError, Result};
 
 pub async fn sys_close(fd: Fd) -> Result<usize> {
-    let file = current_task()
+    let fd_item = current_task()
         .fd_table
         .lock_save_irq()
         .remove(fd)
         .ok_or(KernelError::BadFd)?;
 
-    if let Some(file) = Arc::into_inner(file) {
-        let (ops, ctx) = &mut *file.lock().await;
-        ops.release(ctx).await?;
+    match fd_item {
+        FileDescriptorEntryItem::File(file) => {
+            if let Some(file) = Arc::into_inner(file) {
+                let (ops, ctx) = &mut *file.lock().await;
+                ops.release(ctx).await?;
 
-        Ok(0)
-    } else {
-        Ok(0)
+                Ok(0)
+            } else {
+                Ok(0)
+            }
+        }
+        FileDescriptorEntryItem::Socket(socket) => {
+            todo!();
+            Ok(0)
+        }
     }
 }

src/fs/syscalls/ioctl.rs

@@ -5,7 +5,7 @@ pub async fn sys_ioctl(fd: Fd, request: usize, arg: usize) -> Result<usize> {
     let fd = current_task()
         .fd_table
         .lock_save_irq()
-        .get(fd)
+        .get_file(fd)
         .ok_or(KernelError::BadFd)?;
 
     let (ops, ctx) = &mut *fd.lock().await;

src/fs/syscalls/iov.rs

@@ -22,7 +22,7 @@
     let file = current_task()
         .fd_table
         .lock_save_irq()
-        .get(fd)
+        .get_file(fd)
         .ok_or(KernelError::BadFd)?;
 
     let iovs = copy_obj_array_from_user(iov_ptr, no_iov).await?;
@@ -36,7 +36,7 @@
     let file = current_task()
         .fd_table
         .lock_save_irq()
-        .get(fd)
+        .get_file(fd)
         .ok_or(KernelError::BadFd)?;
 
     let iovs = copy_obj_array_from_user(iov_ptr, no_iov).await?;
@@ -69,9 +69,9 @@
 
     let iovs = copy_obj_array_from_user(iov_ptr, no_iov).await?;
 
     let (ops, _state) = &mut *file.lock().await;
 
     ops.writevat(&iovs, offset).await
 }
 
 pub async fn sys_preadv2(
@@ -89,7 +89,7 @@
 
     let iovs = copy_obj_array_from_user(iov_ptr, no_iov).await?;
 
     let (ops, _state) = &mut *file.lock().await;
 
     ops.readvat(&iovs, offset).await
 }

src/fs/syscalls/rw.rs

@@ -8,7 +8,7 @@
     let file = current_task()
         .fd_table
         .lock_save_irq()
-        .get(fd)
+        .get_file(fd)
         .ok_or(KernelError::BadFd)?;
 
     let (ops, ctx) = &mut *file.lock().await;
@@ -20,7 +20,7 @@
     let file = current_task()
         .fd_table
         .lock_save_irq()
-        .get(fd)
+        .get_file(fd)
         .ok_or(KernelError::BadFd)?;
 
     let (ops, ctx) = &mut *file.lock().await;
@@ -35,7 +35,7 @@
         .get(fd)
         .ok_or(KernelError::BadFd)?;
 
     let (ops, _ctx) = &mut *file.lock().await;
 
     ops.writeat(user_buf, count, offset).await
 }

src/fs/syscalls/seek.rs

@@ -19,7 +19,7 @@ pub async fn sys_lseek(fd: Fd, offset: isize, whence: i32) -> Result<usize> {
     let fd = current_task()
         .fd_table
         .lock_save_irq()
-        .get(fd)
+        .get_file(fd)
         .ok_or(KernelError::BadFd)?;
 
     let (ops, ctx) = &mut *fd.lock().await;

src/fs/syscalls/splice.rs

@@ -15,8 +15,8 @@ pub async fn sys_sendfile(
         let task = current_task();
         let fds = task.fd_table.lock_save_irq();
 
-        let reader = fds.get(in_fd).ok_or(KernelError::BadFd)?;
-        let writer = fds.get(out_fd).ok_or(KernelError::BadFd)?;
+        let reader = fds.get_file(in_fd).ok_or(KernelError::BadFd)?;
+        let writer = fds.get_file(out_fd).ok_or(KernelError::BadFd)?;
 
         (reader, writer)
     };

src/fs/syscalls/stat.rs

@@ -8,7 +8,7 @@ pub async fn sys_fstat(fd: Fd, statbuf: TUA<Stat>) -> Result<usize> {
     let fd = current_task()
         .fd_table
         .lock_save_irq()
-        .get(fd)
+        .get_file(fd)
         .ok_or(KernelError::BadFd)?;
 
     let inode = fd.inode().ok_or(KernelError::BadFd)?;

src/fs/syscalls/trunc.rs

@@ -33,7 +33,7 @@ pub async fn sys_ftruncate(fd: Fd, new_size: usize) -> Result<usize> {
     let fd = current_task()
         .fd_table
         .lock_save_irq()
-        .get(fd)
+        .get_file(fd)
         .ok_or(KernelError::BadFd)?;
 
     let (ops, ctx) = &mut *fd.lock().await;

src/main.rs

@@ -39,6 +39,7 @@ mod fs;
 mod interrupts;
 mod kernel;
 mod memory;
+mod net;
 mod process;
 mod sched;
 mod sync;

src/memory/mmap.rs

@@ -92,7 +92,7 @@ pub async fn sys_mmap(
         let fd = current_task()
             .fd_table
             .lock_save_irq()
-            .get(fd)
+            .get_file(fd)
             .ok_or(KernelError::BadFd)?;
 
         let inode = fd.inode().ok_or(KernelError::BadFd)?;

src/net/mod.rs

@@ -0,0 +1,3 @@
+pub mod open_socket;
+mod sops;
+pub mod syscalls;

src/net/open_socket.rs

@@ -0,0 +1,27 @@
+use crate::net::sops::SocketOps;
+use crate::sync::{AsyncMutexGuard, Mutex};
+use alloc::boxed::Box;
+
+pub struct SocketCtx {}
+
+impl SocketCtx {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+pub struct OpenSocket {
+    state: Mutex<(Box<dyn SocketOps>, SocketCtx)>,
+}
+
+impl OpenSocket {
+    pub fn new(ops: Box<dyn SocketOps>) -> Self {
+        Self {
+            state: Mutex::new((ops, SocketCtx::new())),
+        }
+    }
+
+    pub async fn lock(&self) -> AsyncMutexGuard<'_, (Box<dyn SocketOps>, SocketCtx)> {
+        self.state.lock().await
+    }
+}

src/net/sops.rs

@@ -0,0 +1,33 @@
+use crate::net::open_socket::SocketCtx;
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use async_trait::async_trait;
+use libkernel::error::{KernelError, Result};
+
+#[async_trait]
+pub trait SocketOps: Send + Sync {
+    async fn bind(&self, _ctx: &mut SocketCtx, _addr: &[u8]) -> Result<()> {
+        Err(KernelError::NotSupported)
+    }
+    async fn connect(&self, _ctx: &mut SocketCtx, _addr: &[u8]) -> Result<()> {
+        Err(KernelError::NotSupported)
+    }
+    async fn listen(&self, _ctx: &mut SocketCtx, _backlog: i32) -> Result<()> {
+        Err(KernelError::NotSupported)
+    }
+    async fn accept(&self, _ctx: &mut SocketCtx) -> Result<Box<dyn SocketOps>> {
+        Err(KernelError::NotSupported)
+    }
+    async fn sendmsg(&self, _ctx: &mut SocketCtx, _msg: &[u8]) -> Result<usize> {
+        Err(KernelError::NotSupported)
+    }
+    async fn recvmsg(&self, _ctx: &mut SocketCtx, _buf: &mut [u8]) -> Result<usize> {
+        Err(KernelError::NotSupported)
+    }
+    fn getsockopt(&self, _ctx: &mut SocketCtx, _level: i32, _opt: i32) -> Result<Vec<u8>> {
+        Err(KernelError::NotSupported)
+    }
+    fn setsockopt(&self, _ctx: &mut SocketCtx, _level: i32, _opt: i32, _val: &[u8]) -> Result<()> {
+        Err(KernelError::NotSupported)
+    }
+}

src/net/syscalls/mod.rs

@@ -0,0 +1,113 @@
+use crate::process::fd_table::Fd;
+use crate::sched::current_task;
+use libkernel::error::KernelError;
+use libkernel::memory::address::UA;
+
+pub mod recv;
+pub mod send;
+
+pub enum AddressFamily {
+    Unix = 1,
+    Inet = 2,
+    Inet6 = 10,
+}
+
+impl TryFrom<i32> for AddressFamily {
+    type Error = KernelError;
+
+    fn try_from(value: i32) -> libkernel::error::Result<Self> {
+        match value {
+            1 => Ok(AddressFamily::Unix),
+            2 => Ok(AddressFamily::Inet),
+            10 => Ok(AddressFamily::Inet6),
+            _ => Err(KernelError::InvalidValue),
+        }
+    }
+}
+
+pub enum SocketType {
+    Datagram = 1,
+    Stream = 2,
+    Raw = 3,
+    RDM = 4,
+    SeqPacket = 5,
+    DCCP = 6,
+    Packet = 10,
+}
+
+impl TryFrom<i32> for SocketType {
+    type Error = KernelError;
+
+    fn try_from(value: i32) -> libkernel::error::Result<Self> {
+        match value {
+            1 => Ok(SocketType::Datagram),
+            2 => Ok(SocketType::Stream),
+            3 => Ok(SocketType::Raw),
+            4 => Ok(SocketType::RDM),
+            5 => Ok(SocketType::SeqPacket),
+            6 => Ok(SocketType::DCCP),
+            10 => Ok(SocketType::Packet),
+            _ => Err(KernelError::InvalidValue),
+        }
+    }
+}
+
+pub async fn sys_socket(
+    domain: i32,
+    type_: i32,
+    _protocol: i32,
+) -> libkernel::error::Result<usize> {
+    let _family = AddressFamily::try_from(domain)?;
+    // TODO: mask out flags from type_
+    let _socket_type = SocketType::try_from(type_)?;
+    Err(KernelError::NotSupported)
+}
+
+pub async fn sys_bind(fd: Fd, addr: UA, addr_len: u32) -> libkernel::error::Result<usize> {
+    Err(KernelError::NotSupported)
+}
+
+pub async fn sys_listen(fd: Fd, backlog: i32) -> libkernel::error::Result<usize> {
+    let task = current_task();
+    let socket = task
+        .fd_table
+        .lock_save_irq()
+        .get_socket(fd)
+        .ok_or(KernelError::BadFd)?;
+    let (ops, state) = &mut *socket.lock().await;
+    ops.listen(state, backlog).await?;
+    Ok(0)
+}
+
+pub async fn sys_accept(fd: Fd, addr: UA, addr_len: u32) -> libkernel::error::Result<usize> {
+    let _ = (addr, addr_len);
+    Err(KernelError::NotSupported)
+}
+
+pub async fn sys_connect(fd: Fd, addr: UA, addr_len: u32) -> libkernel::error::Result<usize> {
+    Err(KernelError::NotSupported)
+}
+
+pub enum ShutdownHow {
+    Read = 0,
+    Write = 1,
+    Both = 2,
+}
+
+impl TryFrom<i32> for ShutdownHow {
+    type Error = KernelError;
+
+    fn try_from(value: i32) -> libkernel::error::Result<Self> {
+        match value {
+            0 => Ok(ShutdownHow::Read),
+            1 => Ok(ShutdownHow::Write),
+            2 => Ok(ShutdownHow::Both),
+            _ => Err(KernelError::InvalidValue),
+        }
+    }
+}
+
+pub async fn sys_shutdown(fd: Fd, how: i32) -> libkernel::error::Result<usize> {
+    let _how = ShutdownHow::try_from(how)?;
+    Err(KernelError::NotSupported)
+}