refactor(fd): make accept, bind, connect, listen, set_status_flags mutable

mkroening · mkroening · commit ec0fc3572c9d · 2025-09-04T09:57:02.000+02:00
diff --git a/src/fd/mod.rs b/src/fd/mod.rs
@@ -233,25 +233,27 @@ pub(crate) trait ObjectInterface: Sync + Send + core::fmt::Debug {
 
 	/// `accept` a connection on a socket
 	#[cfg(any(feature = "net", feature = "vsock"))]
-	async fn accept(&self) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {
+	async fn accept(
+		&mut self,
+	) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {
 		Err(Errno::Inval)
 	}
 
 	/// initiate a connection on a socket
 	#[cfg(any(feature = "net", feature = "vsock"))]
-	async fn connect(&self, _endpoint: Endpoint) -> io::Result<()> {
+	async fn connect(&mut self, _endpoint: Endpoint) -> io::Result<()> {
 		Err(Errno::Inval)
 	}
 
 	/// `bind` a name to a socket
 	#[cfg(any(feature = "net", feature = "vsock"))]
-	async fn bind(&self, _name: ListenEndpoint) -> io::Result<()> {
+	async fn bind(&mut self, _name: ListenEndpoint) -> io::Result<()> {
 		Err(Errno::Inval)
 	}
 
 	/// `listen` for connections on a socket
 	#[cfg(any(feature = "net", feature = "vsock"))]
-	async fn listen(&self, _backlog: i32) -> io::Result<()> {
+	async fn listen(&mut self, _backlog: i32) -> io::Result<()> {
 		Err(Errno::Inval)
 	}
 
@@ -310,7 +312,7 @@ pub(crate) trait ObjectInterface: Sync + Send + core::fmt::Debug {
 	}
 
 	/// Sets the file status flags.
-	async fn set_status_flags(&self, _status_flags: StatusFlags) -> io::Result<()> {
+	async fn set_status_flags(&mut self, _status_flags: StatusFlags) -> io::Result<()> {
 		Err(Errno::Nosys)
 	}
 
diff --git a/src/fd/socket/tcp.rs b/src/fd/socket/tcp.rs
@@ -275,7 +275,7 @@ impl Socket {
 		}
 	}
 
-	async fn connect(&self, endpoint: Endpoint) -> io::Result<()> {
+	async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {
 		#[allow(irrefutable_let_patterns)]
 		if let Endpoint::Ip(endpoint) = endpoint {
 			self.with_context(|socket, cx| socket.connect(cx, endpoint, get_ephemeral_port()))
@@ -488,15 +488,17 @@ impl ObjectInterface for async_lock::RwLock<Socket> {
 		self.read().await.write(buffer).await
 	}
 
-	async fn bind(&self, endpoint: ListenEndpoint) -> io::Result<()> {
+	async fn bind(&mut self, endpoint: ListenEndpoint) -> io::Result<()> {
 		self.write().await.bind(endpoint).await
 	}
 
-	async fn connect(&self, endpoint: Endpoint) -> io::Result<()> {
-		self.read().await.connect(endpoint).await
+	async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {
+		self.write().await.connect(endpoint).await
 	}
 
-	async fn accept(&self) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {
+	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))),
@@ -512,7 +514,7 @@ impl ObjectInterface for async_lock::RwLock<Socket> {
 		self.read().await.getsockname().await
 	}
 
-	async fn listen(&self, backlog: i32) -> io::Result<()> {
+	async fn listen(&mut self, backlog: i32) -> io::Result<()> {
 		self.write().await.listen(backlog).await
 	}
 
@@ -532,7 +534,7 @@ impl ObjectInterface for async_lock::RwLock<Socket> {
 		self.read().await.status_flags().await
 	}
 
-	async fn set_status_flags(&self, status_flags: fd::StatusFlags) -> io::Result<()> {
+	async fn set_status_flags(&mut self, status_flags: fd::StatusFlags) -> io::Result<()> {
 		self.write().await.set_status_flags(status_flags).await
 	}
 }
diff --git a/src/fd/socket/udp.rs b/src/fd/socket/udp.rs
@@ -258,11 +258,11 @@ impl ObjectInterface for async_lock::RwLock<Socket> {
 		self.read().await.poll(event).await
 	}
 
-	async fn bind(&self, endpoint: ListenEndpoint) -> io::Result<()> {
+	async fn bind(&mut self, endpoint: ListenEndpoint) -> io::Result<()> {
 		self.write().await.bind(endpoint).await
 	}
 
-	async fn connect(&self, endpoint: Endpoint) -> io::Result<()> {
+	async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {
 		self.write().await.connect(endpoint).await
 	}
 
@@ -290,7 +290,7 @@ impl ObjectInterface for async_lock::RwLock<Socket> {
 		self.read().await.status_flags().await
 	}
 
-	async fn set_status_flags(&self, status_flags: fd::StatusFlags) -> io::Result<()> {
+	async fn set_status_flags(&mut self, status_flags: fd::StatusFlags) -> io::Result<()> {
 		self.write().await.set_status_flags(status_flags).await
 	}
 }
diff --git a/src/fd/socket/vsock.rs b/src/fd/socket/vsock.rs
@@ -232,7 +232,7 @@ impl Socket {
 		))))
 	}
 
-	async fn listen(&self, _backlog: i32) -> io::Result<()> {
+	async fn listen(&mut self, _backlog: i32) -> io::Result<()> {
 		Ok(())
 	}
 
@@ -434,15 +434,17 @@ impl ObjectInterface for async_lock::RwLock<Socket> {
 		self.read().await.write(buffer).await
 	}
 
-	async fn bind(&self, endpoint: ListenEndpoint) -> io::Result<()> {
+	async fn bind(&mut self, endpoint: ListenEndpoint) -> io::Result<()> {
 		self.write().await.bind(endpoint).await
 	}
 
-	async fn connect(&self, endpoint: Endpoint) -> io::Result<()> {
+	async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {
 		self.write().await.connect(endpoint).await
 	}
 
-	async fn accept(&self) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {
+	async fn accept(
+		&mut self,
+	) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {
 		let (handle, endpoint) = self.write().await.accept().await?;
 		Ok((Arc::new(async_lock::RwLock::new(handle)), endpoint))
 	}
@@ -455,7 +457,7 @@ impl ObjectInterface for async_lock::RwLock<Socket> {
 		self.read().await.getsockname().await
 	}
 
-	async fn listen(&self, backlog: i32) -> io::Result<()> {
+	async fn listen(&mut self, backlog: i32) -> io::Result<()> {
 		self.write().await.listen(backlog).await
 	}
 
@@ -467,7 +469,7 @@ impl ObjectInterface for async_lock::RwLock<Socket> {
 		self.read().await.status_flags().await
 	}
 
-	async fn set_status_flags(&self, status_flags: fd::StatusFlags) -> io::Result<()> {
+	async fn set_status_flags(&mut self, status_flags: fd::StatusFlags) -> io::Result<()> {
 		self.write().await.set_status_flags(status_flags).await
 	}
 }
diff --git a/src/syscalls/mod.rs b/src/syscalls/mod.rs
@@ -642,7 +642,7 @@ pub unsafe extern "C" fn sys_ioctl(
 			|e| -i32::from(e),
 			|v| {
 				block_on(
-					async { v.read().await.set_status_flags(status_flags).await },
+					async { v.write().await.set_status_flags(status_flags).await },
 					None,
 				)
 				.map_or_else(|e| -i32::from(e), |()| 0)
@@ -680,7 +680,7 @@ pub extern "C" fn sys_fcntl(fd: i32, cmd: i32, arg: i32) -> i32 {
 			|v| {
 				block_on(
 					async {
-						v.read()
+						v.write()
 							.await
 							.set_status_flags(fd::StatusFlags::from_bits_retain(arg))
 							.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 socket = async_lock::RwLock::new(vsock::Socket::new());
+		let mut socket = async_lock::RwLock::new(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 socket = async_lock::RwLock::new(udp::Socket::new(handle, domain));
+				let mut socket = async_lock::RwLock::new(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 socket = async_lock::RwLock::new(tcp::Socket::new(handle, domain));
+				let mut socket = async_lock::RwLock::new(tcp::Socket::new(handle, domain));
 
 				if sock_flags.contains(SockFlags::SOCK_NONBLOCK) {
 					block_on(socket.set_status_flags(fd::StatusFlags::O_NONBLOCK), None).unwrap();
@@ -650,7 +650,7 @@ pub unsafe extern "C" fn sys_accept(fd: i32, addr: *mut sockaddr, addrlen: *mut
 	obj.map_or_else(
 		|e| -i32::from(e),
 		|v| {
-			block_on(async { v.read().await.accept().await }, None).map_or_else(
+			block_on(async { v.write().await.accept().await }, None).map_or_else(
 				|e| -i32::from(e),
 				#[cfg_attr(not(feature = "net"), expect(unused_variables))]
 				|(obj, endpoint)| match endpoint {
@@ -712,7 +712,7 @@ pub extern "C" fn sys_listen(fd: i32, backlog: i32) -> i32 {
 	obj.map_or_else(
 		|e| -i32::from(e),
 		|v| {
-			block_on(async { v.read().await.listen(backlog).await }, None)
+			block_on(async { v.write().await.listen(backlog).await }, None)
 				.map_or_else(|e| -i32::from(e), |()| 0)
 		},
 	)
@@ -740,7 +740,7 @@ pub unsafe extern "C" fn sys_bind(fd: i32, name: *const sockaddr, namelen: sockl
 				}
 				let endpoint = IpListenEndpoint::from(unsafe { *name.cast::<sockaddr_in>() });
 				block_on(
-					async { v.read().await.bind(ListenEndpoint::Ip(endpoint)).await },
+					async { v.write().await.bind(ListenEndpoint::Ip(endpoint)).await },
 					None,
 				)
 				.map_or_else(|e| -i32::from(e), |()| 0)
@@ -752,7 +752,7 @@ pub unsafe extern "C" fn sys_bind(fd: i32, name: *const sockaddr, namelen: sockl
 				}
 				let endpoint = IpListenEndpoint::from(unsafe { *name.cast::<sockaddr_in6>() });
 				block_on(
-					async { v.read().await.bind(ListenEndpoint::Ip(endpoint)).await },
+					async { v.write().await.bind(ListenEndpoint::Ip(endpoint)).await },
 					None,
 				)
 				.map_or_else(|e| -i32::from(e), |()| 0)
@@ -764,7 +764,7 @@ pub unsafe extern "C" fn sys_bind(fd: i32, name: *const sockaddr, namelen: sockl
 				}
 				let endpoint = VsockListenEndpoint::from(unsafe { *name.cast::<sockaddr_vm>() });
 				block_on(
-					async { v.read().await.bind(ListenEndpoint::Vsock(endpoint)).await },
+					async { v.write().await.bind(ListenEndpoint::Vsock(endpoint)).await },
 					None,
 				)
 				.map_or_else(|e| -i32::from(e), |()| 0)
@@ -816,7 +816,7 @@ pub unsafe extern "C" fn sys_connect(fd: i32, name: *const sockaddr, namelen: so
 	obj.map_or_else(
 		|e| -i32::from(e),
 		|v| {
-			block_on(async { v.read().await.connect(endpoint).await }, None)
+			block_on(async { v.write().await.connect(endpoint).await }, None)
 				.map_or_else(|e| -i32::from(e), |()| 0)
 		},
 	)

Original file line number	Diff line number	Diff line change
`@@ -233,25 +233,27 @@ pub(crate) trait ObjectInterface: Sync + Send + core::fmt::Debug {`
`233`	`233`
`234`	`234`	/// `accept` a connection on a socket
`235`	`235`	`#[cfg(any(feature = "net", feature = "vsock"))]`
`236`		`- async fn accept(&self) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {`
	`236`	`+ async fn accept(`
	`237`	`+ &mut self,`
	`238`	`+ ) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {`
`237`	`239`	`Err(Errno::Inval)`
`238`	`240`	`}`
`239`	`241`
`240`	`242`	`/// initiate a connection on a socket`
`241`	`243`	`#[cfg(any(feature = "net", feature = "vsock"))]`
`242`		`- async fn connect(&self, _endpoint: Endpoint) -> io::Result<()> {`
	`244`	`+ async fn connect(&mut self, _endpoint: Endpoint) -> io::Result<()> {`
`243`	`245`	`Err(Errno::Inval)`
`244`	`246`	`}`
`245`	`247`
`246`	`248`	/// `bind` a name to a socket
`247`	`249`	`#[cfg(any(feature = "net", feature = "vsock"))]`
`248`		`- async fn bind(&self, _name: ListenEndpoint) -> io::Result<()> {`
	`250`	`+ async fn bind(&mut self, _name: ListenEndpoint) -> io::Result<()> {`
`249`	`251`	`Err(Errno::Inval)`
`250`	`252`	`}`
`251`	`253`
`252`	`254`	/// `listen` for connections on a socket
`253`	`255`	`#[cfg(any(feature = "net", feature = "vsock"))]`
`254`		`- async fn listen(&self, _backlog: i32) -> io::Result<()> {`
	`256`	`+ async fn listen(&mut self, _backlog: i32) -> io::Result<()> {`
`255`	`257`	`Err(Errno::Inval)`
`256`	`258`	`}`
`257`	`259`
`@@ -310,7 +312,7 @@ pub(crate) trait ObjectInterface: Sync + Send + core::fmt::Debug {`
`310`	`312`	`}`
`311`	`313`
`312`	`314`	`/// Sets the file status flags.`
`313`		`- async fn set_status_flags(&self, _status_flags: StatusFlags) -> io::Result<()> {`
	`315`	`+ async fn set_status_flags(&mut self, _status_flags: StatusFlags) -> io::Result<()> {`
`314`	`316`	`Err(Errno::Nosys)`
`315`	`317`	`}`
`316`	`318`
Original file line number	Diff line number	Diff line change
`@@ -275,7 +275,7 @@ impl Socket {`
`275`	`275`	`}`
`276`	`276`	`}`
`277`	`277`
`278`		`- async fn connect(&self, endpoint: Endpoint) -> io::Result<()> {`
	`278`	`+ async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {`
`279`	`279`	`#[allow(irrefutable_let_patterns)]`
`280`	`280`	`if let Endpoint::Ip(endpoint) = endpoint {`
`281`	`281`	`self.with_context(\|socket, cx\| socket.connect(cx, endpoint, get_ephemeral_port()))`
`@@ -488,15 +488,17 @@ impl ObjectInterface for async_lock::RwLock<Socket> {`
`488`	`488`	`self.read().await.write(buffer).await`
`489`	`489`	`}`
`490`	`490`
`491`		`- async fn bind(&self, endpoint: ListenEndpoint) -> io::Result<()> {`
	`491`	`+ async fn bind(&mut self, endpoint: ListenEndpoint) -> io::Result<()> {`
`492`	`492`	`self.write().await.bind(endpoint).await`
`493`	`493`	`}`
`494`	`494`
`495`		`- async fn connect(&self, endpoint: Endpoint) -> io::Result<()> {`
`496`		`- self.read().await.connect(endpoint).await`
	`495`	`+ async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {`
	`496`	`+ self.write().await.connect(endpoint).await`
`497`	`497`	`}`
`498`	`498`
`499`		`- async fn accept(&self) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {`
	`499`	`+ async fn accept(`
	`500`	`+ &mut self,`
	`501`	`+ ) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {`
`500`	`502`	`let (socket, endpoint) = self.write().await.accept().await?;`
`501`	`503`	`Ok((`
`502`	`504`	`Arc::new(async_lock::RwLock::new(async_lock::RwLock::new(socket))),`
`@@ -512,7 +514,7 @@ impl ObjectInterface for async_lock::RwLock<Socket> {`
`512`	`514`	`self.read().await.getsockname().await`
`513`	`515`	`}`
`514`	`516`
`515`		`- async fn listen(&self, backlog: i32) -> io::Result<()> {`
	`517`	`+ async fn listen(&mut self, backlog: i32) -> io::Result<()> {`
`516`	`518`	`self.write().await.listen(backlog).await`
`517`	`519`	`}`
`518`	`520`
`@@ -532,7 +534,7 @@ impl ObjectInterface for async_lock::RwLock<Socket> {`
`532`	`534`	`self.read().await.status_flags().await`
`533`	`535`	`}`
`534`	`536`
`535`		`- async fn set_status_flags(&self, status_flags: fd::StatusFlags) -> io::Result<()> {`
	`537`	`+ async fn set_status_flags(&mut self, status_flags: fd::StatusFlags) -> io::Result<()> {`
`536`	`538`	`self.write().await.set_status_flags(status_flags).await`
`537`	`539`	`}`
`538`	`540`	`}`
Original file line number	Diff line number	Diff line change
`@@ -258,11 +258,11 @@ impl ObjectInterface for async_lock::RwLock<Socket> {`
`258`	`258`	`self.read().await.poll(event).await`
`259`	`259`	`}`
`260`	`260`
`261`		`- async fn bind(&self, endpoint: ListenEndpoint) -> io::Result<()> {`
	`261`	`+ async fn bind(&mut self, endpoint: ListenEndpoint) -> io::Result<()> {`
`262`	`262`	`self.write().await.bind(endpoint).await`
`263`	`263`	`}`
`264`	`264`
`265`		`- async fn connect(&self, endpoint: Endpoint) -> io::Result<()> {`
	`265`	`+ async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {`
`266`	`266`	`self.write().await.connect(endpoint).await`
`267`	`267`	`}`
`268`	`268`
`@@ -290,7 +290,7 @@ impl ObjectInterface for async_lock::RwLock<Socket> {`
`290`	`290`	`self.read().await.status_flags().await`
`291`	`291`	`}`
`292`	`292`
`293`		`- async fn set_status_flags(&self, status_flags: fd::StatusFlags) -> io::Result<()> {`
	`293`	`+ async fn set_status_flags(&mut self, status_flags: fd::StatusFlags) -> io::Result<()> {`
`294`	`294`	`self.write().await.set_status_flags(status_flags).await`
`295`	`295`	`}`
`296`	`296`	`}`
Original file line number	Diff line number	Diff line change
`@@ -232,7 +232,7 @@ impl Socket {`
`232`	`232`	`))))`
`233`	`233`	`}`
`234`	`234`
`235`		`- async fn listen(&self, _backlog: i32) -> io::Result<()> {`
	`235`	`+ async fn listen(&mut self, _backlog: i32) -> io::Result<()> {`
`236`	`236`	`Ok(())`
`237`	`237`	`}`
`238`	`238`
`@@ -434,15 +434,17 @@ impl ObjectInterface for async_lock::RwLock<Socket> {`
`434`	`434`	`self.read().await.write(buffer).await`
`435`	`435`	`}`
`436`	`436`
`437`		`- async fn bind(&self, endpoint: ListenEndpoint) -> io::Result<()> {`
	`437`	`+ async fn bind(&mut self, endpoint: ListenEndpoint) -> io::Result<()> {`
`438`	`438`	`self.write().await.bind(endpoint).await`
`439`	`439`	`}`
`440`	`440`
`441`		`- async fn connect(&self, endpoint: Endpoint) -> io::Result<()> {`
	`441`	`+ async fn connect(&mut self, endpoint: Endpoint) -> io::Result<()> {`
`442`	`442`	`self.write().await.connect(endpoint).await`
`443`	`443`	`}`
`444`	`444`
`445`		`- async fn accept(&self) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {`
	`445`	`+ async fn accept(`
	`446`	`+ &mut self,`
	`447`	`+ ) -> io::Result<(Arc<async_lock::RwLock<dyn ObjectInterface>>, Endpoint)> {`
`446`	`448`	`let (handle, endpoint) = self.write().await.accept().await?;`
`447`	`449`	`Ok((Arc::new(async_lock::RwLock::new(handle)), endpoint))`
`448`	`450`	`}`
`@@ -455,7 +457,7 @@ impl ObjectInterface for async_lock::RwLock<Socket> {`
`455`	`457`	`self.read().await.getsockname().await`
`456`	`458`	`}`
`457`	`459`
`458`		`- async fn listen(&self, backlog: i32) -> io::Result<()> {`
	`460`	`+ async fn listen(&mut self, backlog: i32) -> io::Result<()> {`
`459`	`461`	`self.write().await.listen(backlog).await`
`460`	`462`	`}`
`461`	`463`
`@@ -467,7 +469,7 @@ impl ObjectInterface for async_lock::RwLock<Socket> {`
`467`	`469`	`self.read().await.status_flags().await`
`468`	`470`	`}`
`469`	`471`
`470`		`- async fn set_status_flags(&self, status_flags: fd::StatusFlags) -> io::Result<()> {`
	`472`	`+ async fn set_status_flags(&mut self, status_flags: fd::StatusFlags) -> io::Result<()> {`
`471`	`473`	`self.write().await.set_status_flags(status_flags).await`
`472`	`474`	`}`
`473`	`475`	`}`