refactor(socket): implement ObjectInterface for sockets directly

mkroening · mkroening · commit 556e1a1e9a8d · 2025-09-04T09:57:04.000+02:00
diff --git a/src/fd/socket/tcp.rs b/src/fd/socket/tcp.rs
@@ -475,66 +475,63 @@ impl Drop for Socket {
 }
 
 #[async_trait]
-impl ObjectInterface for async_lock::RwLock<Socket> {
+impl ObjectInterface for Socket {
 	async fn poll(&self, event: PollEvent) -> io::Result<PollEvent> {
-		self.read().await.poll(event).await
+		self.poll(event).await
 	}
 
 	async fn read(&self, buffer: &mut [u8]) -> io::Result<usize> {
-		self.read().await.read(buffer).await
+		self.read(buffer).await
 	}
 
 	async fn write(&self, buffer: &[u8]) -> io::Result<usize> {
-		self.read().await.write(buffer).await
+		self.write(buffer).await
 	}
 
 	async fn bind(&mut self, endpoint: ListenEndpoint) -> io::Result<()> {
-		self.write().await.bind(endpoint).await
+		self.bind(endpoint).await
 	}
 
 	async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {
-		self.write().await.connect(endpoint).await
+		self.connect(endpoint).await
 	}
 
 	async fn accept(
 		&mut self,
 	) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {
-		let (socket, endpoint) = self.write().await.accept().await?;
-		Ok((
-			Arc::new(async_lock::RwLock::new(async_lock::RwLock::new(socket))),
-			endpoint,
-		))
+		let (socket, endpoint) = self.accept().await?;
+		Ok((Arc::new(async_lock::RwLock::new(socket)), endpoint))
 	}
 
 	async fn getpeername(&self) -> io::Result<Option<Endpoint>> {
-		self.read().await.getpeername().await
+		self.getpeername().await
 	}
 
 	async fn getsockname(&self) -> io::Result<Option<Endpoint>> {
-		self.read().await.getsockname().await
+		self.getsockname().await
 	}
 
 	async fn listen(&mut self, backlog: i32) -> io::Result<()> {
-		self.write().await.listen(backlog).await
+		self.listen(backlog).await
 	}
 
 	async fn setsockopt(&self, opt: SocketOption, optval: bool) -> io::Result<()> {
-		self.read().await.setsockopt(opt, optval).await
+		self.setsockopt(opt, optval).await
 	}
 
 	async fn getsockopt(&self, opt: SocketOption) -> io::Result<bool> {
-		self.read().await.getsockopt(opt).await
+		self.getsockopt(opt).await
 	}
 
 	async fn shutdown(&self, how: i32) -> io::Result<()> {
-		self.read().await.shutdown(how).await
+		self.shutdown(how).await
 	}
 
 	async fn status_flags(&self) -> io::Result<fd::StatusFlags> {
-		self.read().await.status_flags().await
+		self.status_flags().await
 	}
 
 	async fn set_status_flags(&mut self, status_flags: fd::StatusFlags) -> io::Result<()> {
-		self.write().await.set_status_flags(status_flags).await
+		self.set_status_flags(status_flags).await
 	}
 }
diff --git a/src/fd/socket/udp.rs b/src/fd/socket/udp.rs
@@ -253,44 +253,44 @@ impl Drop for Socket {
 }
 
 #[async_trait]
-impl ObjectInterface for async_lock::RwLock<Socket> {
+impl ObjectInterface for Socket {
 	async fn poll(&self, event: PollEvent) -> io::Result<PollEvent> {
-		self.read().await.poll(event).await
+		self.poll(event).await
 	}
 
 	async fn bind(&mut self, endpoint: ListenEndpoint) -> io::Result<()> {
-		self.write().await.bind(endpoint).await
+		self.bind(endpoint).await
 	}
 
 	async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {
-		self.write().await.connect(endpoint).await
+		self.connect(endpoint).await
 	}
 
 	async fn sendto(&self, buffer: &[u8], endpoint: Endpoint) -> io::Result<usize> {
-		self.read().await.sendto(buffer, endpoint).await
+		self.sendto(buffer, endpoint).await
 	}
 
 	async fn recvfrom(&self, buffer: &mut [MaybeUninit<u8>]) -> io::Result<(usize, Endpoint)> {
-		self.read().await.recvfrom(buffer).await
+		self.recvfrom(buffer).await
 	}
 
 	async fn read(&self, buffer: &mut [u8]) -> io::Result<usize> {
-		self.read().await.read(buffer).await
+		self.read(buffer).await
 	}
 
 	async fn write(&self, buf: &[u8]) -> io::Result<usize> {
-		self.read().await.write(buf).await
+		self.write(buf).await
 	}
 
 	async fn getsockname(&self) -> io::Result<Option<Endpoint>> {
-		self.read().await.getsockname().await
+		self.getsockname().await
 	}
 
 	async fn status_flags(&self) -> io::Result<fd::StatusFlags> {
-		self.read().await.status_flags().await
+		self.status_flags().await
 	}
 
 	async fn set_status_flags(&mut self, status_flags: fd::StatusFlags) -> io::Result<()> {
-		self.write().await.set_status_flags(status_flags).await
+		self.set_status_flags(status_flags).await
 	}
 }
diff --git a/src/fd/socket/vsock.rs b/src/fd/socket/vsock.rs
@@ -421,55 +421,55 @@ impl Drop for Socket {
 }
 
 #[async_trait]
-impl ObjectInterface for async_lock::RwLock<Socket> {
+impl ObjectInterface for Socket {
 	async fn poll(&self, event: PollEvent) -> io::Result<PollEvent> {
-		self.read().await.poll(event).await
+		self.poll(event).await
 	}
 
 	async fn read(&self, buffer: &mut [u8]) -> io::Result<usize> {
-		self.read().await.read(buffer).await
+		self.read(buffer).await
 	}
 
 	async fn write(&self, buffer: &[u8]) -> io::Result<usize> {
-		self.read().await.write(buffer).await
+		self.write(buffer).await
 	}
 
 	async fn bind(&mut self, endpoint: ListenEndpoint) -> io::Result<()> {
-		self.write().await.bind(endpoint).await
+		self.bind(endpoint).await
 	}
 
 	async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {
-		self.write().await.connect(endpoint).await
+		self.connect(endpoint).await
 	}
 
 	async fn accept(
 		&mut self,
 	) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {
-		let (handle, endpoint) = self.write().await.accept().await?;
+		let (handle, endpoint) = self.accept().await?;
 		Ok((Arc::new(async_lock::RwLock::new(handle)), endpoint))
 	}
 
 	async fn getpeername(&self) -> io::Result<Option<Endpoint>> {
-		self.read().await.getpeername().await
+		self.getpeername().await
 	}
 
 	async fn getsockname(&self) -> io::Result<Option<Endpoint>> {
-		self.read().await.getsockname().await
+		self.getsockname().await
 	}
 
 	async fn listen(&mut self, backlog: i32) -> io::Result<()> {
-		self.write().await.listen(backlog).await
+		self.listen(backlog).await
 	}
 
 	async fn shutdown(&self, how: i32) -> io::Result<()> {
-		self.read().await.shutdown(how).await
+		self.shutdown(how).await
 	}
 
 	async fn status_flags(&self) -> io::Result<fd::StatusFlags> {
-		self.read().await.status_flags().await
+		self.status_flags().await
 	}
 
 	async fn set_status_flags(&mut self, status_flags: fd::StatusFlags) -> io::Result<()> {
-		self.write().await.set_status_flags(status_flags).await
+		self.set_status_flags(status_flags).await
 	}
 }
diff --git a/src/syscalls/socket/mod.rs b/src/syscalls/socket/mod.rs
@@ -588,7 +588,7 @@ pub extern "C" fn sys_socket(domain: i32, type_: i32, protocol: i32) -> i32 {
 
 	#[cfg(feature = "vsock")]
 	if domain == Af::Vsock && sock == Sock::Stream {
-		let mut socket = async_lock::RwLock::new(vsock::Socket::new());
+		let mut socket = vsock::Socket::new();
 
 		if sock_flags.contains(SockFlags::SOCK_NONBLOCK) {
 			block_on(socket.set_status_flags(fd::StatusFlags::O_NONBLOCK), None).unwrap();
@@ -610,7 +610,7 @@ pub extern "C" fn sys_socket(domain: i32, type_: i32, protocol: i32) -> i32 {
 			if sock == Sock::Dgram {
 				let handle = nic.create_udp_handle().unwrap();
 				drop(guard);
-				let mut socket = async_lock::RwLock::new(udp::Socket::new(handle, domain));
+				let mut socket = udp::Socket::new(handle, domain);
 
 				if sock_flags.contains(SockFlags::SOCK_NONBLOCK) {
 					block_on(socket.set_status_flags(fd::StatusFlags::O_NONBLOCK), None).unwrap();
@@ -626,7 +626,7 @@ pub extern "C" fn sys_socket(domain: i32, type_: i32, protocol: i32) -> i32 {
 			if sock == Sock::Stream {
 				let handle = nic.create_tcp_handle().unwrap();
 				drop(guard);
-				let mut socket = async_lock::RwLock::new(tcp::Socket::new(handle, domain));
+				let mut socket = tcp::Socket::new(handle, domain);
 
 				if sock_flags.contains(SockFlags::SOCK_NONBLOCK) {
 					block_on(socket.set_status_flags(fd::StatusFlags::O_NONBLOCK), None).unwrap();

Original file line number	Diff line number	Diff line change
`@@ -475,66 +475,63 @@ impl Drop for Socket {`
`475`	`475`	`}`
`476`	`476`
`477`	`477`	`#[async_trait]`
`478`		`-impl ObjectInterface for async_lock::RwLock<Socket> {`
	`478`	`+impl ObjectInterface for Socket {`
`479`	`479`	`async fn poll(&self, event: PollEvent) -> io::Result<PollEvent> {`
`480`		`- self.read().await.poll(event).await`
	`480`	`+ self.poll(event).await`
`481`	`481`	`}`
`482`	`482`
`483`	`483`	`async fn read(&self, buffer: &mut [u8]) -> io::Result<usize> {`
`484`		`- self.read().await.read(buffer).await`
	`484`	`+ self.read(buffer).await`
`485`	`485`	`}`
`486`	`486`
`487`	`487`	`async fn write(&self, buffer: &[u8]) -> io::Result<usize> {`
`488`		`- self.read().await.write(buffer).await`
	`488`	`+ self.write(buffer).await`
`489`	`489`	`}`
`490`	`490`
`491`	`491`	`async fn bind(&mut self, endpoint: ListenEndpoint) -> io::Result<()> {`
`492`		`- self.write().await.bind(endpoint).await`
	`492`	`+ self.bind(endpoint).await`
`493`	`493`	`}`
`494`	`494`
`495`	`495`	`async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {`
`496`		`- self.write().await.connect(endpoint).await`
	`496`	`+ self.connect(endpoint).await`
`497`	`497`	`}`
`498`	`498`
`499`	`499`	`async fn accept(`
`500`	`500`	`&mut self,`
`501`	`501`	`) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {`
`502`		`- let (socket, endpoint) = self.write().await.accept().await?;`
`503`		`- Ok((`
`504`		`- Arc::new(async_lock::RwLock::new(async_lock::RwLock::new(socket))),`
`505`		`- endpoint,`
`506`		`- ))`
	`502`	`+ let (socket, endpoint) = self.accept().await?;`
	`503`	`+ Ok((Arc::new(async_lock::RwLock::new(socket)), endpoint))`
`507`	`504`	`}`
`508`	`505`
`509`	`506`	`async fn getpeername(&self) -> io::Result<Option<Endpoint>> {`
`510`		`- self.read().await.getpeername().await`
	`507`	`+ self.getpeername().await`
`511`	`508`	`}`
`512`	`509`
`513`	`510`	`async fn getsockname(&self) -> io::Result<Option<Endpoint>> {`
`514`		`- self.read().await.getsockname().await`
	`511`	`+ self.getsockname().await`
`515`	`512`	`}`
`516`	`513`
`517`	`514`	`async fn listen(&mut self, backlog: i32) -> io::Result<()> {`
`518`		`- self.write().await.listen(backlog).await`
	`515`	`+ self.listen(backlog).await`
`519`	`516`	`}`
`520`	`517`
`521`	`518`	`async fn setsockopt(&self, opt: SocketOption, optval: bool) -> io::Result<()> {`
`522`		`- self.read().await.setsockopt(opt, optval).await`
	`519`	`+ self.setsockopt(opt, optval).await`
`523`	`520`	`}`
`524`	`521`
`525`	`522`	`async fn getsockopt(&self, opt: SocketOption) -> io::Result<bool> {`
`526`		`- self.read().await.getsockopt(opt).await`
	`523`	`+ self.getsockopt(opt).await`
`527`	`524`	`}`
`528`	`525`
`529`	`526`	`async fn shutdown(&self, how: i32) -> io::Result<()> {`
`530`		`- self.read().await.shutdown(how).await`
	`527`	`+ self.shutdown(how).await`
`531`	`528`	`}`
`532`	`529`
`533`	`530`	`async fn status_flags(&self) -> io::Result<fd::StatusFlags> {`
`534`		`- self.read().await.status_flags().await`
	`531`	`+ self.status_flags().await`
`535`	`532`	`}`
`536`	`533`
`537`	`534`	`async fn set_status_flags(&mut self, status_flags: fd::StatusFlags) -> io::Result<()> {`
`538`		`- self.write().await.set_status_flags(status_flags).await`
	`535`	`+ self.set_status_flags(status_flags).await`
`539`	`536`	`}`
`540`	`537`	`}`
Original file line number	Diff line number	Diff line change
`@@ -253,44 +253,44 @@ impl Drop for Socket {`
`253`	`253`	`}`
`254`	`254`
`255`	`255`	`#[async_trait]`
`256`		`-impl ObjectInterface for async_lock::RwLock<Socket> {`
	`256`	`+impl ObjectInterface for Socket {`
`257`	`257`	`async fn poll(&self, event: PollEvent) -> io::Result<PollEvent> {`
`258`		`- self.read().await.poll(event).await`
	`258`	`+ self.poll(event).await`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`async fn bind(&mut self, endpoint: ListenEndpoint) -> io::Result<()> {`
`262`		`- self.write().await.bind(endpoint).await`
	`262`	`+ self.bind(endpoint).await`
`263`	`263`	`}`
`264`	`264`
`265`	`265`	`async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {`
`266`		`- self.write().await.connect(endpoint).await`
	`266`	`+ self.connect(endpoint).await`
`267`	`267`	`}`
`268`	`268`
`269`	`269`	`async fn sendto(&self, buffer: &[u8], endpoint: Endpoint) -> io::Result<usize> {`
`270`		`- self.read().await.sendto(buffer, endpoint).await`
	`270`	`+ self.sendto(buffer, endpoint).await`
`271`	`271`	`}`
`272`	`272`
`273`	`273`	`async fn recvfrom(&self, buffer: &mut [MaybeUninit<u8>]) -> io::Result<(usize, Endpoint)> {`
`274`		`- self.read().await.recvfrom(buffer).await`
	`274`	`+ self.recvfrom(buffer).await`
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`async fn read(&self, buffer: &mut [u8]) -> io::Result<usize> {`
`278`		`- self.read().await.read(buffer).await`
	`278`	`+ self.read(buffer).await`
`279`	`279`	`}`
`280`	`280`
`281`	`281`	`async fn write(&self, buf: &[u8]) -> io::Result<usize> {`
`282`		`- self.read().await.write(buf).await`
	`282`	`+ self.write(buf).await`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`async fn getsockname(&self) -> io::Result<Option<Endpoint>> {`
`286`		`- self.read().await.getsockname().await`
	`286`	`+ self.getsockname().await`
`287`	`287`	`}`
`288`	`288`
`289`	`289`	`async fn status_flags(&self) -> io::Result<fd::StatusFlags> {`
`290`		`- self.read().await.status_flags().await`
	`290`	`+ self.status_flags().await`
`291`	`291`	`}`
`292`	`292`
`293`	`293`	`async fn set_status_flags(&mut self, status_flags: fd::StatusFlags) -> io::Result<()> {`
`294`		`- self.write().await.set_status_flags(status_flags).await`
	`294`	`+ self.set_status_flags(status_flags).await`
`295`	`295`	`}`
`296`	`296`	`}`
Original file line number	Diff line number	Diff line change
`@@ -421,55 +421,55 @@ impl Drop for Socket {`
`421`	`421`	`}`
`422`	`422`
`423`	`423`	`#[async_trait]`
`424`		`-impl ObjectInterface for async_lock::RwLock<Socket> {`
	`424`	`+impl ObjectInterface for Socket {`
`425`	`425`	`async fn poll(&self, event: PollEvent) -> io::Result<PollEvent> {`
`426`		`- self.read().await.poll(event).await`
	`426`	`+ self.poll(event).await`
`427`	`427`	`}`
`428`	`428`
`429`	`429`	`async fn read(&self, buffer: &mut [u8]) -> io::Result<usize> {`
`430`		`- self.read().await.read(buffer).await`
	`430`	`+ self.read(buffer).await`
`431`	`431`	`}`
`432`	`432`
`433`	`433`	`async fn write(&self, buffer: &[u8]) -> io::Result<usize> {`
`434`		`- self.read().await.write(buffer).await`
	`434`	`+ self.write(buffer).await`
`435`	`435`	`}`
`436`	`436`
`437`	`437`	`async fn bind(&mut self, endpoint: ListenEndpoint) -> io::Result<()> {`
`438`		`- self.write().await.bind(endpoint).await`
	`438`	`+ self.bind(endpoint).await`
`439`	`439`	`}`
`440`	`440`
`441`	`441`	`async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {`
`442`		`- self.write().await.connect(endpoint).await`
	`442`	`+ self.connect(endpoint).await`
`443`	`443`	`}`
`444`	`444`
`445`	`445`	`async fn accept(`
`446`	`446`	`&mut self,`
`447`	`447`	`) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {`
`448`		`- let (handle, endpoint) = self.write().await.accept().await?;`
	`448`	`+ let (handle, endpoint) = self.accept().await?;`
`449`	`449`	`Ok((Arc::new(async_lock::RwLock::new(handle)), endpoint))`
`450`	`450`	`}`
`451`	`451`
`452`	`452`	`async fn getpeername(&self) -> io::Result<Option<Endpoint>> {`
`453`		`- self.read().await.getpeername().await`
	`453`	`+ self.getpeername().await`
`454`	`454`	`}`
`455`	`455`
`456`	`456`	`async fn getsockname(&self) -> io::Result<Option<Endpoint>> {`
`457`		`- self.read().await.getsockname().await`
	`457`	`+ self.getsockname().await`
`458`	`458`	`}`
`459`	`459`
`460`	`460`	`async fn listen(&mut self, backlog: i32) -> io::Result<()> {`
`461`		`- self.write().await.listen(backlog).await`
	`461`	`+ self.listen(backlog).await`
`462`	`462`	`}`
`463`	`463`
`464`	`464`	`async fn shutdown(&self, how: i32) -> io::Result<()> {`
`465`		`- self.read().await.shutdown(how).await`
	`465`	`+ self.shutdown(how).await`
`466`	`466`	`}`
`467`	`467`
`468`	`468`	`async fn status_flags(&self) -> io::Result<fd::StatusFlags> {`
`469`		`- self.read().await.status_flags().await`
	`469`	`+ self.status_flags().await`
`470`	`470`	`}`
`471`	`471`
`472`	`472`	`async fn set_status_flags(&mut self, status_flags: fd::StatusFlags) -> io::Result<()> {`
`473`		`- self.write().await.set_status_flags(status_flags).await`
	`473`	`+ self.set_status_flags(status_flags).await`
`474`	`474`	`}`
`475`	`475`	`}`