Skip to content

Commit 37cef00

Browse files
Samuka007Samuka007
authored
fix(net): Fix TCP Unresponsiveness and Inability to Close Connections (#791)
* fix(net): Improve stability. 为RawSocket与UdpSocket实现close时调用close方法，符合smoltcp的行为。为SocketInode实现drop，保证程序任何情况下退出时都能正确close对应socket, 释放被占用的端口。 * fix(net): Correct socket close behavior.
1 parent b941261 commit 37cef00

File tree

4 files changed

+143
-134
lines changed

4 files changed

+143
-134
lines changed

‎kernel/src/net/net_core.rs

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -217,6 +217,9 @@ fn send_event(sockets: &smoltcp::iface::SocketSet) -> Result<(), SystemError> {
217217
if inner_socket.state() == smoltcp::socket::tcp::State::Established {
218218
events |= TcpSocket::CAN_CONNECT;
219219
}
220+
if inner_socket.state() == smoltcp::socket::tcp::State::CloseWait {
221+
events |= EPollEventType::EPOLLHUP.bits() as u64;
222+
}
220223
handle_guard
221224
.get(&global_handle)
222225
.unwrap()
@@ -226,13 +229,11 @@ fn send_event(sockets: &smoltcp::iface::SocketSet) -> Result<(), SystemError> {
226229
smoltcp::socket::Socket::Dhcpv4(_) => {}
227230
smoltcp::socket::Socket::Dns(_) => unimplemented!("Dns socket hasn't unimplemented"),
228231
}
229-
drop(handle_guard);
230-
let mut handle_guard = HANDLE_MAP.write_irqsave();
231-
let handle_item = handle_guard.get_mut(&global_handle).unwrap();
232232
EventPoll::wakeup_epoll(
233233
&handle_item.epitems,
234234
EPollEventType::from_bits_truncate(events as u32),
235235
)?;
236+
drop(handle_guard);
236237
// crate::kdebug!(
237238
// "{} send_event {:?}",
238239
// handle,

‎kernel/src/net/socket/inet.rs

Lines changed: 98 additions & 102 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,11 @@
11
use alloc::{boxed::Box, sync::Arc, vec::Vec};
22
use smoltcp::{
3-
socket::{raw, tcp, udp, AnySocket},
3+
socket::{raw, tcp, udp},
44
wire,
55
};
66
use system_error::SystemError;
77

88
use crate::{
9-
arch::rand::rand,
109
driver::net::NetDevice,
1110
kerror, kwarn,
1211
libs::rwlock::RwLock,
@@ -88,7 +87,11 @@ impl RawSocket {
8887
impl Socket for RawSocket {
8988
fn close(&mut self) {
9089
let mut socket_set_guard = SOCKET_SET.lock_irqsave();
91-
socket_set_guard.remove(self.handle.smoltcp_handle().unwrap()); // 删除的时候，会发送一条FINISH的信息？
90+
if let smoltcp::socket::Socket::Udp(mut sock) =
91+
socket_set_guard.remove(self.handle.smoltcp_handle().unwrap())
92+
{
93+
sock.close();
94+
}
9295
drop(socket_set_guard);
9396
poll_ifaces();
9497
}
@@ -289,7 +292,7 @@ impl UdpSocket {
289292
ip.port = PORT_MANAGER.get_ephemeral_port(self.metadata.socket_type)?;
290293
}
291294
// 检测端口是否已被占用
292-
PORT_MANAGER.bind_port(self.metadata.socket_type, ip.port, self.clone())?;
295+
PORT_MANAGER.bind_port(self.metadata.socket_type, ip.port)?;
293296

294297
let bind_res = if ip.addr.is_unspecified() {
295298
socket.bind(ip.port)
@@ -310,7 +313,11 @@ impl UdpSocket {
310313
impl Socket for UdpSocket {
311314
fn close(&mut self) {
312315
let mut socket_set_guard = SOCKET_SET.lock_irqsave();
313-
socket_set_guard.remove(self.handle.smoltcp_handle().unwrap()); // 删除的时候，会发送一条FINISH的信息？
316+
if let smoltcp::socket::Socket::Udp(mut sock) =
317+
socket_set_guard.remove(self.handle.smoltcp_handle().unwrap())
318+
{
319+
sock.close();
320+
}
314321
drop(socket_set_guard);
315322
poll_ifaces();
316323
}
@@ -559,11 +566,20 @@ impl TcpSocket {
559566
impl Socket for TcpSocket {
560567
fn close(&mut self) {
561568
for handle in self.handles.iter() {
562-
let mut socket_set_guard = SOCKET_SET.lock_irqsave();
563-
socket_set_guard.remove(handle.smoltcp_handle().unwrap()); // 删除的时候，会发送一条FINISH的信息？
564-
drop(socket_set_guard);
569+
{
570+
let mut socket_set_guard = SOCKET_SET.lock_irqsave();
571+
let smoltcp_handle = handle.smoltcp_handle().unwrap();
572+
socket_set_guard
573+
.get_mut::<smoltcp::socket::tcp::Socket>(smoltcp_handle)
574+
.close();
575+
drop(socket_set_guard);
576+
}
577+
poll_ifaces();
578+
SOCKET_SET
579+
.lock_irqsave()
580+
.remove(handle.smoltcp_handle().unwrap());
581+
// kdebug!("[Socket] [TCP] Close: {:?}", handle);
565582
}
566-
poll_ifaces();
567583
}
568584

569585
fn read(&self, buf: &mut [u8]) -> (Result<usize, SystemError>, Endpoint) {
@@ -627,7 +643,7 @@ impl Socket for TcpSocket {
627643
drop(socket_set_guard);
628644
SocketHandleItem::sleep(
629645
self.socket_handle(),
630-
EPollEventType::EPOLLIN.bits() as u64,
646+
(EPollEventType::EPOLLIN.bits() | EPollEventType::EPOLLHUP.bits()) as u64,
631647
HANDLE_MAP.read_irqsave(),
632648
);
633649
}
@@ -697,7 +713,7 @@ impl Socket for TcpSocket {
697713
if let Endpoint::Ip(Some(ip)) = endpoint {
698714
let temp_port = PORT_MANAGER.get_ephemeral_port(self.metadata.socket_type)?;
699715
// 检测端口是否被占用
700-
PORT_MANAGER.bind_port(self.metadata.socket_type, temp_port, self.clone())?;
716+
PORT_MANAGER.bind_port(self.metadata.socket_type, temp_port)?;
701717

702718
// kdebug!("temp_port: {}", temp_port);
703719
let iface: Arc<dyn NetDevice> = NET_DEVICES.write_irqsave().get(&0).unwrap().clone();
@@ -750,7 +766,7 @@ impl Socket for TcpSocket {
750766

751767
/// @brief tcp socket 监听 local_endpoint 端口
752768
///
753-
/// @param backlog 未处理的连接队列的最大长度. 由于smoltcp不支持backlog，所以这个参数目前无效
769+
/// @param backlog 未处理的连接队列的最大长度
754770
fn listen(&mut self, backlog: usize) -> Result<(), SystemError> {
755771
if self.is_listening {
756772
return Ok(());
@@ -763,12 +779,14 @@ impl Socket for TcpSocket {
763779
let backlog = handlen.max(backlog);
764780

765781
// 添加剩余需要构建的socket
766-
// kdebug!("tcp socket:before listen, socket'len={}",self.handle.len());
782+
// kdebug!("tcp socket:before listen, socket'len={}", self.handle_list.len());
767783
let mut handle_guard = HANDLE_MAP.write_irqsave();
784+
let wait_queue = Arc::clone(&handle_guard.get(&self.socket_handle()).unwrap().wait_queue);
785+
768786
self.handles.extend((handlen..backlog).map(|_| {
769787
let socket = Self::create_new_socket();
770788
let handle = GlobalSocketHandle::new_smoltcp_handle(sockets.add(socket));
771-
let handle_item = SocketHandleItem::new();
789+
let handle_item = SocketHandleItem::new(Some(wait_queue.clone()));
772790
handle_guard.insert(handle, handle_item);
773791
handle
774792
}));
@@ -797,7 +815,7 @@ impl Socket for TcpSocket {
797815
}
798816

799817
// 检测端口是否已被占用
800-
PORT_MANAGER.bind_port(self.metadata.socket_type, ip.port, self.clone())?;
818+
PORT_MANAGER.bind_port(self.metadata.socket_type, ip.port)?;
801819
// kdebug!("tcp socket:bind, socket'len={}",self.handle.len());
802820

803821
self.local_endpoint = Some(ip);
@@ -818,100 +836,78 @@ impl Socket for TcpSocket {
818836
}
819837

820838
fn accept(&mut self) -> Result<(Box<dyn Socket>, Endpoint), SystemError> {
839+
if !self.is_listening {
840+
return Err(SystemError::EINVAL);
841+
}
821842
let endpoint = self.local_endpoint.ok_or(SystemError::EINVAL)?;
822843
loop {
823844
// kdebug!("tcp accept: poll_ifaces()");
824845
poll_ifaces();
825-
// kdebug!("tcp socket:accept, socket'len={}",self.handle.len());
826-
827-
let mut sockets = SOCKET_SET.lock_irqsave();
828-
829-
// 随机获取访问的socket的handle
830-
let index: usize = rand() % self.handles.len();
831-
let handle = self.handles.get(index).unwrap();
832-
833-
let socket = sockets
834-
.iter_mut()
835-
.find(|y| {
836-
tcp::Socket::downcast(y.1)
837-
.map(|y| y.is_active())
838-
.unwrap_or(false)
839-
})
840-
.map(|y| tcp::Socket::downcast_mut(y.1).unwrap());
841-
if let Some(socket) = socket {
842-
if socket.is_active() {
843-
// kdebug!("tcp accept: socket.is_active()");
844-
let remote_ep = socket.remote_endpoint().ok_or(SystemError::ENOTCONN)?;
845-
846-
let new_socket = {
847-
// The new TCP socket used for sending and receiving data.
848-
let mut tcp_socket = Self::create_new_socket();
849-
self.do_listen(&mut tcp_socket, endpoint)
850-
.expect("do_listen failed");
851-
852-
// tcp_socket.listen(endpoint).unwrap();
853-
854-
// 之所以把old_handle存入new_socket, 是因为当前时刻，smoltcp已经把old_handle对应的socket与远程的endpoint关联起来了
855-
// 因此需要再为当前的socket分配一个新的handle
856-
let new_handle =
857-
GlobalSocketHandle::new_smoltcp_handle(sockets.add(tcp_socket));
858-
let old_handle = ::core::mem::replace(
859-
&mut *self.handles.get_mut(index).unwrap(),
860-
new_handle,
861-
);
862-
863-
let metadata = SocketMetadata::new(
864-
SocketType::Tcp,
865-
Self::DEFAULT_TX_BUF_SIZE,
866-
Self::DEFAULT_RX_BUF_SIZE,
867-
Self::DEFAULT_METADATA_BUF_SIZE,
868-
self.metadata.options,
869-
);
870-
871-
let new_socket = Box::new(TcpSocket {
872-
handles: vec![old_handle],
873-
local_endpoint: self.local_endpoint,
874-
is_listening: false,
875-
metadata,
876-
});
877-
// kdebug!("tcp socket:after accept, socket'len={}",new_socket.handle.len());
878-
879-
// 更新端口与 socket 的绑定
880-
if let Some(Endpoint::Ip(Some(ip))) = self.endpoint() {
881-
PORT_MANAGER.unbind_port(self.metadata.socket_type, ip.port)?;
882-
PORT_MANAGER.bind_port(
883-
self.metadata.socket_type,
884-
ip.port,
885-
*new_socket.clone(),
886-
)?;
887-
}
888-
889-
// 更新handle表
890-
let mut handle_guard = HANDLE_MAP.write_irqsave();
891-
// 先删除原来的
892-
893-
let item = handle_guard.remove(&old_handle).unwrap();
894-
895-
// 按照smoltcp行为，将新的handle绑定到原来的item
896-
handle_guard.insert(new_handle, item);
897-
let new_item = SocketHandleItem::new();
898-
899-
// 插入新的item
900-
handle_guard.insert(old_handle, new_item);
901-
902-
new_socket
903-
};
904-
// kdebug!("tcp accept: new socket: {:?}", new_socket);
905-
drop(sockets);
906-
poll_ifaces();
907-
908-
return Ok((new_socket, Endpoint::Ip(Some(remote_ep))));
846+
// kdebug!("tcp socket:accept, socket'len={}", self.handle_list.len());
847+
848+
let mut sockset = SOCKET_SET.lock_irqsave();
849+
// Get the corresponding activated handler
850+
let global_handle_index = self.handles.iter().position(|handle| {
851+
let con_smol_sock = sockset.get::<tcp::Socket>(handle.smoltcp_handle().unwrap());
852+
con_smol_sock.is_active()
853+
});
854+
855+
if let Some(handle_index) = global_handle_index {
856+
let con_smol_sock = sockset
857+
.get::<tcp::Socket>(self.handles[handle_index].smoltcp_handle().unwrap());
858+
859+
// kdebug!("[Socket] [TCP] Accept: {:?}", handle);
860+
// handle is connected socket's handle
861+
let remote_ep = con_smol_sock
862+
.remote_endpoint()
863+
.ok_or(SystemError::ENOTCONN)?;
864+
865+
let mut tcp_socket = Self::create_new_socket();
866+
self.do_listen(&mut tcp_socket, endpoint)?;
867+
868+
let new_handle = GlobalSocketHandle::new_smoltcp_handle(sockset.add(tcp_socket));
869+
870+
// let handle in TcpSock be the new empty handle, and return the old connected handle
871+
let old_handle = core::mem::replace(&mut self.handles[handle_index], new_handle);
872+
873+
let metadata = SocketMetadata::new(
874+
SocketType::Tcp,
875+
Self::DEFAULT_TX_BUF_SIZE,
876+
Self::DEFAULT_RX_BUF_SIZE,
877+
Self::DEFAULT_METADATA_BUF_SIZE,
878+
self.metadata.options,
879+
);
880+
881+
let sock_ret = Box::new(TcpSocket {
882+
handles: vec![old_handle],
883+
local_endpoint: self.local_endpoint,
884+
is_listening: false,
885+
metadata,
886+
});
887+
888+
{
889+
let mut handle_guard = HANDLE_MAP.write_irqsave();
890+
// 先删除原来的
891+
let item = handle_guard.remove(&old_handle).unwrap();
892+
893+
// 按照smoltcp行为，将新的handle绑定到原来的item
894+
let new_item = SocketHandleItem::new(None);
895+
handle_guard.insert(old_handle, new_item);
896+
// 插入新的item
897+
handle_guard.insert(new_handle, item);
898+
drop(handle_guard);
909899
}
900+
return Ok((sock_ret, Endpoint::Ip(Some(remote_ep))));
910901
}
911-
// kdebug!("tcp socket:before sleep, handle_guard'len={}",HANDLE_MAP.write_irqsave().len());
912902

913-
drop(sockets);
914-
SocketHandleItem::sleep(*handle, Self::CAN_ACCPET, HANDLE_MAP.read_irqsave());
903+
drop(sockset);
904+
905+
// kdebug!("[TCP] [Accept] sleeping socket with handle: {:?}", self.handles.get(0).unwrap().smoltcp_handle().unwrap());
906+
SocketHandleItem::sleep(
907+
self.socket_handle(), // NOTICE
908+
Self::CAN_ACCPET,
909+
HANDLE_MAP.read_irqsave(),
910+
);
915911
// kdebug!("tcp socket:after sleep, handle_guard'len={}",HANDLE_MAP.write_irqsave().len());
916912
}
917913
}

0 commit comments

Comments
 (0)