[linux] 使用 kprobe 观察 tcp 拥塞窗口的变化

tcp 中拥塞窗口用来做拥塞控制。在发送侧，要发送数据的时候会基于拥塞窗口进行判断，当前这个包还能不能发送出去。
tcp 发包函数是 tcp_write_xmit()，在这个函数中调用 tcp_cwnd_test() 来判断当前拥塞窗口让不让发包。从 tcp_cwnd_test() 函数能看出来，in_flight 是已经发送出去，但是还没有被确认的包，如果这个数大于拥塞窗口，那么就返回 0，不能发包了，因为没有确认的包太多了，再发送可能加重网络拥塞，所以就返回 0。如果没确认的包比拥塞窗口小，那么至少可以再发送一个包。

/* Can at least one segment of SKB be sent right now, according to the* congestion window rules?  If so, return how many segments are allowed.*/
static inline unsigned int tcp_cwnd_test(const struct tcp_sock *tp,const struct sk_buff *skb)
{u32 in_flight, cwnd, halfcwnd;/* Don't be strict about the congestion window for the final FIN.  */if ((TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) &&tcp_skb_pcount(skb) == 1)return 1;in_flight = tcp_packets_in_flight(tp);cwnd = tp->snd_cwnd;if (in_flight >= cwnd)return 0;/* For better scheduling, ensure we have at least* 2 GSO packets in flight.*/halfcwnd = max(cwnd >> 1, 1U);return min(halfcwnd, cwnd - in_flight);
}static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,int push_one, gfp_t gfp)
{...while ((skb = tcp_send_head(sk))) {...cwnd_quota = tcp_cwnd_test(tp, skb);if (!cwnd_quota) {if (push_one == 2)/* Force out a loss probe pkt. */cwnd_quota = 1;elsebreak;}...}

拥塞窗口和接收窗口以及发送窗口的单位是不一样的。

接收窗口和发送窗口的单位是字节。

拥塞窗口的单位是报文的个数，一般是 mss。

本文不涉及 tcp 的拥塞控制算法，只记录使用 kprobe 来观察 tcp 拥塞窗口这样一种方法。

1 tcp 服务端与客户端

本人的测试环境是在 windows 笔记本和 ubuntu 虚拟机。

服务端在 windows 上，使用如下链接的工具来创建。

TCP/UDP测试工具下载 V2.1.1绿色免费版--pc6下载站

客户端在 ubuntu 虚拟机上，代码如下。建立连接之后，客户端就一直发送报文，之所以使用死循环狂发报文，是因为这样能构造出发送窗口减小或者丢包的情况。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>#define SERVER_PORT   (12345)
#define SERVER_IP     "192.168.74.1"
#define MAX_BUFSIZE   (512)int main(int argc,char *argv[]) {int sock_fd;sock_fd = socket(AF_INET, SOCK_STREAM, 0);if(sock_fd < 0) {printf("create socket error.\n");return -1;}struct sockaddr_in addr_serv;memset(&addr_serv, 0, sizeof(addr_serv));addr_serv.sin_family = AF_INET;addr_serv.sin_port =  htons(SERVER_PORT);addr_serv.sin_addr.s_addr = inet_addr(SERVER_IP);if(connect(sock_fd, (struct sockaddr *)&addr_serv,sizeof(struct sockaddr)) < 0){printf("connect error.\n");return -1;}char buff[1024] = "hello tcp, hello woasdfasdfasdfasdfasdfgasdfgasdfgasdfgsdfgsdfgsdfgsdfgsdfgsdfgsdfgfgsdfgsdfgsasdfadasfasdfasdfasdfasdfadfasdfsdfsdfasd";for (;;) {send(sock_fd, buff, 1000, 0);}close(sock_fd);return 0;
}

2 kprobe 内核模块

kprobe 通过内核模块来完成，探测的函数是 tcp_slow_start()。从名字也可以看出来，这个函数是在慢启动阶段，将拥塞窗口逐渐增大的。tcp 测试使用的端口号是 12345，但是在 struct inet_sock 结构体中，还需要做一下字节序转换，12345 转换之后是 14640。在函数 tcp_slow_start() 被调用时，会打印出源端口号，目标端口号，发送拥塞窗口，acked，发送窗口等信息。

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/kprobes.h>
#include <linux/tcp.h>
#include <net/sock.h>#define MAX_SYMBOL_LEN  64
static char symbol[MAX_SYMBOL_LEN] = "tcp_slow_start";
module_param_string(symbol, symbol, sizeof(symbol), 0644);static struct kprobe kp = {.symbol_name    = symbol,
};static int __kprobes handler_pre(struct kprobe *p, struct pt_regs *regs)
{struct tcp_sock *tp = (struct tcp_sock *)(regs->di);unsigned int acked = (unsigned int)(regs->si);struct inet_sock *inet = (struct inet_sock *)(tp);if (inet->inet_dport == 14640 || inet->inet_sport == 14640) {printk("handler pre stack, -------------------------------\n");printk("dport = %d, sport = %d, snd cwnd = %d, acked = %u, slow start thresh = %d, cwnd max = %d, max packets out = %d, snd wnd = %d\n",inet->inet_dport, inet->inet_sport, tp->snd_cwnd, acked, tp->snd_ssthresh, tp->snd_cwnd_clamp, tp->max_packets_out, tp->snd_wnd);dump_stack();printk("handler pre stack end, ---------------------------\n");}return 0;
}static void __kprobes handler_post(struct kprobe *p, struct pt_regs *regs,unsigned long flags)
{
}static int __init kprobe_init(void)
{int ret;kp.pre_handler = handler_pre;kp.post_handler = handler_post;ret = register_kprobe(&kp);if (ret < 0) {printk("register_kprobe failed, returned %d\n", ret);return ret;}printk("kprobe at %p\n", kp.addr);return 0;
}static void __exit kprobe_exit(void)
{unregister_kprobe(&kp);printk("kprobe at %p unregistered\n", kp.addr);
}

编译脚本：

root@wangyanlong-virtual-machine:/home/wyl/mod/kprobe# cat Makefile
obj-m += kprobe.oall:make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modulesclean:make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

内核模块中还打印了 tcp_slow_start() 的调用栈，如下是一次打印的截图。

如下是 tcp_slow_start() 的代码，从代码中可以看出，这次 ack 确认了几个报文，那么拥塞窗口就会增加几个。但是拥塞窗口也是有最大限制的，不能大于 snd_cwnd_clamp。

u32 tcp_slow_start(struct tcp_sock *tp, u32 acked)
{u32 cwnd = min(tp->snd_cwnd + acked, tp->snd_ssthresh);acked -= cwnd - tp->snd_cwnd;tp->snd_cwnd = min(cwnd, tp->snd_cwnd_clamp);return acked;
}

3 结果

从下图可以看出来以下几点：

（1）拥塞窗口的初始大小是 10，slow start thresh 的初始值是一个很大的数。在 tcp_sock_init() 函数中进行赋值的。

void tcp_init_sock(struct sock *sk)
{...tp->snd_cwnd = TCP_INIT_CWND;tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;...
}

#define TCP_INIT_CWND 10

#define TCP_INFINITE_SSTHRESH 0x7fffffff

（2）慢启动阶段，拥塞窗口会逐渐增大，增大的个数就是 acked 所表示的确认的报文个数

（3）当丢包或者发送窗口变为 0 的时候，表示可能发生了拥塞，这个时候拥塞窗口会减小，然后再逐渐恢复

https://www.cnblogs.com/zafu/p/10646188.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/720260.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！