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
![[C语言]——C语言数据类型和变量](https://img-blog.csdnimg.cn/direct/fb8da936ade947449d070ee0ab58c503.png)
