使用 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;
			else
				break;
		}
        ...
   }

 

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

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

拥塞窗口的单位是报文的个数，一般是 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.o

all:
        make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
        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