Adjust as_socket signature

kernel/src/fs/file_handle.rs

@@ -97,7 +97,7 @@ pub trait FileLike: Pollable + Send + Sync + Any {
         return_errno_with_message!(Errno::EOPNOTSUPP, "fallocate is not supported");
     }
 
-    fn as_socket(self: Arc<Self>) -> Option<Arc<dyn Socket>> {
+    fn as_socket(&self) -> Option<&dyn Socket> {
         None
     }
 }
@@ -126,4 +126,9 @@ impl dyn FileLike {
         let mut reader = VmReader::from(buf).to_fallible();
         self.write_at(offset, &mut reader)
     }
+
+    pub fn as_socket_or_err(&self) -> Result<&dyn Socket> {
+        self.as_socket()
+            .ok_or_else(|| Error::with_message(Errno::ENOTSOCK, "the file is not a socket"))
+    }
 }

kernel/src/fs/file_table.rs

@@ -15,7 +15,6 @@ use super::{
 use crate::{
     events::{Events, IoEvents, Observer, Subject},
     fs::utils::StatusFlags,
-    net::socket::Socket,
     prelude::*,
     process::{
         signal::{constants::SIGIO, signals::kernel::KernelSignal, PollAdaptor},
@@ -185,13 +184,6 @@ impl FileTable {
             .ok_or(Error::with_message(Errno::EBADF, "fd not exits"))
     }
 
-    pub fn get_socket(&self, sockfd: FileDesc) -> Result<Arc<dyn Socket>> {
-        let file_like = self.get_file(sockfd)?.clone();
-        file_like
-            .as_socket()
-            .ok_or_else(|| Error::with_message(Errno::ENOTSOCK, "the fd is not a socket"))
-    }
-
     pub fn get_entry(&self, fd: FileDesc) -> Result<&FileTableEntry> {
         self.table
             .get(fd as usize)

kernel/src/net/socket/ip/datagram/mod.rs

@@ -242,7 +242,7 @@ impl FileLike for DatagramSocket {
         self.try_send(reader, &remote, flags)
     }
 
-    fn as_socket(self: Arc<Self>) -> Option<Arc<dyn Socket>> {
+    fn as_socket(&self) -> Option<&dyn Socket> {
         Some(self)
     }
 

kernel/src/net/socket/ip/stream/mod.rs

@@ -453,7 +453,7 @@ impl FileLike for StreamSocket {
         Ok(())
     }
 
-    fn as_socket(self: Arc<Self>) -> Option<Arc<dyn Socket>> {
+    fn as_socket(&self) -> Option<&dyn Socket> {
         Some(self)
     }
 

kernel/src/net/socket/unix/stream/socket.rs

@@ -164,7 +164,7 @@ impl Pollable for UnixStreamSocket {
 }
 
 impl FileLike for UnixStreamSocket {
-    fn as_socket(self: Arc<Self>) -> Option<Arc<dyn Socket>> {
+    fn as_socket(&self) -> Option<&dyn Socket> {
         Some(self)
     }
 

kernel/src/net/socket/vsock/stream/socket.rs

@@ -139,7 +139,7 @@ impl Pollable for VsockStreamSocket {
 }
 
 impl FileLike for VsockStreamSocket {
-    fn as_socket(self: Arc<Self>) -> Option<Arc<dyn Socket>> {
+    fn as_socket(&self) -> Option<&dyn Socket> {
         Some(self)
     }
 

kernel/src/syscall/accept.rs

@@ -7,7 +7,7 @@ use crate::{
         utils::{CreationFlags, StatusFlags},
     },
     prelude::*,
-    util::net::{get_socket_from_fd, write_socket_addr_to_user},
+    util::net::write_socket_addr_to_user,
 };
 
 pub fn sys_accept(
@@ -47,8 +47,13 @@ fn do_accept(
     flags: Flags,
     ctx: &Context,
 ) -> Result<FileDesc> {
+    let file = {
+        let file_table = ctx.posix_thread.file_table().lock();
+        file_table.get_file(sockfd)?.clone()
+    };
+    let socket = file.as_socket_or_err()?;
+
     let (connected_socket, socket_addr) = {
-        let socket = get_socket_from_fd(sockfd)?;
         socket.accept().map_err(|err| match err.error() {
             // FIXME: `accept` should not be restarted if a timeout has been set on the socket using `setsockopt`.
             Errno::EINTR => Error::new(Errno::ERESTARTSYS),

kernel/src/syscall/bind.rs

@@ -1,22 +1,24 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use super::SyscallReturn;
-use crate::{
+use crate::{fs::file_table::FileDesc, prelude::*, util::net::read_socket_addr_from_user};
-    fs::file_table::FileDesc,
-    prelude::*,
-    util::net::{get_socket_from_fd, read_socket_addr_from_user},
-};
 
 pub fn sys_bind(
     sockfd: FileDesc,
     sockaddr_ptr: Vaddr,
     addrlen: u32,
-    _ctx: &Context,
+    ctx: &Context,
 ) -> Result<SyscallReturn> {
     let socket_addr = read_socket_addr_from_user(sockaddr_ptr, addrlen as usize)?;
     debug!("sockfd = {sockfd}, socket_addr = {socket_addr:?}");
 
-    let socket = get_socket_from_fd(sockfd)?;
+    let file = {
+        let file_table = ctx.posix_thread.file_table().lock();
+        file_table.get_file(sockfd)?.clone()
+    };
+    let socket = file.as_socket_or_err()?;
+
     socket.bind(socket_addr)?;
+
     Ok(SyscallReturn::Return(0))
 }

kernel/src/syscall/connect.rs

@@ -1,22 +1,23 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use super::SyscallReturn;
-use crate::{
+use crate::{fs::file_table::FileDesc, prelude::*, util::net::read_socket_addr_from_user};
-    fs::file_table::FileDesc,
-    prelude::*,
-    util::net::{get_socket_from_fd, read_socket_addr_from_user},
-};
 
 pub fn sys_connect(
     sockfd: FileDesc,
     sockaddr_ptr: Vaddr,
     addr_len: u32,
-    _ctx: &Context,
+    ctx: &Context,
 ) -> Result<SyscallReturn> {
     let socket_addr = read_socket_addr_from_user(sockaddr_ptr, addr_len as _)?;
     debug!("fd = {sockfd}, socket_addr = {socket_addr:?}");
 
-    let socket = get_socket_from_fd(sockfd)?;
+    let file = {
+        let file_table = ctx.posix_thread.file_table().lock();
+        file_table.get_file(sockfd)?.clone()
+    };
+    let socket = file.as_socket_or_err()?;
+
     socket
         .connect(socket_addr)
         .map_err(|err| match err.error() {
@@ -24,5 +25,6 @@ pub fn sys_connect(
             Errno::EINTR => Error::new(Errno::ERESTARTSYS),
             _ => err,
         })?;
+
     Ok(SyscallReturn::Return(0))
 }

kernel/src/syscall/getpeername.rs

@@ -1,25 +1,25 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use super::SyscallReturn;
-use crate::{
+use crate::{fs::file_table::FileDesc, prelude::*, util::net::write_socket_addr_to_user};
-    fs::file_table::FileDesc,
-    prelude::*,
-    util::net::{get_socket_from_fd, write_socket_addr_to_user},
-};
 
 pub fn sys_getpeername(
     sockfd: FileDesc,
     addr: Vaddr,
     addrlen_ptr: Vaddr,
-    _ctx: &Context,
+    ctx: &Context,
 ) -> Result<SyscallReturn> {
     debug!("sockfd = {sockfd}, addr = 0x{addr:x}, addrlen_ptr = 0x{addrlen_ptr:x}");
 
-    let peer_addr = {
+    let file = {
-        let socket = get_socket_from_fd(sockfd)?;
+        let file_table = ctx.posix_thread.file_table().lock();
-        socket.peer_addr()?
+        file_table.get_file(sockfd)?.clone()
     };
+    let socket = file.as_socket_or_err()?;
+
+    let peer_addr = socket.peer_addr()?;
     // FIXME: trunscate write len if addrlen is not big enough
     write_socket_addr_to_user(&peer_addr, addr, addrlen_ptr)?;
+
     Ok(SyscallReturn::Return(0))
 }

kernel/src/syscall/getsockname.rs

@@ -1,26 +1,25 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use super::SyscallReturn;
-use crate::{
+use crate::{fs::file_table::FileDesc, prelude::*, util::net::write_socket_addr_to_user};
-    fs::file_table::FileDesc,
-    prelude::*,
-    util::net::{get_socket_from_fd, write_socket_addr_to_user},
-};
 
 pub fn sys_getsockname(
     sockfd: FileDesc,
     addr: Vaddr,
     addrlen_ptr: Vaddr,
-    _ctx: &Context,
+    ctx: &Context,
 ) -> Result<SyscallReturn> {
     debug!("sockfd = {sockfd}, addr = 0x{addr:x}, addrlen_ptr = 0x{addrlen_ptr:x}");
 
-    let socket_addr = {
+    let file = {
-        let socket = get_socket_from_fd(sockfd)?;
+        let file_table = ctx.posix_thread.file_table().lock();
-        socket.addr()?
+        file_table.get_file(sockfd)?.clone()
     };
+    let socket = file.as_socket_or_err()?;
 
+    let socket_addr = socket.addr()?;
     // FIXME: trunscate write len if addrlen is not big enough
     write_socket_addr_to_user(&socket_addr, addr, addrlen_ptr)?;
+
     Ok(SyscallReturn::Return(0))
 }

kernel/src/syscall/getsockopt.rs

@@ -4,7 +4,7 @@ use super::SyscallReturn;
 use crate::{
     fs::file_table::FileDesc,
     prelude::*,
-    util::net::{get_socket_from_fd, new_raw_socket_option, CSocketOptionLevel},
+    util::net::{new_raw_socket_option, CSocketOptionLevel},
 };
 
 pub fn sys_getsockopt(
@@ -19,21 +19,24 @@ pub fn sys_getsockopt(
     if optval == 0 || optlen_addr == 0 {
         return_errno_with_message!(Errno::EINVAL, "optval or optlen_addr is null pointer");
     }
-    let user_space = ctx.user_space();
 
+    let user_space = ctx.user_space();
     let optlen: u32 = user_space.read_val(optlen_addr)?;
+
     debug!("level = {level:?}, sockfd = {sockfd}, optname = {optname:?}, optlen = {optlen}");
 
-    let socket = get_socket_from_fd(sockfd)?;
+    let file = {
+        let file_table = ctx.posix_thread.file_table().lock();
+        file_table.get_file(sockfd)?.clone()
+    };
+    let socket = file.as_socket_or_err()?;
 
     let mut raw_option = new_raw_socket_option(level, optname)?;
-
     debug!("raw option: {:?}", raw_option);
 
     socket.get_option(raw_option.as_sock_option_mut())?;
 
     let write_len = raw_option.write_to_user(optval, optlen)?;
-
     user_space.write_val(optlen_addr, &(write_len as u32))?;
 
     Ok(SyscallReturn::Return(0))

kernel/src/syscall/listen.rs

@@ -1,13 +1,18 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use super::SyscallReturn;
-use crate::{fs::file_table::FileDesc, prelude::*, util::net::get_socket_from_fd};
+use crate::{fs::file_table::FileDesc, prelude::*};
 
-pub fn sys_listen(sockfd: FileDesc, backlog: i32, _ctx: &Context) -> Result<SyscallReturn> {
+pub fn sys_listen(sockfd: FileDesc, backlog: i32, ctx: &Context) -> Result<SyscallReturn> {
     debug!("sockfd = {sockfd}, backlog = {backlog}");
 
-    let socket = get_socket_from_fd(sockfd)?;
+    let file = {
+        let file_table = ctx.posix_thread.file_table().lock();
+        file_table.get_file(sockfd)?.clone()
+    };
+    let socket = file.as_socket_or_err()?;
 
     socket.listen(backlog as usize)?;
+
     Ok(SyscallReturn::Return(0))
 }

kernel/src/syscall/recvfrom.rs

@@ -2,10 +2,8 @@
 
 use super::SyscallReturn;
 use crate::{
-    fs::file_table::FileDesc,
+    fs::file_table::FileDesc, net::socket::SendRecvFlags, prelude::*,
-    net::socket::SendRecvFlags,
+    util::net::write_socket_addr_to_user,
-    prelude::*,
-    util::net::{get_socket_from_fd, write_socket_addr_to_user},
 };
 
 pub fn sys_recvfrom(
@@ -20,7 +18,11 @@ pub fn sys_recvfrom(
     let flags = SendRecvFlags::from_bits_truncate(flags);
     debug!("sockfd = {sockfd}, buf = 0x{buf:x}, len = {len}, flags = {flags:?}, src_addr = 0x{src_addr:x}, addrlen_ptr = 0x{addrlen_ptr:x}");
 
-    let socket = get_socket_from_fd(sockfd)?;
+    let file = {
+        let file_table = ctx.posix_thread.file_table().lock();
+        file_table.get_file(sockfd)?.clone()
+    };
+    let socket = file.as_socket_or_err()?;
 
     let mut writers = {
         let vm_space = ctx.process.root_vmar().vm_space();

kernel/src/syscall/recvmsg.rs

@@ -2,10 +2,7 @@
 
 use super::SyscallReturn;
 use crate::{
-    fs::file_table::FileDesc,
+    fs::file_table::FileDesc, net::socket::SendRecvFlags, prelude::*, util::net::CUserMsgHdr,
-    net::socket::SendRecvFlags,
-    prelude::*,
-    util::net::{get_socket_from_fd, CUserMsgHdr},
 };
 
 pub fn sys_recvmsg(
@@ -22,8 +19,13 @@ pub fn sys_recvmsg(
         sockfd, c_user_msghdr, flags
     );
 
+    let file = {
+        let file_table = ctx.posix_thread.file_table().lock();
+        file_table.get_file(sockfd)?.clone()
+    };
+    let socket = file.as_socket_or_err()?;
+
     let (total_bytes, message_header) = {
-        let socket = get_socket_from_fd(sockfd)?;
         let mut io_vec_writer = c_user_msghdr.copy_writer_array_from_user(ctx)?;
         socket
             .recvmsg(&mut io_vec_writer, flags)

kernel/src/syscall/sendmsg.rs

@@ -5,7 +5,7 @@ use crate::{
     fs::file_table::FileDesc,
     net::socket::{MessageHeader, SendRecvFlags},
     prelude::*,
-    util::net::{get_socket_from_fd, CUserMsgHdr},
+    util::net::CUserMsgHdr,
 };
 
 pub fn sys_sendmsg(
@@ -22,7 +22,11 @@ pub fn sys_sendmsg(
         sockfd, c_user_msghdr, flags
     );
 
-    let socket = get_socket_from_fd(sockfd)?;
+    let file = {
+        let file_table = ctx.posix_thread.file_table().lock();
+        file_table.get_file(sockfd)?.clone()
+    };
+    let socket = file.as_socket_or_err()?;
 
     let (mut io_vec_reader, message_header) = {
         let addr = c_user_msghdr.read_socket_addr_from_user()?;

kernel/src/syscall/sendto.rs

@@ -5,7 +5,7 @@ use crate::{
     fs::file_table::FileDesc,
     net::socket::{MessageHeader, SendRecvFlags},
     prelude::*,
-    util::net::{get_socket_from_fd, read_socket_addr_from_user},
+    util::net::read_socket_addr_from_user,
 };
 
 pub fn sys_sendto(
@@ -26,7 +26,11 @@ pub fn sys_sendto(
     };
     debug!("sockfd = {sockfd}, buf = 0x{buf:x}, len = 0x{len:x}, flags = {flags:?}, socket_addr = {socket_addr:?}");
 
-    let socket = get_socket_from_fd(sockfd)?;
+    let file = {
+        let file_table = ctx.posix_thread.file_table().lock();
+        file_table.get_file(sockfd)?.clone()
+    };
+    let socket = file.as_socket_or_err()?;
 
     let message_header = MessageHeader::new(socket_addr, None);
 

kernel/src/syscall/setsockopt.rs

@@ -4,7 +4,7 @@ use super::SyscallReturn;
 use crate::{
     fs::file_table::FileDesc,
     prelude::*,
-    util::net::{get_socket_from_fd, new_raw_socket_option, CSocketOptionLevel},
+    util::net::{new_raw_socket_option, CSocketOptionLevel},
 };
 
 pub fn sys_setsockopt(
@@ -13,7 +13,7 @@ pub fn sys_setsockopt(
     optname: i32,
     optval: Vaddr,
     optlen: u32,
-    _ctx: &Context,
+    ctx: &Context,
 ) -> Result<SyscallReturn> {
     let level = CSocketOptionLevel::try_from(level).map_err(|_| Errno::EOPNOTSUPP)?;
     if optval == 0 {
@@ -25,16 +25,17 @@ pub fn sys_setsockopt(
         level, sockfd, optname, optlen
     );
 
-    let socket = get_socket_from_fd(sockfd)?;
+    let file = {
+        let file_table = ctx.posix_thread.file_table().lock();
+        file_table.get_file(sockfd)?.clone()
+    };
+    let socket = file.as_socket_or_err()?;
 
     let raw_option = {
         let mut option = new_raw_socket_option(level, optname)?;
-
         option.read_from_user(optval, optlen)?;
-
         option
     };
-
     debug!("raw option: {:?}", raw_option);
 
     socket.set_option(raw_option.as_sock_option())?;

kernel/src/syscall/shutdown.rs

@@ -1,16 +1,19 @@
 // SPDX-License-Identifier: MPL-2.0
 
 use super::SyscallReturn;
-use crate::{
+use crate::{fs::file_table::FileDesc, net::socket::SockShutdownCmd, prelude::*};
-    fs::file_table::FileDesc, net::socket::SockShutdownCmd, prelude::*,
-    util::net::get_socket_from_fd,
-};
 
-pub fn sys_shutdown(sockfd: FileDesc, how: i32, _ctx: &Context) -> Result<SyscallReturn> {
+pub fn sys_shutdown(sockfd: FileDesc, how: i32, ctx: &Context) -> Result<SyscallReturn> {
     let shutdown_cmd = SockShutdownCmd::try_from(how)?;
     debug!("sockfd = {sockfd}, cmd = {shutdown_cmd:?}");
 
-    let socket = get_socket_from_fd(sockfd)?;
+    let file = {
+        let file_table = ctx.posix_thread.file_table().lock();
+        file_table.get_file(sockfd)?.clone()
+    };
+    let socket = file.as_socket_or_err()?;
+
     socket.shutdown(shutdown_cmd)?;
+
     Ok(SyscallReturn::Return(0))
 }

kernel/src/util/net/mod.rs

@@ -10,14 +10,3 @@ pub use addr::{
 };
 pub use options::{new_raw_socket_option, CSocketOptionLevel};
 pub use socket::{CUserMsgHdr, Protocol, SockFlags, SockType, SOCK_TYPE_MASK};
-
-use crate::{
-    fs::file_table::FileDesc, net::socket::Socket, prelude::*, process::posix_thread::AsPosixThread,
-};
-
-pub fn get_socket_from_fd(sockfd: FileDesc) -> Result<Arc<dyn Socket>> {
-    let current = current_thread!();
-    let current = current.as_posix_thread().unwrap();
-    let file_table = current.file_table().lock();
-    file_table.get_socket(sockfd)
-}