From fc77c474db61914ab97eb2a90dade1f62d5b9b3d Mon Sep 17 00:00:00 2001 From: Ruihan Li Date: Tue, 24 Sep 2024 13:27:17 +0800 Subject: [PATCH] Move and group methods --- kernel/libs/aster-bigtcp/src/iface/common.rs | 194 ++++++++++--------- 1 file changed, 101 insertions(+), 93 deletions(-) diff --git a/kernel/libs/aster-bigtcp/src/iface/common.rs b/kernel/libs/aster-bigtcp/src/iface/common.rs index eb63e14e9..25fc3e548 100644 --- a/kernel/libs/aster-bigtcp/src/iface/common.rs +++ b/kernel/libs/aster-bigtcp/src/iface/common.rs @@ -47,6 +47,16 @@ impl IfaceCommon { } } + pub(super) fn ipv4_addr(&self) -> Option { + self.interface.lock().ipv4_addr() + } + + pub(super) fn ext(&self) -> &E { + &self.ext + } +} + +impl IfaceCommon { /// Acquires the lock to the interface. /// /// *Lock ordering:* [`Self::sockets`] first, [`Self::interface`] second. @@ -62,53 +72,12 @@ impl IfaceCommon { ) -> SpinLockGuard, LocalIrqDisabled> { self.sockets.lock() } +} - pub(super) fn ipv4_addr(&self) -> Option { - self.interface.lock().ipv4_addr() - } - - /// Allocates an unused ephemeral port. - /// - /// We follow the port range that many Linux kernels use by default, which is 32768-60999. - /// - /// See . - fn alloc_ephemeral_port(&self) -> Option { - let mut used_ports = self.used_ports.lock(); - for port in IP_LOCAL_PORT_START..=IP_LOCAL_PORT_END { - if let Entry::Vacant(e) = used_ports.entry(port) { - e.insert(0); - return Some(port); - } - } - None - } - - #[must_use] - fn bind_port(&self, port: u16, can_reuse: bool) -> bool { - let mut used_ports = self.used_ports.lock(); - if let Some(used_times) = used_ports.get_mut(&port) { - if *used_times == 0 || can_reuse { - // FIXME: Check if the previous socket was bound with SO_REUSEADDR. - *used_times += 1; - } else { - return false; - } - } else { - used_ports.insert(port, 1); - } - true - } - - /// Releases the port so that it can be used again (if it is not being reused). - pub(crate) fn release_port(&self, port: u16) { - let mut used_ports = self.used_ports.lock(); - if let Some(used_times) = used_ports.remove(&port) { - if used_times != 1 { - used_ports.insert(port, used_times - 1); - } - } - } +const IP_LOCAL_PORT_START: u16 = 32768; +const IP_LOCAL_PORT_END: u16 = 60999; +impl IfaceCommon { pub(super) fn bind_socket( &self, iface: Arc>, @@ -145,11 +114,97 @@ impl IfaceCommon { Ok(bound_socket) } - /// Remove a socket from the interface + /// Allocates an unused ephemeral port. + /// + /// We follow the port range that many Linux kernels use by default, which is 32768-60999. + /// + /// See . + fn alloc_ephemeral_port(&self) -> Option { + let mut used_ports = self.used_ports.lock(); + for port in IP_LOCAL_PORT_START..=IP_LOCAL_PORT_END { + if let Entry::Vacant(e) = used_ports.entry(port) { + e.insert(0); + return Some(port); + } + } + None + } + + #[must_use] + fn bind_port(&self, port: u16, can_reuse: bool) -> bool { + let mut used_ports = self.used_ports.lock(); + if let Some(used_times) = used_ports.get_mut(&port) { + if *used_times == 0 || can_reuse { + // FIXME: Check if the previous socket was bound with SO_REUSEADDR. + *used_times += 1; + } else { + return false; + } + } else { + used_ports.insert(port, 1); + } + true + } + + fn insert_bound_socket(&self, socket: &Arc>) { + let keyable_socket = KeyableArc::from(socket.clone()); + + let inserted = self + .bound_sockets + .write_irq_disabled() + .insert(keyable_socket); + assert!(inserted); + } +} + +impl IfaceCommon { + /// Releases the port so that it can be used again (if it is not being reused). + pub(crate) fn release_port(&self, port: u16) { + let mut used_ports = self.used_ports.lock(); + if let Some(used_times) = used_ports.remove(&port) { + if used_times != 1 { + used_ports.insert(port, used_times - 1); + } + } + } + + /// Removes a socket from the interface. pub(crate) fn remove_socket(&self, handle: SocketHandle) { self.sockets.lock().remove(handle); } + pub(crate) fn remove_bound_socket_now(&self, socket: &Arc>) { + let keyable_socket = KeyableArc::from(socket.clone()); + + let removed = self + .bound_sockets + .write_irq_disabled() + .remove(&keyable_socket); + assert!(removed); + } + + pub(crate) fn remove_bound_socket_when_closed(&self, socket: &Arc>) { + let keyable_socket = KeyableArc::from(socket.clone()); + + let removed = self + .bound_sockets + .write_irq_disabled() + .remove(&keyable_socket); + assert!(removed); + + let mut closing_sockets = self.closing_sockets.lock(); + + // Check `is_closed` after holding the lock to avoid race conditions. + if keyable_socket.is_closed() { + return; + } + + let inserted = closing_sockets.insert(keyable_socket); + assert!(inserted); + } +} + +impl IfaceCommon { #[must_use] pub(super) fn poll(&self, device: &mut D) -> Option { let mut sockets = self.sockets.lock(); @@ -204,51 +259,4 @@ impl IfaceCommon { poll_at.map(|at| smoltcp::time::Instant::total_millis(&at) as u64) } - - pub(super) fn ext(&self) -> &E { - &self.ext - } - - fn insert_bound_socket(&self, socket: &Arc>) { - let keyable_socket = KeyableArc::from(socket.clone()); - - let inserted = self - .bound_sockets - .write_irq_disabled() - .insert(keyable_socket); - assert!(inserted); - } - - pub(crate) fn remove_bound_socket_now(&self, socket: &Arc>) { - let keyable_socket = KeyableArc::from(socket.clone()); - - let removed = self - .bound_sockets - .write_irq_disabled() - .remove(&keyable_socket); - assert!(removed); - } - - pub(crate) fn remove_bound_socket_when_closed(&self, socket: &Arc>) { - let keyable_socket = KeyableArc::from(socket.clone()); - - let removed = self - .bound_sockets - .write_irq_disabled() - .remove(&keyable_socket); - assert!(removed); - - let mut closing_sockets = self.closing_sockets.lock(); - - // Check `is_closed` after holding the lock to avoid race conditions. - if keyable_socket.is_closed() { - return; - } - - let inserted = closing_sockets.insert(keyable_socket); - assert!(inserted); - } } - -const IP_LOCAL_PORT_START: u16 = 32768; -const IP_LOCAL_PORT_END: u16 = 60999;