【Linux TCP close】深入理解TCP协议及其源代码
深入理解TCP协议及其源代码
TCP close分析
close背后的连接终止过程
TCP协议作为一个可靠的、基于连接的流协议，要通过IP层的不可靠传输来，给上层协议提供"可靠"的数据流。
- 可靠：TCP要保证用户数据完整以及数据的顺序。
- 基于连接：启动前要建立连接，结束后要断开连接。
- 流协议：TCP的数据是以字节为单位的，而没有进行分包。
其中TCP协议的使用有建立连接和断开连接是TCP与UDP的区别之一，本文主要对TCP的close进行源码分析和运行跟踪。
首先TCP断开连接的过程是4次挥手：
- 主机1发送完自己要发送的所有数据，决定断开连接
- 主机1使用
close发送fin|ack（附带对主机2前面数据的ack），断开连接的过程开始，此时主机1的发送窗口关闭，接受窗口还在工作； - 主机2接受到主机1的
fin后，发送ack告知主机1对方的fin已收到； - 主机2继续发送数据，直到主机2发送完所有数据
- 主机2使用
close发送fin，表示自己的数据也发送完毕 - 主机1接受
fin，发送ack，告知主机2对方的fin已收到
也就是主机1和主机2连接断开的过程中，某一主机已经表示断开连接了时另一主机还可能继续发数据，当然也存在两者同时发送完毕，那就成了第3次挥手主机2的fin和第2次对主机1ack一起发送。
因为TCP是可靠的协议，所以需要Ack来保证发送的fin已到达对方，且存在两者不同时发送完数据的情况，所以通常情况下需要4次挥手。
所以TCP的close分为先后两个情况，同时关闭的情况不做描述。
TCP close源码
C语言中使用close来关闭对应的TCPSocket套接字，比如
int socket_fp = socket(AF_INET, SOCK_STREAM, 0);
close(socket_fp);
close函数通过系统调用sys_close来执行，代码位于fs/open.c中
/* fs/open.c:1191 */
SYSCALL_DEFINE1(close, unsigned int, fd)
{
int retval = __close_fd(current->files, fd);
//...
return retval;
}
系统调用又sys_close又通过fs/file.c中的__close_fd函数来释放文件指针，最终调用flip_close方法
/* fs/file.c */
int __close_fd(struct files_struct *files, unsigned fd)
{
struct file *file;
struct fdtable *fdt;
// 获得访问锁
spin_lock(&files->file_lock);
fdt = files_fdtable(files);
if (fd >= fdt->max_fds)
goto out_unlock;
file = fdt->fd[fd];
if (!file)
goto out_unlock;
rcu_assign_pointer(fdt->fd[fd], NULL);
// 释放文件描述符
__put_unused_fd(files, fd);
// 释放访问锁
spin_unlock(&files->file_lock);
// 调用flip_close方法
return filp_close(file, files);
out_unlock:
spin_unlock(&files->file_lock);
return -EBADF;
}
flip_close位于fs/open.c中。
/* fs/open.c */
int filp_close(struct file *filp, fl_owner_t id)
{
int retval = 0;
// 检测文件描述符引用数目
if (!file_count(filp)) {
printk(KERN_ERR "VFS: Close: file count is 0\n");
return 0;
}
// 调用flush方法
if (filp->f_op->flush)
retval = filp->f_op->flush(filp, id);
if (likely(!(filp->f_mode & FMODE_PATH))) {
dnotify_flush(filp, id);
locks_remove_posix(filp, id);
}
// 调用fput方法
fput(filp);
return retval;
}
位于fs/file_table.c中的fput调用fput_many，接着启动task____fput调用__fput，最终跟踪到指针函数f_op->release
/* fs/file_table.c */
static void __fput(struct file *file)
{
// ...
// 调用指针函数file->f_op->release
if (file->f_op->release)
file->f_op->release(inode, file);
// ...
}
void fput_many(struct file *file, unsigned int refs)
{
if (atomic_long_sub_and_test(refs, &file->f_count)) {
struct task_struct *task = current;
if (likely(!in_interrupt() && !(task->flags & PF_KTHREAD))) {
// 这里启动了____fput
init_task_work(&file->f_u.fu_rcuhead, ____fput);
if (!task_work_add(task, &file->f_u.fu_rcuhead, true))
return;
}
if (llist_add(&file->f_u.fu_llist, &delayed_fput_list))
schedule_delayed_work(&delayed_fput_work, 1);
}
}
void fput(struct file *file)
{
// 调用fput_many
fput_many(file, 1);
}
fp_ops->release
fp_ops->release这个指针函数在套接字初始化的时候被赋值，可以定位到函数sock_close
/* net/socket.c */
static const struct file_operations socket_file_ops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.read_iter = sock_read_iter,
.write_iter = sock_write_iter,
.poll = sock_poll,
.unlocked_ioctl = sock_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl = compat_sock_ioctl,
#endif
.mmap = sock_mmap,
.release = sock_close,
.fasync = sock_fasync,
.sendpage = sock_sendpage,
.splice_write = generic_splice_sendpage,
.splice_read = sock_splice_read,
};
通过socket_close调用__sock_release中的sock->ops->release函数
/* net/socket.c */
static void __sock_release(struct socket *sock, struct inode *inode)
{
if (sock->ops) {
struct module *owner = sock->ops->owner;
if (inode)
inode_lock(inode);
sock->ops->release(sock);
sock->sk = NULL;
if (inode)
inode_unlock(inode);
sock->ops = NULL;
module_put(owner);
}
if (sock->wq.fasync_list)
pr_err("%s: fasync list not empty!\n", __func__);
if (!sock->file) {
iput(SOCK_INODE(sock));
return;
}
sock->file = NULL;
}
static int sock_close(struct inode *inode, struct file *filp)
{
__sock_release(SOCKET_I(inode), inode);
return 0;
}
这里的sock->ops->release指针函数就根据传输层的协议不同，指向不同的函数，由于我们这里是TCP，所以最后调用inet_stream_ops->release
TCP关闭调用过程
close(socket_fd)
|
f_op->release
|---sock_close
|---sock->ops->release
|--- inet_stream_ops->release(tcp_close)
tcp_close
/* net/ipv4/tcp.c */
void tcp_close(struct sock *sk, long timeout)
{
struct sk_buff *skb;
int data_was_unread = 0;
int state;
lock_sock(sk);
sk->sk_shutdown = SHUTDOWN_MASK;
if (sk->sk_state == TCP_LISTEN) {
// 套接字处于Listen状态，将状态调整未close
tcp_set_state(sk, TCP_CLOSE);
inet_csk_listen_stop(sk);
goto adjudge_to_death;
}
// 清空buffer
while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
u32 len = TCP_SKB_CB(skb)->end_seq - TCP_SKB_CB(skb)->seq;
if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
len--;
data_was_unread += len;
__kfree_skb(skb);
}
sk_mem_reclaim(sk);
if (sk->sk_state == TCP_CLOSE)
goto adjudge_to_death;
// ...
} else if (tcp_close_state(sk)) { // 将状态设为fin_wait
tcp_send_fin(sk); // 调用tcp_send_fin(sk)
}
sk_stream_wait_close(sk, timeout);
adjudge_to_death:
// ...
}
EXPORT_SYMBOL(tcp_close);
现在进入了tcp关闭连接的关键部分，先关闭者将套接字状态由listen设为close，然后清空发送区缓存，接着通过tcp_send_fin来发送fin请求，自身进入fin_wait1状态。
第一次挥手
/* net/ipv4/tcp_output.c */
void tcp_send_fin(struct sock *sk)
{
......
// 设置flags为ack|fin
TCP_SKB_CB(skb)->flags = (TCPCB_FLAG_ACK | TCPCB_FLAG_FIN);
......
// 发送fin包
__tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_OFF);
}
第二次挥手
接着等待另一方回应，处理TCP不同状态码的函数为net\ipv4\tcp_input.c中的tcp_rcv_state_process，现在主要是等待对方对fin的ack，让套接字进入fin_wait2状态。
case TCP_FIN_WAIT1: {
// ...
// 判断ack是否正确
if (tp->snd_una != tp->write_seq)
break;
// 进入fin_wait2状态
tcp_set_state(sk, TCP_FIN_WAIT2);
sk->sk_shutdown |= SEND_SHUTDOWN;
// ...
// 设置超时定时器，超时自动关闭套接字
tmo = tcp_fin_time(sk);
if (tmo > TCP_TIMEWAIT_LEN) {
inet_csk_reset_keepalive_timer(sk, tmo - TCP_TIMEWAIT_LEN);
} else if (th->fin || sock_owned_by_user(sk)) {
inet_csk_reset_keepalive_timer(sk, tmo);
} else {
tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
goto discard;
}
break;
}
switch (sk->sk_state) {
// ...
case TCP_FIN_WAIT1:
case TCP_FIN_WAIT2:
if (sk->sk_shutdown & RCV_SHUTDOWN) {
if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
after(TCP_SKB_CB(skb)->end_seq - th->fin, tp->rcv_nxt)) {
NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
tcp_reset(sk);
return 1;
}
}
// ...
这时，另一主机收到fin，同样是tcp_rcv_state_process处理，根据状态（现在是连接建立ESTABLISHED）调用tcp_data_queue进入close_wait状态
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb){
// ...
switch (sk->sk_state){
// ...
case TCP_ESTABLISHED:
tcp_data_queue(sk, skb);
queued = 1;
break;
// ...
}
}
函数tcp_data_queue中调用了tcp_fin函数，该函数将套接字状态切换为close_wait，然后等待新数据发送ack
void tcp_fin(struct sock *sk)
{
struct tcp_sock *tp = tcp_sk(sk);
inet_csk_schedule_ack(sk);
sk->sk_shutdown |= RCV_SHUTDOWN;
sock_set_flag(sk, SOCK_DONE);
switch (sk->sk_state) {
case TCP_SYN_RECV:
case TCP_ESTABLISHED:
/* Move to CLOSE_WAIT */
tcp_set_state(sk, TCP_CLOSE_WAIT);
inet_csk_enter_pingpong_mode(sk);
break;
}
// ...
}
第三次挥手
主机2也调用了close，状态将由close_wait变为last_ack
void tcp_close(struct sock *sk, long timeout)
{
......
else if (tcp_close_state(sk)){
// tcp_close_state会将sk从close_wait状态变为last_ack
// 发送fin包
tcp_send_fin(sk);
}
}
第四次挥手
主机1，接收到fin后，回复ack，并进入time_wait，回收资源
static void tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th)
{
switch (sk->sk_state) {
......
case TCP_FIN_WAIT2:
// 收到FIN之后，发送ACK进入TIME_WAIT
tcp_send_ack(sk);
tcp_time_wait(sk, TCP_TIME_WAIT, 0);
}
}
主机2收到fin的ack后进入closed状态，回收资源
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb, struct tcphdr *th, unsigned len)
{
// ...
if (th->ack) {
// ...
case TCP_LAST_ACK:
if (tp->snd_una == tp->write_seq) {
tcp_update_metrics(sk);
// 设置socket为closed，并回收socket的资源
tcp_done(sk);
goto discard;
}
// ...
}
}
MenuOS运行跟踪
Qmenu中启动MenuOS，进入调试
上上次实验编译了一个带调试功能，且带有TCP服务器和客户端的MenuOS系统
同样打开一个终端，进入LinuxKernel目录，启动之前编译好的带调试的MenuOS
~$ cd LinuxKernel
~/LinuxKernel$ qemu-system-i386 -kernel linux-5.4.2/arch/x86/boot/bzImage -initrd rootfs.img -append "root=/dev/sda init=/init nokaslr" -s -S
进入调试
这时候虚拟机进入停止在一个黑屏界面，等待gdb的接入和下一步指令。
新开一个终端窗口，进入gdb调试。
接着分别
- 导入符号表
- 连接调试服务器
- 设置断点
jett@ubuntu:~/LinuxKernel$ gdb
(gdb) file ~/LinuxKernel/linux-5.4.2/vmlinux
Reading symbols from ~/LinuxKernel/linux-5.4.2/vmlinux...done.
(gdb) target remote:1234
Remote debugging using :1234
0x0000fff0 in ?? ()
(gdb) break start_kernel
Breakpoint 1 at 0xc1db5885: file init/main.c, line 576.
然后输入c让系统继续执行，执行到断点start_kernel ()则说明成功。
(gdb) c
Continuing.
Breakpoint 1, start_kernel () at init/main.c:576
576 {
添加新断点sys_close, tcp_close, tcp_rcv_state_process, tcp_fin, tcp_send_fin
(gdb) b sys_close
Breakpoint 3 at 0xc119fe60: file fs/open.c, line 1191.
(gdb) info b # 查看设置的断点
c让系统继续执行
启动replyhi服务
服务器经过4次sys_socketcall进入监听状态，分别是SYS_SOCKET, SYS_BIND, SYS_LISTEN, SYS_ACCEPT
启动hello客户端
continue到sys_close断点，说明客户端发送完消息，准备关闭套接字
此时可以print *sk来查看套接字的状态
在tcp_close和tcp_send_fin后函数，等待主机2ack，这是第一次挥手
主机2调用tcp_fin发送ack，接着也进行了tcp_close，第二次和第三次挥手同时进行（两者同时关闭）
接着主机1进入tcp_rcv_state_process处理函数，根据状态，向主机2通过tcp_send_fin回复ack并关闭套接字；主机2收到ack后关闭套接字
Breakpoint 4, tcp_close (sk=0xc726c6c0, timeout=0) at net/ipv4/tcp.c:2340
2340 {
(gdb) c
Continuing.
Breakpoint 6, tcp_send_fin (sk=0xc726c6c0) at net/ipv4/tcp_output.c:3122
3122 {
(gdb) c
Continuing.
Breakpoint 8, tcp_fin (sk=0xc726cd80) at net/ipv4/tcp_input.c:4146
4146 {
(gdb) c
Continuing.
Breakpoint 4, tcp_close (sk=0xc726cd80, timeout=0) at net/ipv4/tcp.c:2340
2340 {
(gdb) c
Continuing.
Breakpoint 7, tcp_rcv_state_process (sk=0xc726c6c0, skb=0xc78f7000) at net/ipv4/tcp_input.c:6126
6126 {
(gdb) c
Continuing.
Breakpoint 6, tcp_send_fin (sk=0xc726cd80) at net/ipv4/tcp_output.c:3122
3122 {
(gdb) c
Continuing.
Breakpoint 7, tcp_rcv_state_process (sk=0xc726cd80, skb=0xc78f7000) at net/ipv4/tcp_input.c:6126
6126 {
(gdb) c
Continuing.
作者：SA19225176，万有引力丶
参考资料来源：USTC Socket与系统调用深度分析
